代理模式详解（JDK/Cglib实现）

1.何为代理模式

代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。
比如在法庭上，我的代理律师替你进行陈述。代理律师就可以看作是代理你的代理对象，代理的行为（方法）是陈述。

在java语言当中也有从自然界抽象的代理模式，一般分为两类，静态代理，动态代理。

2.静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活且麻烦，需要对每个目标类都单独写一个代理类。实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

上面我们是从实现和应用角度来说的静态代理，从 JVM 层面来说，在运行前就已经创建了， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

2.1实现步骤

1. 定义一个接口及其实现类； 创建一个代理类同样实现这个接口
2. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。
3. 屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些其他操作。

废话不多说，上代码

1.定义一个查询接口

public interface QueryService {
   String query(String param);
}

2.定义实现类目标对象

public class QueryServiceImpl implements QueryService {
    @Override
    public String query(String param) {
        System.out.println("param:"+param);
        return "query result";
    }
}

3.定义代理类

public class QueryProxy implements  QueryService{

    //屏蔽目标对象访问
    private final QueryService queryService;

    public QueryProxy(QueryService queryService) {
        this.queryService = queryService;
    }

    @Override
    public String query(String param) {
        //前处理
        System.out.println("before>>>>");
        String result  =queryService.query(param);
        //后处理
        System.out.println("after>>>>");
        return result;
    }
}

4.具体使用

public class Main {

    public static void main(String[] args) {
        QueryService queryService =  new QueryServiceImpl();
        //代理类对象
        QueryProxy queryProxy = new QueryProxy(queryService);
        queryProxy.query("123");
    }
}

执行结果

3.动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口

在我们常用的框架 Spring AOP、Mybatis、RPC通信框架中，它们的实现都依赖了动态代理。
只需要定义接口，在实际调用时使用的是代理生成的代理类。
动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。

从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的
就 Java 来说，动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理等等。

3.1.JDK 动态代理

在JDK动态代理中有两个核心类 InvocationHandler 接口和 Proxy 类。
Proxy主要是用来生成代理对象的，使用newProxyInstance方法就可以创建代理对象的实例。

    public static Object newProxyInstance(ClassLoader loader,//类加载器，用于加载代理对象
                                          Class<?>[] interfaces,//被代理类实现的一些接口
                                          InvocationHandler h //实现了 InvocationHandler 接口的对象
                                          )
        throws IllegalArgumentException
    {
        ......
    }

InvocationHandler 接口，当着接口被实现后，当使用上述的代理对象调用方法时，实际调用的是此处的invoke的实现方法。

public interface InvocationHandler {

    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, //代理对象
                         Method method, //方法
                         Object[] args //参数列表
                         )
        throws Throwable;
}

3.1.1.实现步骤

1. 定义一个接口及其实现类；
2. 自定义 InvocationHandler 并重写invoke方法，在 invoke方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象；

1.定义查询接口

public interface QueryService {
   String query(String param);
}

2.定义查询实现类

public class QueryServiceImpl implements QueryService {
    @Override
    public String query(String param) {
        System.out.println("QueryServiceImpl>>>");
        return "query result";
    }
}

3.使用动态代理生成代理

public class Main {

    public static void main(String[] args) {
        QueryService queryService = new QueryServiceImpl();
        QueryService queryServiceProxy = (QueryService) Proxy.newProxyInstance(
                queryService.getClass().getClassLoader(),//类加载器
                queryService.getClass().getInterfaces(),//被代理的接口
                new QueryHandler(queryService));//拦截
        queryServiceProxy.query("dadada");
    }
}

结果如下

3.2.CGLIB 动态代理机制

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类，如果没有实现类是无法实现代理的，
但是CGLIB 就很好的解决了这个问题

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。
你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, //被代理的对象（需要增强的对象）
                            java.lang.reflect.Method method, //被拦截的方法（需要增强的方法）
                            Object[] args,//参数列表
                            MethodProxy proxy //用于调用原始方法
                            ) throws Throwable;
}

你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

3.2.1.实现步骤

1. 定义一个类；
2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的invoke 方法类似；
3. 通过 Enhancer 类的 create()创建代理类；

上代码
1.引入依赖

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

2.定义接口

public interface QueryService {
   String query(String param);
}

3.实现方法拦截类

public class QueryMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //前处理
        System.out.println("before >>>" + method.getName());
        Object object = "test";
        System.out.println(object);
        //后处理
        System.out.println("after >>> " + method.getName());
        return object;
    }
}

此处拦截可是接口，也可以是类，拦截类可以这样使用

public class QueryMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        //前处理
        System.out.println("before >>>" + method.getName());
        //原方法调用
        Object object = methodProxy.invokeSuper(o, objects);
        //后处理
        System.out.println("after >>> " + method.getName());
        return object;
    }
}

4.使用Enhancer生成代理类

public class Main {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(QueryService.class.getClassLoader());//类加载器
        enhancer.setSuperclass(QueryService.class);//设置为代理类
        enhancer.setCallback(new QueryMethodInterceptor());//设置方法拦截
        QueryService queryServiceProxy = (QueryService) enhancer.create();//创建代理类
        queryServiceProxy.query("ddaa");
    }
}

结果如下

总结

JDK 动态代理和 CGLIB 动态代理对比
JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

静态代理和动态代理的对比
灵活性 ：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
JVM 层面 ：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。