1. 举例

  • 委托类
  1. public class DelegateClass {
  2.     public DelegateClass() {
  3.     }
  4.     public DelegateClass(String string) {
  5.     }
  6.     public boolean add(String string, int i) {
  7.         System.out.println("This is add method: " + string + ", " + i);
  8.         return true;
  9.     }
  10.     public void update() {
  11.         System.out.println("This is update method");
  12.     }
  13. }
  • 测试
  1. public static void main(String[] args) throws Exception {
  2.     // 保留生成的FastClass类文件
  3.     System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\Temp\\CGLib\\FastClass");
  4.     Class delegateClass = DelegateClass.class;
  5.     // Java Reflect
  6.     // 反射构造类
  7.     Constructor delegateConstructor = delegateClass.getConstructor(String.class);
  8.     // 创建委托类实例
  9.     DelegateClass delegateInstance = (DelegateClass) delegateConstructor.newInstance("Tom");
  10.     // 反射方法类
  11.     Method addMethod = delegateClass.getMethod("add", String.class, int.class);
  12.     // 调用方法
  13.     addMethod.invoke(delegateInstance, "Tom", 30);
  14.     Method updateMethod = delegateClass.getMethod("update");
  15.     updateMethod.invoke(delegateInstance);
  16.     // CGLib FastClass
  17.     // FastClass动态子类实例
  18.     FastClass fastClass = FastClass.create(DelegateClass.class);
  19.     // 创建委托类实例
  20.     DelegateClass fastInstance = (DelegateClass) fastClass.newInstance(
  21.         new Class[] {String.class}, new Object[]{"Jack"});
  22.     // 调用委托类方法
  23.     fastClass.invoke("add", new Class[]{ String.class, int.class}, fastInstance, 
  24.         new Object[]{ "Jack", 25});
  25.     fastClass.invoke("update", new Class[]{}, fastInstance, new Object[]{});
  26. }

2. FastClass

FastClass不使用反射类（Constructor或Method）来调用委托类方法，而是动态生成一个新的类（继承FastClass），向类中写入委托类实例直接调用方法的语句，用模板方式解决Java语法不支持问题，同时改善Java反射性能。 动态类为委托类方法调用语句建立索引，使用者根据方法签名（方法名+参数类型）得到索引值，再通过索引值进入相应的方法调用语句，得到调用结果。

  • FastClass
  1. public abstract class FastClass{
  2.     // 委托类
  3.     private Class type;
  5.     // 子类访问构造方法
  6.     protected FastClass() {}
  7.     protected FastClass(Class type) {
  8.         this.type = type;
  9.     }
  11.     // 创建动态FastClass子类
  12.     public static FastClass create(Class type) {
  13.         // Generator：子类生成器，继承AbstractClassGenerator
  14.         Generator gen = new Generator();
  15.         gen.setType(type);
  16.         gen.setClassLoader(type.getClassLoader());
  17.         return gen.create();
  18.     }
  20.     /**
  21.      * 调用委托类方法
  22.      *
  23.      * @param name 方法名
  24.      * @param parameterTypes 方法参数类型
  25.      * @param obj 委托类实例
  26.      * @param args 方法参数对象
  27.      */
  28.     public Object invoke(String name, Class[] parameterTypes, Object obj, Object[] args) {
  29.         return invoke(getIndex(name, parameterTypes), obj, args);
  30.     }
  32.     /**
  33.      * 根据方法描述符找到方法索引
  34.      *
  35.      * @param name 方法名
  36.      * @param parameterTypes 方法参数类型
  37.      */
  38.     public abstract int getIndex(String name, Class[] parameterTypes);
  41.     /**
  42.      * 根据方法索引调用委托类方法
  43.      *
  44.      * @param index 方法索引
  45.      * @param obj 委托类实例
  46.      * @param args 方法参数对象
  47.      */
  48.     public abstract Object invoke(int index, Object obj, Object[] args);
  50.     /**
  51.      * 调用委托类构造方法
  52.      * 
  53.      * @param parameterTypes 构造方法参数类型
  54.      * @param args 构造方法参数对象
  55.      */
  56.     public Object newInstance(Class[] parameterTypes, Object[] args) throws {
  57.         return newInstance(getIndex(parameterTypes), args);
  58.     }
  60.     /**
  61.      * 根据构造方法描述符（参数类型）找到构造方法索引
  62.      *
  63.      * @param parameterTypes 构造方法参数类型
  64.      */
  65.     public abstract int getIndex(Class[] parameterTypes);
  67.     /**
  68.      * 根据构造方法索引调用委托类构造方法
  69.      *
  70.      * @param index 构造方法索引
  71.      * @param args 构造方法参数对象
  72.      */
  73.     public abstract Object newInstance(int index, Object[] args);
  75. }
  • 动态子类
  1. public class DelegateClass$$FastClassByCGLIB$$4af5b667 extends FastClass {
  3.     /**
  4.      * 动态子类构造方法
  5.      */
  6.     public DelegateClass$$FastClassByCGLIB$$4af5b667(Class delegateClass) {
  7.         super(delegateClass);
  8.     }
  9.     /**
  10.      * 根据方法签名得到方法索引
  11.      *
  12.      * @param name 方法名
  13.      * @param parameterTypes 方法参数类型
  14.      */
  15.     public int getIndex(String methodName, Class[] parameterTypes) {
  16.         switch(methodName.hashCode()) {
  18.             // 委托类方法add索引：0
  19.             case 96417:
  20.                 if (methodName.equals("add")) {
  21.                     switch(parameterTypes.length) {
  22.                         case 2:
  23.                             if (parameterTypes[0].getName().equals("java.lang.String") && 
  24.                                 parameterTypes[1].getName().equals("int")) {
  25.                                 return 0;
  26.                             }
  27.                     }
  28.                 }
  29.                 break;
  31.             // 委托类方法update索引：1
  32.             case -838846263:
  33.                 if (methodName.equals("update")) {
  34.                     switch(parameterTypes.length) {
  35.                         case 0:
  36.                             return 1;
  37.                     }
  38.                 }
  39.                 break;
  41.             // Object方法equals索引：2
  42.             case -1295482945:
  43.                 if (methodName.equals("equals")) {
  44.                     switch(parameterTypes.length) {
  45.                         case 1:
  46.                             if (parameterTypes[0].getName().equals("java.lang.Object")) {
  47.                                 return 2;
  48.                             }
  49.                     }
  50.                 }
  51.                 break;
  53.             // Object方法toString索引：3
  54.             case -1776922004:
  55.                 if (methodName.equals("toString")) {
  56.                     switch(parameterTypes.length) {
  57.                         case 0: return 3;
  58.                     }
  59.                 }
  60.                 break;
  62.             // Object方法hashCode索引：4
  63.             case 147696667:
  64.                 if (methodName.equals("hashCode")) {
  65.                     switch(parameterTypes.length) {
  66.                         case 0:
  67.                             return 4;
  68.                     }
  69.                 }
  70.         }
  71.         return -1;
  72.     }
  74.     /**
  75.      * 根据方法索引调用委托类方法
  76.      *
  77.      * @param methodIndex 方法索引
  78.      * @param delegateInstance 委托类实例
  79.      * @param parameterValues 方法参数对象
  80.      */
  81.     public Object invoke(int methodIndex, Object delegateInstance, Object[] parameterValues) {
  82.         DelegateClass instance = (DelegateClass) delegateInstance;
  83.         int index = methodIndex;
  84.         try {
  85.             switch(index) {
  86.                 case 0:
  87.                     // 委托类实例直接调用方法语句
  88.                     return new Boolean(instance.add((String)parameterValues[0], 
  89.                             ((Number)parameterValues[1]).intValue()));
  90.                 case 1:
  91.                     instance.update();
  92.                     return null;
  93.                 case 2:
  94.                     return new Boolean(instance.equals(parameterValues[0]));
  95.                 case 3:
  96.                     return instance.toString();
  97.                 case 4:
  98.                     return new Integer(instance.hashCode());
  99.             }
  100.         } catch (Throwable t) {
  101.             throw new InvocationTargetException(t);
  102.         }
  103.         throw new IllegalArgumentException("Cannot find matching method/constructor");
  104.     }
  105.     /**
  106.      * 根据构造方法描述符（参数类型）找到构造方法索引
  107.      *
  108.      * @param parameterTypes 构造方法参数类型
  109.      */
  110.     public int getIndex(Class[] parameterTypes) {
  111.         switch(parameterTypes.length) {
  112.             // 无参构造方法索引：0
  113.             case 0:
  114.                 return 0;
  116.             // 有参构造方法索引：1
  117.             case 1:
  118.                 if (parameterTypes[0].getName().equals("java.lang.String")) {
  119.                     return 1;
  120.                 }
  121.             default:
  122.                 return -1;
  123.         }
  124.     }
  126.     /**
  127.      * 根据构造方法索引调用委托类构造方法
  128.      *
  129.      * @param methodIndex 构造方法索引
  130.      * @param parameterValues 构造方法参数对象
  131.      */
  132.     public Object newInstance(int methodIndex, Object[] parameterValues) {
  133.         // 创建委托类实例
  134.         DelegateClass newInstance = new DelegateClass;
  135.         DelegateClass newObject = newInstance;
  136.         int index = methodIndex;
  137.         try {
  138.             switch(index) {
  139.                 // 调用构造方法（<init>）
  140.                 case 0:
  141.                     newObject.<init>();
  142.                     return newInstance;
  143.                 case 1:
  144.                     newObject.<init>((String)parameterValues[0]);
  145.                     return newInstance;
  146.             }
  147.         } catch (Throwable t) {
  148.             throw new InvocationTargetException(t);
  149.         }
  150.         throw new IllegalArgumentException("Cannot find matching method/constructor");
  151.     }
  152.     public int getMaxIndex() {
  153.         return 4;
  154.     }
  155. }

作者：毛小力
链接：https://www.jianshu.com/p/0604d79435f1
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。