设计模式3.3-- CGLIB动态代理源码解读

Posted 2021-11-09 第十六封

cglib 动态代理

cglib介绍

CGLIB 是一个开源项目，一个强大高性能高质量的代码生成库，可以在运行期拓展 Java 类，实现 Java 接口等等。底层是使用一个小而快的字节码处理框架 ASM，从而转换字节码和生成新的类。

理论上我们也可以直接用 ASM 来直接生成代码，但是要求我们对 JVM 内部，class 文件格式，以及字节码的指令集都很熟悉。

这玩意不在 JDK 的包里面，需要自己下载导入或者 Maven 坐标导入。

我选择 Maven 导入, 加到 pom.xml 文件：

<dependencies>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>3.3.0</version>
    </dependency>
</dependencies>

Student.java:

public class Student {
    public void learn() {
        System.out.println("我是学生，我想学习");
    }
}

MyProxy.java(代理类)

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class StudentProxy implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("代理前 -------");
        proxy.invokeSuper(obj, args);
        System.out.println("代理后 -------");
        return null;
    }

}

测试类（Test.java）

import net.sf.cglib.core.DebuggingClassWriter;
import net.sf.cglib.proxy.Enhancer;

public class Test {
    public static void main(String[] args) {
        // 代理类class文件存入本地磁盘方便我们反编译查看源码
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "/Users/aphysia/Desktop");

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Student.class);
        enhancer.setCallback(new StudentProxy());
        Student student = (Student) enhancer.create();
        student.learn();

    }
}

运行之后的结果是：

CGLIB debugging enabled, writing to \'/Users/xuwenhao/Desktop\'
代理前 -------
我是学生，我想学习
代理后 -------

在我们选择的文件夹里面，生成了代理类的代码：

源码分析

我们先要代理的类，需要实现MethodInterceptor(方法拦截器)接口,这个接口只有一个方法 intercept,参数分别是：

• obj：需要增强的对象
• method：需要拦截的方法
• args：要被拦截的方法参数
• proxy：表示要触发父类的方法对象

package net.sf.cglib.proxy;
import java.lang.reflect.Method;
public interface MethodInterceptor extends Callback {
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;
}

再看回我们要创建代理类的方法 enhancer.create(),这个方法的意思：如果需要，生成一个新类，并使用指定的回调(如果有的话)来创建一个新的对象实例。使用超类的无参数构造函数。

    public Object create() {
        classOnly = false;
        argumentTypes = null;
        return createHelper();
    }

主要的方法逻辑我们得看 createHelper()，除了校验，就是调用 KEY_FACTORY.newInstance() 方法生成 EnhancerKey对象，KEY_FACTORY 是静态 EnhancerKey 接口，newInstance(）是接口里面的一个方法，重点在super.create(key)里面，调用的是父类的方法：

    private Object createHelper() {
        // 校验
        preValidate();
        Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                ReflectUtils.getNames(interfaces),
                filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
                callbackTypes,
                useFactory,
                interceptDuringConstruction,
                serialVersionUID);
        this.currentKey = key;
        Object result = super.create(key);
        return result;
    }

AbstractClassGenerator 是 Enhancer 的父类，create(key) 方法的主要逻辑是获取类加载器，缓存获取类加载数据，然后再反射构造对象，里面有两个创造实例对象的方法：

• fistInstance(): 不应该在常规流中调用此方法。从技术上讲，{@link #wrapCachedClass(Class)}使用{@link EnhancerFactoryData}作为缓存值，后者支持比普通的旧反射查找和调用更快的实例化。出于向后兼容性的原因，这个方法保持不变:只是以防它曾经被使用过。(我的理解是目前的逻辑不会走到这个分支，因为它比较忙，但是为了兼容，这个case还保存着)，内部逻辑其实用的是ReflectUtils.newInstance(type)。
• nextInstance(): 真正的创建代理对象的类

    protected Object create(Object key) {
        try {
            ClassLoader loader = getClassLoader();
            Map<ClassLoader, ClassLoaderData> cache = CACHE;
            ClassLoaderData data = cache.get(loader);
            if (data == null) {
                synchronized (AbstractClassGenerator.class) {
                    cache = CACHE;
                    data = cache.get(loader);
                    if (data == null) {
                        Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
                        data = new ClassLoaderData(loader);
                        newCache.put(loader, data);
                        CACHE = newCache;
                    }
                }
            }
            this.key = key;
            Object obj = data.get(this, getUseCache());
            if (obj instanceof Class) {
                return firstInstance((Class) obj);
            }
            // 真正创建对象的方法
            return nextInstance(obj);
        } catch (RuntimeException e) {
            throw e;
        } catch (Error e) {
            throw e;
        } catch (Exception e) {
            throw new CodeGenerationException(e);
        }
    }

这个方法定义在AbstractClassGenerator，但是实际上是调用子类 Enhancer的实现，主要是通过获取参数类型，参数，以及回调对象，用这些参数反射生成代理对象。

    protected Object nextInstance(Object instance) {
        EnhancerFactoryData data = (EnhancerFactoryData) instance;

        if (classOnly) {
            return data.generatedClass;
        }

        Class[] argumentTypes = this.argumentTypes;
        Object[] arguments = this.arguments;
        if (argumentTypes == null) {
            argumentTypes = Constants.EMPTY_CLASS_ARRAY;
            arguments = null;
        }
        // 构造
        return data.newInstance(argumentTypes, arguments, callbacks);
    }

内部实现逻辑,调用的都是ReflectUtils.newInstance(), 参数种类不一样：

        public Object newInstance(Class[] argumentTypes, Object[] arguments, Callback[] callbacks) {
            setThreadCallbacks(callbacks);
            try {

                if (primaryConstructorArgTypes == argumentTypes ||
                        Arrays.equals(primaryConstructorArgTypes, argumentTypes)) {
                    return ReflectUtils.newInstance(primaryConstructor, arguments);
                }
               return ReflectUtils.newInstance(generatedClass, argumentTypes, arguments);
            } finally {
            
                setThreadCallbacks(null);
            }

        }

跟进去到底，就是获取构造器方法，反射方式构造代理对象，最终调用到的是 JDK 提供的方法：

    public static Object newInstance(Class type, Class[] parameterTypes, Object[] args) {
        return newInstance(getConstructor(type, parameterTypes), args);
    }
    public static Object newInstance(final Constructor cstruct, final Object[] args) {
            
        boolean flag = cstruct.isAccessible();
        try {
            if (!flag) {
                cstruct.setAccessible(true);
            }
            Object result = cstruct.newInstance(args);
            return result;
        } catch (InstantiationException e) {
            throw new CodeGenerationException(e);
        } catch (IllegalAccessException e) {
            throw new CodeGenerationException(e);
        } catch (InvocationTargetException e) {
            throw new CodeGenerationException(e.getTargetException());
        } finally {
            if (!flag) {
                cstruct.setAccessible(flag);
            }
        }
                
    }

打开它自动生成的代理类文件看看，就会发现其实也是生成那些方法，加上了一些增强方法：

生成的代理类继承了原来的类：

public class Student$$EnhancerByCGLIB$$929cb5fe extends Student implements Factory {
    ...
}

看看生成的增强方法,其实是调用到 intercept()方法，这个方法由我们前面自己实现，因此就完成了代理对象增强的功能：

    public final void learn() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$learn$0$Method, CGLIB$emptyArgs, CGLIB$learn$0$Proxy);
        } else {
            super.learn();
        }
    }

cglib 和 jdk 动态代理有什么区别

1. jdk 动态代理是利用拦截器加上反射生成了一个代理接口的匿名类，执行方法的时候交给 InvokeHandler 处理。CGLIB 动态代理是使用了 ASM框架，修改原来的字节码，然后生成新的子类来处理。
2. JDK 代理需要实现接口，但是CGLIB不强制。
3. 在JDK1.6之前，cglib因为用了字节码生成技术，比反射效率高，但是之后jdk也进行了一些优化，效率上已经提升了。

【作者简介】：
秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。

剑指Offer全部题解PDF

2020年我写了什么？

开源编程笔记

深入理解设计模式-代理模式（静态代理动态代理jdk和cglib）

文章目录

• 一、定义
• 二、使用场景
• 三、代码样例
• • 1.类图
  • 2.静态代理
  • 3.JDK动态代理
  • 4.Cglib动态代理
• 四、优缺点
• 五、拓展延伸
• • 1.jdk和cglib动态代理类反编译
  • 2.jdk和cglib动态代理区别
• 结尾

---

一、定义

所谓代理模式是指客户端并不直接调用实际的对象，而是通过调用代理对象，来间接的调用实际的对象。通俗的来讲代理模式就是我们生活中常见的中介。

---

二、使用场景

• 热门框架源码：Spring AOP、Mybatis Mapper

• 权限管理、异常处理、操作日志、事务控制

---

三、代码样例

1.类图

2.静态代理

/**
 * 公共接口
 */
public interface Singer 
    void sing();

/**
 * 具体角色，男歌手
 */
public class MaleSinger implements Singer
    private String name;

    public MaleSinger() 
    

    public MaleSinger(String name) 
        this.name = name;
    
    @Override
    public void sing() 
        System.out.println(this.name+"男歌手在唱歌");
    

/**
 * 代理角色
 */
public class Agent implements Singer 
    //代理角色要有一个被代理角色
    private MaleSinger singer;
    public Agent(MaleSinger singer) 
        this.singer = singer;
    
    @Override
    public void sing() 
        System.out.println("协商出场费，做会场工作");
        //一定是被代理角色歌手去唱歌
        singer.sing();
        System.out.println("会场收拾，结算费用");
    

/**
 * 静态代理客户端
 */
public class StaticProxyClient 
    public static void main(String[] args) 
        MaleSinger singer=new MaleSinger("周杰伦");
        Agent agent=new Agent(singer);
        //通过代理来运行唱歌
        agent.sing();
    

3.JDK动态代理

/**
 * jdk动态代理类工厂
 */
public class JdkProxyFactory 
    /**
     * 动态生成代理对象
     * @param target
     * @return
     */
    public static <T> T getProxyBean(T target)
        Class clazz = target.getClass();
        //在JDK中动态生成代理对象的方法
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), new InvocationHandler() 
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable 
                System.out.println("协商出场费，做会场工作");
                Object obj =  method.invoke(target,args);
                System.out.println("会场收拾，结算费用");
                return obj;
            

        );
    

/**
 * jdk动态代理客户端
 */
public class JdkProxyClient 
    public static void main(String[] args) 
        //设置用于输出jdk动态代理产生的类
        System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        Singer singer = new MaleSinger("周杰伦");
        JdkProxyFactory.getProxyBean(singer).sing();
        System.out.println("aa");

    

4.Cglib动态代理

/**
 * cglib动态代理类工厂
 */
public class CglibProxyFactory 
    /**
     * 动态生成代理对象
     * @param target
     * @return
     */
    public static <T> T getProxyBean(T target)
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new MethodInterceptor() 
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable 
                System.out.println("协商出场费，做会场工作");
                Object obj = method.invoke(target,objects);
                System.out.println("会场收拾，结算费用");
                return obj;
            
        );
        return (T) enhancer.create();
    

/**
 * cglib动态代理客户端
 */
public class CglibProxyClient 
    public static void main(String[] args) 
        //用于输出生成的代理class文件,"D:/test/designpattern"表示存储在class文件夹中
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"D:/test/designpattern");
        Singer singer = new MaleSinger("周杰伦");
        CglibProxyFactory.getProxyBean(singer).sing();

    

---

四、优缺点

优点：

• 1、代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用
• 2、代理对象可以扩展目标对象的功能
• 3、代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

缺点：

• 1、代理模式会造成系统设计中类的数量增加
• 2、在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢
• 3、增加了系统的复杂度

---

五、拓展延伸

1.jdk和cglib动态代理类反编译

JDK代理类反编译：


Cglib代理类反编译：

2.jdk和cglib动态代理区别

Jdk动态代理：
利用拦截器加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
特点：
JDK动态代理只能对实现了接口的类生成代理，而不能针对类

Cglib动态代理：
利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理。
特点：
Cglib是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，并覆盖其中方法的增强，但是因为采用的是继承，所以该类或方法最好不要生成final，对于final类或方法，是无法继承的

---

结尾

• 感谢大家的耐心阅读，如有建议请私信或评论留言。
• 如有收获，劳烦支持，关注、点赞、评论、收藏均可，博主会经常更新，与大家共同进步