静态代理、JDK动态代理、CGLIB动态代理以及JDK和CGLIB动态代理的区别

什么是代理？

代理模式在 Java 开发中是一种比较常见的设计模式。设计目的旨在为服务类与客户类之间插入其他功能，插入的功能对于调用者是透明的，起到伪装控制的作用。如租房的例子: 房客、中介、房东。对应于代理模式中即:客户类、代理类 、委托类 (被代理类)
为某一个对象(委托类)提供一个代理 (代理类)，用来控制对这个对象的访问。委托类和代理类有个共同的父类或父接口。代理类会对请求做预处理、过滤，将请求分配给指定对象。

两个设计原则

• 代理类与委托类有共同的行为
• 代理类能够增强委托类的行为

三要素

1. 共同的行为-定义接口
2. 目标对象/真实角色-实现接口
3. 代理对象-实现接口 增强用户行为

静态代理

某个对象提供一个代理，代理角色固定，以控制对这个对象的访问。代理类和委托类有共同的父类或父接口，这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。

静态代理的实现

定义接口-定义行为

public interface Marry {
    public void toMarry();
}

静态代理 -> 目标角色

实现行为

public class You implements Marry {
    @Override
    public void toMarry() {
        System.out.println("你要结婚了...");
    }
}

静态代理-> 代理角色

1.实现行为
2.增强用户行为

public class MarryCompanyProxy implements Marry{
    //目标对象
    private Marry target;//多态

    //通过带参构造器传递目标对象
    public MarryCompanyProxy(Marry target) {
        this.target = target;
    }

    //实现行为
    @Override
    public void toMarry() {
        //用户行为增强
        before();

        //调用目标对象中的方法
        target.toMarry();

        //用户行为增强
        after();
    }

    /**
     * 用户行为增强
     */
    private void after() {
        System.out.println("新婚快乐...");
    }

    private void before() {
        System.out.println("婚礼现场正在布置...");
    }
}

静态代理测试

public class StaticProxy {

    public static void main(String[] args) {
        //目标对象
        You you = new You();
        //代理对象
        MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
        //通过代理对象调用目标对象中的方法
        marryCompanyProxy.toMarry();
    }
}

静态代理对于代理的角色是固定的，如dao层有20个dao类，如果要对方法的访问权限进行代理，此时需要创建20个静态代理角色，引起类爆炸，无法满足生产上的需要，于是就催生了动态代理的思想。

特点

1. 目标对象固定
2. 在程序运行前已经得到目标对象
3. 代理对象对目标对象进行增强
4. 有可能存在多个代理，产生"类爆炸"（缺点）

JDK动态代理

JDK动态代理的目标对象必须有接口实现
可以根据需要，通过反射机制在程序运行期，动态的为目标对象创建代理对象

newProxyInstance

Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下操作方法:

/*
 Loader:类加载器
 interfaces：接口数组
     target.getClass().getInterfaces():目标对象的接口数组
 h:InvocationHandler接口（传入InvocationHandler接口的实现类）*/
 
 public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces
                                      InvocationHandler h)

获取代理对象

/**
 * JDK动态代理类
 *      每一个代理类都需要实现InvocationHandler接口
 */
public class JdkHandler implements InvocationHandler {



    //目标对象
    private Object target;//类型不固定，创建时动态生成
    //通过带参构造器传递目标对象


    public JdkHandler(Object target) {
        this.target = target;
    }

    /**
     * 1.调用目标对象的方法（返回object）
     * 2.增强目标对象的行为
     *
     * @param proxy 调用该方法的代理实例
     * @param method 目标对象的方法
     * @param args 目标对象的方法所需要的参数
     * @return
     * @throws Throwable
     */

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //前后都可能会有增强行为，不一定都要有，只是可能会有
        //用户的增强行为
        System.out.println("============方法执行前");


        // 调用目标对象中的方法（返回object）
        Object object=method.invoke(target,args);


        //用户的增强行为
        System.out.println("方法执行后============");

        return object;//调用方法中返回的值
    }
    /**
     * 获取代理对象
     * public static Object newProxyInstance(ClassLoader loader,
     *                                       Class[] interfaces,
     *                                       InvocationHandler h)
     *  Loader:类加载器
     *  interfaces：接口数组
     *      target.getClass().getInterfaces():目标对象的接口数组
     *  h:InvocationHandler接口（传入InvocationHandler接口的实现类）
     * @return
     */
    public Object getProxy(){
        Object object= Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                                target.getClass().getInterfaces(),
                                                this);
        return object;
    }
}

通过代理对象实现目标对象的功能

public class JdkHandlerTest {
    public static void main(String[] args) {
        //目标对象
        You you = new You();
        //得到代理类
        JdkHandler jdkHandler = new JdkHandler(you);
        //得到代理对象
        Marry marry = (Marry) jdkHandler.getProxy();
        //通过代理对象调用目标对象的方法
        marry.toMarry();
    }
}

特点

1.目标对象不固定
2.在程序运行时，动态创建目标对象
3.代理对象会增强目标对象的行为

Java动态代理类中的invoke是怎么调用的?

在生成的动态代理类$Proxy9.class中，构造方法调用了父类Proxy.class的构造方法，给成员变量invocationHandler赋值，$Proxy9.class的static模块中创建了被代理类的方法，调用相应方法时方法体中调用了父类中的成员变量InvocationHandler的invoke()方法。

CGLIB动态代理

JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能使用JDK的动态代理，cglib是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。
代理类继承目标类，重写目标类中的方法

添加依赖

在pom.xml文件中引入cglib的相关依赖，可以上maven官网下载，也可以复制下面的依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
public class CglibInterceptor implements MethodInte

定义类实现MethodInterceptor接口

public class CglibInterceptor implements MethodInterceptor {

    //目标对象
    private Object target;
    //通过构造器传入目标对象

    public CglibInterceptor(Object target) {
        this.target = target;
    }

    /**
     * 获取代理对象
     * @return
     */
    public Object getProxy(){
        //通过Enhancer对象中的create()方法生成一个类，用于生产代理对象
        Enhancer enhancer = new Enhancer();
        //设置父类（将目标类作为代理类的父类）
        enhancer.setSuperclass(target.getClass());
        //CglibInterceptor implements MethodInterceptor extends Callback
        //设置拦截器（回调对象为本身对象）
        enhancer.setCallback(this);
        //生成代理类对象，并返回给调用者
        return enhancer.create();
    }

    /**
     * 拦截器
     * 1.目标对象的方法调用
     * 2.行为增强
     * @param o cglib动态生成的代理类的实例
     * @param method 实体类所调用的都被代理的方法的引用
     * @param objects 参数列表
     * @param methodProxy 生成的代理类对方法的代理引用
     * @return
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        //用户的增强行为
        System.out.println("============方法执行前");

        //调用目标类中的方法
        Object object=methodProxy.invoke(target,objects);

        //用户的增强行为
        System.out.println("方法执行后============");

        return null;
    }
}

调用方法进行测试

public class CglibInterceptorTest {
public static void main(String[] args) {
//得到目标对象
You you = new You();
//得到拦截器
CglibInterceptor cglibInterceptor = new CglibInterceptor(you);
//得到代理对象
Marry marry= (Marry) cglibInterceptor.getProxy();
//通过代理对象调用目标对象中的方法
marry.toMarry();
}
}

使用的还是一开始静态代理写的方法

JDK和CGLIB动态代理的区别是什么？

• JDK动态代理实现接口，Cglib动态代理继承思想
• JDK动态代理 (目标对象存在接口时) 执行效率高于Ciglib
• 如果目标对象有接口实现，选择JDK代理，如果没有接口实现选择Cglib代理

基于CGLIB动态代理的实现代码实现一下没有接口实现的类分别是怎样的结果

先写一个没有接口实现的类User

public class User {
    public void test(){
        System.out.println("cglib动态代理...");
    }
}

通过Cglib动态代理实现：没有接口实现的类

        User user = new User();
        CglibInterceptor cglibInterceptor02 = new CglibInterceptor(user);
        User u = (User) cglibInterceptor02.getProxy();
        u.test();

实现结果

通过JDK动态代理实现：没有接口实现的类

User user = new User();
        JdkHandler jdkHandler = new JdkHandler(user);
        User u= (User) jdkHandler.getProxy();
        u.test();

实现结果