cglib源码学习交流

最新推荐文章于 2022-08-17 20:18:52 发布
最新推荐文章于 2022-08-17 20:18:52 发布
阅读量1k 收藏
点赞数
分类专栏： 通用软件开发 文章标签： class object callback string integer immutable

 背景

前段时间在工作中，包括一些代码阅读过程中，spring aop经常性的会看到cglib中的相关内容，包括BeanCopier,BulkBean,Enancher等内容，以前虽大致知道一些内容，原理是通过bytecode，但没具体深入代码研究，只知其所用不知其所以然，所以就特地花了半天多的工作时间研究了CGLIB的相关源码，同时结合看了下 spring Aop中对CGLIB的使用。

本文主要通过对cglib有原理的分析，反编译查看源码，例子等方式做一个介绍。

cglib基本信息

  1. cglib的官方网站： http://cglib.sourceforge.net/
  2. cglib目前的最新版本应该是2.2，公司普遍使用的版本也是这个
  3. 官网的samples : http://cglib.sourceforge.net/xref/samples/

cglib代码包结构

  • core (核心代码)
    • EmitUtils
    • ReflectUtils
    • KeyFactory
    • ClassEmitter/CodeEmitter
    • NamingPolicy/DefaultNamingPolicy
    • GeneratorStrategy/DefaultGeneratorStrategy
    • DebuggingClassWriter
    • ClassGenerator/AbstractClassGenerator
  • beans (bean操作类)
    • BeanCopier
    • BulkBean
    • BeanMap
    • ImmutableBean
    • BeanGenerator
  • reflect
    • FastClass
  • proxy
    • Enhancer
    • CallbackGenerator
    • Callback
      • MethodInterceptor , Dispatcher, LazyLoader , ProxyRefDispatcher , NoOp , FixedValue , InvocationHandler(提供和jdk proxy的功能)
    • CallbackFilter
  • util
    • StringSwitcher
    • ParallelSorter
  • transform

core核心代码部分

EmitUtils

重要的工具类，主要封装了一些操作bytecode的基本函数，比如生成一个null_constructor，添加类属性add_property等

ReflectUtils

处理jdk reflect的工具类，比如获取一个类所有的Method，获取构造函数信息等。

ClassEmitter/CodeEmitter

对asm的classAdapter和MethodAdapter的实现，贯穿于cglib代码的处理

KeyFactory

类库中重要的唯一标识生成器，用于cglib做cache时做map key，比较底层的基础类。
例子：

interface BulkBeanKey {
public Object newInstance(String target, String[] getters, String[] setters, String[] types);
}
(BulkBeanKey)KeyFactory.create(BulkBeanKey.class).newInstance(targetClassName, getters, setters, typeClassNames)；

说明：

  • 每个Key接口，都必须提供newInstance方法，但具体的参数可以随意定义，通过newInstance返回的为一个唯一标示，只有当传入的所有参数的equals都返回true时，生成的key才是相同的，这就相当于多key的概念。

NamingPolicy

默认的实现类：DefaultNamingPolicy， 具体cglib动态生成类的命名控制。
一般的命名规则：

  • 被代理class name + "$$" + 使用cglib处理的class name + "ByCGLIB" + "$$" + key的hashcode
  • 示例：FastSource$$FastClassByCGLIB$$e1a36bab.class

GeneratorStrategy

默认的实现类：　DefaultGeneratorStrategy
控制ClassGenerator生成class的byte数据，中间可插入自己的处理。注意这里依赖了：DebuggingClassWriter进行class generator的处理

DebuggingClassWriter

cglib封装asm的处理类，用于生成class的byte流，通过GeneratorStrategy回调ClassGenerator.generateClass(DebuggingClassWriter)，将自定义的class byte处理回调给具体的cglib上层操作类，比如由具体的BeanCopier去控制bytecode的生成。

ClassGenerator

其中一个抽象实现：AbstractClassGenerator。cglib代码中核心的Class bytecode操作主体，包含了一些cache，调用NamingPolicy,GeneratorStrategy进行处理，可以说是一个最核心的调度者。

对应的类图：

  1. 外部的BeanCopier都包含了一Generator，继承自AbstractClassGenerator,实现了generateClass(ClassVisitor v),Object firstInstance(Class type)方法。
  2. AbstractClassGenerator自身会根据Source进行cache，所以针对已经生成过的class，这里KeyFactory对应的值要相等，则会直接返回cache中的结果。所以BeanCopier每次create慢只是每次都需要new两个对象，一个是KeyFactory.newInstance，另一个是firstInstance方法调用生成一个对象。

反编译tips

大家都知道cglib是进行bytecode操作，会动态生成class，最快最直接的学习就是结合他生成的class，对照代码进行学习，效果会好很多。

Java代码 复制代码 收藏代码
  1. system.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "指定输出目录");　 
system.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "指定输出目录");　

可参见 cores/DebuggingClassWriter代码。说明：这样cglib会将动态生成的每个class都输出到文件中，然后我们可以通过decomp进行反编译查看源码。

beans　(相关操作类)

BeanCopier

简单的示例代码就不做介绍，相信大家都指导怎么用，这里主要介绍下Convert的使用。

  • 许多网友都做过BeanCopier，BeanUtils的测试，基本BeanCopier的性能是BeanUtils的10倍以上。，出了反射这一性能差异外，BeanUtils默认是开启Converter功能，允许同名，不同类型的属性进行拷贝，比如Date对象到String属性。
  • 有兴趣的同学可以去比较下PropertyUtils，默认不开启Converter功能，发现性能是BeanUtils的2倍多。

初始化例子：BeanCopier copier = BeanCopier.create(Source.class, Target.class, true);
第三个参数useConverter，是否开启Convert，默认BeanCopier只会做同名，同类型属性的copier，否则就会报错。

Converter使用例子代码 复制代码 收藏代码
  1. public class BeanCopierTest {
  3. public static void main(String args[]) {
  4. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/tmp/1");
  5. BeanCopier copier = BeanCopier.create(Source.class, Target.class, true);
  6. Source from = new Source();
  7. from.setValue(1);
  9. Target to = new Target();
  10. Converter converter = new BigIntConverter();
  11. copier.copy(from, to, converter); //使用converter类
  13. System.out.println(to.getValue());
  14. }
  15. }
  17. class BigIntConverter implements net.sf.cglib.core.Converter {
  19. @Override
  20. public Object convert(Object value, Class target, Object context) {
  21. System.out.println(value.getClass() + " " + value); // from类中的value对象
  22. System.out.println(target); // to类中的定义的参数对象
  23. System.out.println(context.getClass() + " " + context); // String对象,具体的方法名
  24. if (target.isAssignableFrom(BigInteger.class)) {
  25. return new BigInteger(value.toString());
  26. } else {
  27. return value;
  28. }
  29. }
  31. }
  32. ----
  33. 反编译后看的代码：
  34. public class Target$$BeanCopierByCGLIB$$e1c34377 extends BeanCopier
  35. {
  36. public void copy(Object obj, Object obj1, Converter converter)
  37. {
  38. Target target = (Target)obj1;
  39. Source source = (Source)obj;
  40. // 注意是直接调用，没有通过reflect
  41. target.setValue((BigInteger)converter.convert(new Integer(source.getValue()), CGLIB$load_class$java$2Emath$2EBigInteger, "setValue"));
  42. }
  43. }

使用注意

  1. 避免每次进行BeanCopier.create创建对象，一般建议是通过static BeanCopier copier = BeanCopier.create()
  2. 合理使用converter。
  3. 应用场景：两个对象之间同名同属性的数据拷贝, 不能单独针对其中的几个属性单独拷贝

BulkBean

相比于BeanCopier，BulkBean将整个Copy的动作拆分为getPropertyValues，setPropertyValues的两个方法，允许自定义处理的属性。

Java代码 复制代码 收藏代码
  1. public class BulkBeanTest {
  3. public static void main(String args[]) {
  4. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ljh/cglib");
  5. String[] getter = new String[] { "getValue" };
  6. String[] setter = new String[] { "setValue" };
  7. Class[] clazzs = new Class[] { int.class };
  9. BulkBean bean = BulkBean.create(BulkSource.class, getter, setter, clazzs);
  10. BulkSource obj = new BulkSource();
  11. obj.setValue(1);
  13. Object[] objs = bean.getPropertyValues(obj);
  14. for (Object tmp : objs) {
  15. System.out.println(tmp);
  16. }
  17. }
  18. }
  19. class BulkSource {
  20. private int value;
  21. .....
  22. }
  24. // 反编译后的代码：　
  25. public void getPropertyValues(Object obj, Object aobj[])
  26. {
  27. BulkSource bulksource = (BulkSource)obj;
  28. aobj[0] = new Integer(bulksource.getValue());
  29. } 
public class BulkBeanTest {

    public static void main(String args[]) {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ljh/cglib");
        String[] getter = new String[] { "getValue" };
        String[] setter = new String[] { "setValue" };
        Class[] clazzs = new Class[] { int.class };

        BulkBean bean = BulkBean.create(BulkSource.class, getter, setter, clazzs);
        BulkSource obj = new BulkSource();
        obj.setValue(1);

        Object[] objs = bean.getPropertyValues(obj);
        for (Object tmp : objs) {
            System.out.println(tmp);
        }
    }
}
class BulkSource {
    private int value;
    .....
}

// 反编译后的代码：　
 public void getPropertyValues(Object obj, Object aobj[])
    {
        BulkSource bulksource = (BulkSource)obj;
        aobj[0] = new Integer(bulksource.getValue());
    }

使用注意

  1. 避免每次进行BulkBean.create创建对象，一般建议是通过static BulkBean.create copier = BulkBean.create
  2. 应用场景：针对特定属性的get,set操作，一般适用通过xml配置注入和注出的属性，运行时才确定处理的Source,Target类，只需关注属性名即可。

BeanMap

相比于BeanCopier,BulkBean，都是针对两个Pojo Bean进行处理，那如果对象一个是Pojo Bean和Map对象之间，那就得看看BeanMap，将一个java bean允许通过map的api进行调用。
几个支持的操作接口：

  • Object get(Object key)
  • Object put(Object key, Object value)
  • void putAll(Map t)
  • Set entrySet()
  • Collection values()
  • boolean containsKey(Object key)
  • ....
Java代码 复制代码 收藏代码
  1. public class BeanMapTest {
  3. public static void main(String args[]) {
  4. // 初始化
  5. BeanMap map = BeanMap.create(new Pojo());
  6. // 构造
  7. Pojo pojo = new Pojo();
  8. pojo.setIntValue(1);
  9. pojo.setBigInteger(new BigInteger("2"));
  10. // 赋值
  11. map.setBean(pojo);
  12. // 验证
  13. System.out.println(map.get("intValue"));
  14. System.out.println(map.keySet());
  15. System.out.println(map.values());
  16. }
  17. }
  19. class Pojo {
  21. private int intValue;
  22. private BigInteger bigInteger;
  23. ....
  24. }
  26. //反编译代码查看：
  27. //首先保存了所有的属性到一个set中
  28. private static FixedKeySet keys = new FixedKeySet(new String[] {
  29. "bigInteger", "intValue"
  30. });
  31. public Object get(Object obj, Object obj1)
  32. {
  33. (Pojo)obj;
  34. String s = (String)obj1;
  35. s;
  36. s.hashCode();
  37. JVM INSTR lookupswitch 2: default 72
  38. // -139068386: 40
  39. // 556050114: 52;
  40. goto _L1 _L2 _L3
  41. _L2:
  42. "bigInteger";
  43. 　//属性判断是否相等
  44. equals();
  45. JVM INSTR ifeq 73;
  46. goto _L4 _L5
  47. _L5:
  48. break MISSING_BLOCK_LABEL_73;
  49. _L4:
  50. getBigInteger();
  51. return;
  52. _L3:
  54. ....
  56. } 
public class BeanMapTest {

    public static void main(String args[]) {
        // 初始化
        BeanMap map = BeanMap.create(new Pojo());
        // 构造
        Pojo pojo = new Pojo();
        pojo.setIntValue(1);
        pojo.setBigInteger(new BigInteger("2"));
        // 赋值
        map.setBean(pojo);
        // 验证
        System.out.println(map.get("intValue"));
        System.out.println(map.keySet());
        System.out.println(map.values());
    }
}

class Pojo {

    private int        intValue;
    private BigInteger bigInteger;
    ....
}

//反编译代码查看：
//首先保存了所有的属性到一个set中
private static FixedKeySet keys = new FixedKeySet(new String[] {
        "bigInteger", "intValue"
    });
public Object get(Object obj, Object obj1)
    {
        (Pojo)obj;
        String s = (String)obj1;
        s;
        s.hashCode();
        JVM INSTR lookupswitch 2: default 72
    //                   -139068386: 40
    //                   556050114: 52;
           goto _L1 _L2 _L3
_L2:
        "bigInteger";
　//属性判断是否相等
        equals();
        JVM INSTR ifeq 73;
           goto _L4 _L5
_L5:
        break MISSING_BLOCK_LABEL_73;
_L4:
        getBigInteger();
        return;
_L3:

....

}

使用注意

  1. 避免每次进行BeanMap map = BeanMap.create();创建对象，不同于BeanCopier对象，BeanMap主要针对对象实例进行处理，所以一般建议是map.setBean(pojo);进行动态替换持有的对象实例。
  2. 应用场景：针对put,putAll操作会直接修改pojo对象里的属性，所以可以通过beanMap.putAll(map)进行map<->pojo属性的拷贝。

BeanGenerator

暂时没有想到合适的使用场景，不过BeanGenerator使用概念是很简单的，就是将一个Map<String,Class>properties的属性定义，动态生成一个pojo bean类。

Java代码 复制代码 收藏代码
  1. BeanGenerator generator = new BeanGenerator();
  2. generator.addProperty("intValue", int.class);
  3. generator.addProperty("integer", Integer.class);
  4. generator.addProperty("properties", Properties.class);
  6. Class clazz = (Class) generator.createClass();
  7. Object obj = generator.create();
  9. PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(obj.getClass());
  10. for (PropertyDescriptor getter : getters) {
  11. Method write = getter.getWriteMethod();
  12. System.out.println(write.getName());
  13. } 
BeanGenerator generator = new BeanGenerator();
generator.addProperty("intValue", int.class);
generator.addProperty("integer", Integer.class);
generator.addProperty("properties", Properties.class);
       
Class clazz = (Class) generator.createClass();
Object obj = generator.create();

PropertyDescriptor[] getters = ReflectUtils.getBeanGetters(obj.getClass());
for (PropertyDescriptor getter : getters) {
    Method write = getter.getWriteMethod();
    System.out.println(write.getName());
}

ImmutableBean

bean Immutable模式的一种动态class实现，Immutable模式主要应用于服务设计上，返回的pojo bean对象，不运行进行write方法调用。

说明

个人是不太建议使用cglib动态class的方式来实现bean Immutable的模式，Immutable模式应该是一种服务接口上的显示声明，而不是如此隐晦，而且pojo bean尽量做到是轻量级，简答的set/get方法，如果要做充血的领域模型那就另当别论了。

reflect (class,method处理)

FastClass

顾明思义，FastClass就是对Class对象进行特定的处理，比如通过数组保存method引用，因此FastClass引出了一个index下标的新概念，比如getIndex(String name, Class[] parameterTypes)就是以前的获取method的方法。
通过数组存储method,constructor等class信息，从而将原先的反射调用，转化为class.index的直接调用，从而体现所谓的FastClass。

Java代码 复制代码 收藏代码
  1. public class FastClassTest {
  2. public static void main(String args[]) throws Exception {
  3. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ljh/cglib");
  5. FastClass clazz = FastClass.create(FastSource.class);
  6. // fast class反射调用
  7. FastSource obj = (FastSource) clazz.newInstance();
  8. clazz.invoke("setValue", new Class[] { int.class }, obj, new Object[] { 1 });
  9. clazz.invoke("setOther", new Class[] { int.class }, obj, new Object[] { 2 });
  11. int value = (Integer) clazz.invoke("getValue", new Class[] {}, obj, new Object[] {});
  12. int other = (Integer) clazz.invoke("getOther", new Class[] {}, obj, new Object[] {});
  13. System.out.println(value + " " + other);
  14. // fastMethod使用
  15. FastMethod setValue = clazz.getMethod("setValue", new Class[] { int.class });
  16. System.out.println("setValue index is : " + setValue.getIndex());
  18. FastMethod getValue = clazz.getMethod("getValue", new Class[] {});
  19. System.out.println("getValue index is : " + getValue.getIndex());
  21. FastMethod setOther = clazz.getMethod("setOther", new Class[] { int.class });
  22. System.out.println("setOther index is : " + setOther.getIndex());
  24. FastMethod getOther = clazz.getMethod("getOther", new Class[] {});
  25. System.out.println("getOther index is : " + getOther.getIndex());
  26. // 其他
  27. System.out.println("getDeclaredMethods : " + clazz.getJavaClass().getDeclaredMethods().length);
  28. System.out.println("getConstructors : " + clazz.getJavaClass().getConstructors().length);
  29. System.out.println("getFields : " + clazz.getJavaClass().getFields().length);
  30. System.out.println("getMaxIndex : " + clazz.getMaxIndex());
  31. }
  32. }
  34. class FastSource {
  35. private int value;
  36. private int other;
  38. } 
public class FastClassTest {
    public static void main(String args[]) throws Exception {
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ljh/cglib");

        FastClass clazz = FastClass.create(FastSource.class);
        // fast class反射调用
        FastSource obj = (FastSource) clazz.newInstance();
        clazz.invoke("setValue", new Class[] { int.class }, obj, new Object[] { 1 });
        clazz.invoke("setOther", new Class[] { int.class }, obj, new Object[] { 2 });

        int value = (Integer) clazz.invoke("getValue", new Class[] {}, obj, new Object[] {});
        int other = (Integer) clazz.invoke("getOther", new Class[] {}, obj, new Object[] {});
        System.out.println(value + " " + other);
        // fastMethod使用
        FastMethod setValue = clazz.getMethod("setValue", new Class[] { int.class });
        System.out.println("setValue index is : " + setValue.getIndex());

        FastMethod getValue = clazz.getMethod("getValue", new Class[] {});
        System.out.println("getValue index is : " + getValue.getIndex());

        FastMethod setOther = clazz.getMethod("setOther", new Class[] { int.class });
        System.out.println("setOther index is : " + setOther.getIndex());

        FastMethod getOther = clazz.getMethod("getOther", new Class[] {});
        System.out.println("getOther index is : " + getOther.getIndex());
        // 其他
        System.out.println("getDeclaredMethods : " + clazz.getJavaClass().getDeclaredMethods().length);
        System.out.println("getConstructors : " + clazz.getJavaClass().getConstructors().length);
        System.out.println("getFields : " + clazz.getJavaClass().getFields().length);
        System.out.println("getMaxIndex : " + clazz.getMaxIndex());
    }
}

class FastSource {
    private int value;
    private int other;

}

proxy (spring aop相关)

总体类结构图：

Callback & CallbackGenerator

  1. MethodInterceptor
    • 类似于spring aop的around Advise的功能，大家都知道，不多做介绍。唯一需要注意的就是proxy.invokeSuper和proxy.invoke的区别。invokeSuper是退出当前interceptor的处理，进入下一个callback处理，invoke则会继续回调该方法，如果传递给invoke的obj参数出错容易造成递归调用
  2. Dispatcher, ProxyRefDispatcher
    • 类似于delegate的模式，直接将请求分发给具体的Dispatcher调用，是否有着接口+实现分离的味道，将接口的方法调用通过Dispatcher转到实现target上。ProxyRefDispatcher与Dispatcher想比，loadObject()多了个当前代理对象的引用。
    • 反编译的部分代码代码 复制代码 收藏代码
      1. //反编译的部分代码
      2. public final int cal(int i, int j)
      3. {
      4. CGLIB$CALLBACK_1;
      5. if(CGLIB$CALLBACK_1 != null) goto _L2; else goto _L1
      6. _L1:
      7. JVM INSTR pop ;
      8. CGLIB$BIND_CALLBACKS(this);
      9. CGLIB$CALLBACK_1;
      10. _L2:
      11. loadObject(); //每次都进行调用
      12. (DefaultCalcService);
      13. i;
      14. j;
      15. cal(); //调用实现类的方法
      16. return;
      17. }
  3. LazyLoader
    • 相比于Dispatcher,lazyLoader在第一次获取了loadObject后，会进行缓存，后续的请求调用都会直接调用该缓存的属性.
    • 反编译部分代码代码 复制代码 收藏代码
      1. //反编译部分代码
      2. public final int cal(int i, int j)
      3. {
      4. this;
      5. return ((DefaultCalcService)CGLIB$LOAD_PRIVATE_3()).cal(i, j);
      6. }
      8. private final synchronized Object CGLIB$LOAD_PRIVATE_3()
      9. {
      10. CGLIB$LAZY_LOADER_3; //保存的属性
      11. if(CGLIB$LAZY_LOADER_3 != null) goto _L2; else goto _L1
      12. _L1:
      13. JVM INSTR pop ;
      14. this;
      15. CGLIB$CALLBACK_3;
      16. if(CGLIB$CALLBACK_3 != null) goto _L4; else goto _L3
      17. _L3:
      18. JVM INSTR pop ;
      19. CGLIB$BIND_CALLBACKS(this);
      20. CGLIB$CALLBACK_3;
      21. _L4:
      22. loadObject();
      23. JVM INSTR dup_x1 ;
      24. CGLIB$LAZY_LOADER_3;
      25. _L2:
      26. return;
      27. }
  4. NoOp
    • 不做任何处理，结合Filter针对不需要做代理方法直接返回，调用其原始方法
  5. FixedValue
    • 强制方法返回固定值,可结合Filter进行控制
  6. InvocationHandler(提供和jdk proxy的功能),不常用

CallbackFilter

主要的作用就是callback调度，主要的一个方法：int accept(Method method);
返回的int在int值，代表对应method需要插入的callback，会静态生成到class的代码中，这样是cglib proxy区别于jdk proxy的方式，一个是静态的代码调用，一个是动态的reflect。
可以查看： Enhancer类中的emitMethods方法，line:883。在构造class method字节吗之前就已经确定需要运行的callback。

Enhancer

Java代码 复制代码 收藏代码
  1. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ljh/cglib");
  2. LogInteceptor logInteceptor = new LogInteceptor();
  3. CalDispatcher calDispatcher = new CalDispatcher();
  4. CalcProxyRefDispatcher calcProxyRefDispatcher = new CalcProxyRefDispatcher();
  5. LazyLoaderCallback lazyLoaderCallback = new LazyLoaderCallback();
  7. Enhancer enhancer = new Enhancer();
  8. enhancer.setSuperclass(CalcService.class); //接口类
  9. enhancer.setCallbacks(new Callback[] { logInteceptor, calDispatcher, calcProxyRefDispatcher,lazyLoaderCallback, NoOp.INSTANCE }); // callback数组
  10. enhancer.setCallbackFilter(new CalcCallbackFilter()); // filter
  11. CalcService service = (CalcService) enhancer.create();
  13. int result = service.cal(1, 1); 
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/home/ljh/cglib");
LogInteceptor logInteceptor = new LogInteceptor();
CalDispatcher calDispatcher = new CalDispatcher();
CalcProxyRefDispatcher calcProxyRefDispatcher = new CalcProxyRefDispatcher();
LazyLoaderCallback lazyLoaderCallback = new LazyLoaderCallback();

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(CalcService.class); //接口类
enhancer.setCallbacks(new Callback[] { logInteceptor, calDispatcher, calcProxyRefDispatcher,lazyLoaderCallback, NoOp.INSTANCE }); // callback数组
enhancer.setCallbackFilter(new CalcCallbackFilter()); // filter
CalcService service = (CalcService) enhancer.create();

int result = service.cal(1, 1);

Util (工具类，感觉有点鸡肋)

  • StringSwitcher 提供string和int的map映射查询，给定一个string字符串，返回同个下标数组的int值，感觉很鸡肋，用Map不是可以很快速的实现功能
  • ParallelSorter 看了具体的代码，没啥意思，就是提供了一个二分的快速排序和多路归并排序。没有所谓的并行排序，原本以为会涉及多线程处理，可惜没有

transform

暂时没仔细研究，更多的是对asm的封装，等下次看了asm代码后再回来研究下。



转自http://agapple.iteye.com/blog/799827

ustcxjt
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cglib_2.0_beta2_API_en帮助文档.chm格式
08-11
cglib_2.0_beta2_API_en帮助文档.chm格式 文档内容和官网api一致
Hutool CglibUtil.copy报错 java.lang.ClassNotFoundException: net.sf.cglib.core.Converter
洗刷先生的博客
03-18 1929
java.lang.ClassNotFoundException: net.sf.cglib.core.Converter 或者 hutool 源代码报错 说明少引一个包
工具类BeanMap,BeanCopier
feidanmengyu的博客
03-07 747
对象之间的转换； 深度复制； 1,BeanMap 实现的是Map接口；将对象转换成Map非常简单； 2,BeanCopier 深度复制；Demo主要类： Test:/** * Created by admin on 2017/3/7. */ public class Test { public static void main(String[] args) {
BeanMap常用方法 - cglib.beans常用工具类
程序员咏哥的博客
05-08 4582
BeanCopier是Cglib包中的一个类，用于对象与Map之间相互转换。 实体类 package com.hanyong.domain; import lombok.Data; /** * SysUserDO * * @Author: han * @CreateTime: 2019-05-28 */ @Data public class SysUserDO { ...
动态代理cglibjar包和源码
05-21
动态代理cglibjar包和源码动态代理cglibjar包和源码动态代理cglibjar包和源码动态代理cglibjar包和源码动态代理cglibjar包和源码
cglib.jar源码
08-25
spring AOP中的cglib代理所依赖的jar包cglib.jar源码 net.sf.cglib.proxy
cglib-3.1源码
04-22
cglib源码，包括windows和linux版本源码。需要研究的可以下载研究。
cglib-2.2.2源码
04-22
cglib-2.2.2源码
CGLib3.2.5依赖包及源码
09-25
cglib-3.2.5.jar、cglib-nodep-3.2.5.jar、cglib-RELEASE_3_2_5.tar.gz（源码）、cglib-RELEASE_3_2_5.zip（源码）
org.springframework.cglib.beans.BeanMap的使用
gshg1203的专栏
12-20 4499
org.springframework.cglib.beans.BeanMap可以快捷、优雅的将Java entity bean 转换为Map对象；但是使用时也需要主要，org.springframework.cglib.beans.BeanMap直接转换出来的Map对象，做不了put操作；例如： LoggerIndex index = new LoggerIndex(); index.set...
cglib 的 beanMap 与 反射 的效率
徐风子的博客
02-09 1151
一直在用cglib，突然想起来还没有测试过他的效率到底如何，所以稍微测试了一下 对于有11个成员变量的bean，一个是直接使用java的反射读取，另一个是使用cglib转换beanMap以后直接使用get读取。（详细结果见下表） 可以看出， cglib 的效率是 直接反射的3倍（字节码编程确实很厉害！）另外，cglib的beanMap在初次创建一个类的缓存时会耗费一定的时间（300ms），之后...
深拷贝的缺点_使用cglib进行bean拷贝
weixin_39815879的博客
12-05 534
点赞收藏加关注是我创作的最大动力大家可能用过很多种方式拷贝bean，一开始阿帕奇的BeanUtil，Spring里的BeanUtil、MapStruct等等，种类繁多，它们各有各的实现方式，有的是通过反射，有的是生成映射，有的是生成字节码。可以说，每种方式各有各的优缺点（意思就是我不评价它们好坏），今天我只说cglib中的BeanCopier，它有什么特点呢：生成字节码，生成调用set get的方...
spring中bean的高级属性之list, set, map以及props元素(含举例)
qingfeng_825的专栏
11-29 143
 list, set, map和props元素分别用来设置类型为List，Set，Map和Propertis的属性值。分别用来为bean传入集合值。  对应的spring的配置文件举例如下： xml 代码 &lt;? xml version="1.0" encoding="gb2312" ?&gt;      &lt;! DOCTYPE beans PUBLIC "-//SP...
cglib生成的东西放哪了
risc123456的博客
08-17 79
cglib生成的class文件放到哪里了???
黑马程序员----基础加强3反射和内省
chentengyue_2013的专栏
04-07 781
------- android培训、java培训、期待与您交流！ ----------   >>JAVA1.2时就存在反射，并不是1.5的新特性         >>类Class（平时定义时是小写的class,这个是一个类，名字叫Class）   Class代表一类什么样的事物？          Java类用于描述一类事物的共性，该类该有什么属
map和bean的优缺点
xiaoshihoudewo_的博客
06-02 1170
------------------------------------------------map的优点： 1.灵活，通用，相当于是一个大泛型，也可以转成bean。 2.大幅提高开发速度（开发层面） 3.数据库频繁变动的前提下，几乎很少的去修改代码。 4.节省了bean的维护工作，项目中几乎找不到bean了。 5.和spring一脉相承，不需要额外的配置来转化bean，以及额外的bug，（这里说的是spring jdbc） ----------------------------------------
cglib 的BeanCopier高性能解密
布道
04-02 5901
在一些系统代码中，随处可见的BeanCopier（源于org.springframework.cglib.beans），它主要用在将PO与DTO互转。一些人在惊叹它的高性能的同时，不曾了解它的实现原理（它不使用的反射）！它基于CGLIB代理，CGLIB(Code Generation Library)是高效的代码生成包，底层依靠ASM（开源的Java字节码编辑类库）操作字节码实现。 JDK动态代...
利用BeanMap实现Bean与Map之间相互转换
weixin_45510772的博客
03-23 331
导入依赖 <!-- https://mvnrepository.com/artifact/cglib/cglib-nodep --> <dependency> <groupId>cglib</groupId> <artifactId>cglib-nodep</artifactId> <version>3.3.0</version> </dependency
cglib jdk17
最新发布
01-19
cglib是一个强大的Java字节码增强库，它可以在运行时扩展Java类和实现动态代理。在JDK17中，cglib可以与JDK17一起使用，以实现更高级的功能和灵活性。 要在JDK17中使用cglib，你需要按照以下步骤进行操作： 1. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值