动态代理的一些简单的总结

什么是代理模式？

 代理模式是指在不修改原目标代码的前提下，给其增加或扩展功能。也就是给一个类添加一个代理类，通常我们称被代理类为目标类，当我们访问实际对象时，事实上访问的是代理类，代理类相当于一个中间件，它能在目标类的基础上增加或扩展功能。

动态代理分为两种：JDK动态代理和CGLIB动态代理。

在Spring框架中，大量运用了动态代理模式。

JDK动态代理

JDK动态代理是JDK自带的功能，主要使用到InvocationHandler接口和Proxy对象的静态方法newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法。

例如，随便编写一个带有一个功能的接口：

/**
 * 目标接口
 */
public interface Animal {
    String dog();
}

创建一个类，实现它，我们称之为目标类，也就是被代理类：

/**
 * 目标类
 */
public class AnimalImpl implements Animal {

    /**
     * 需要被增强的方法
     * @return
     */
    @Override
    public String dog() {
        System.out.println("this is a dog");
        return "this is return value";
    }

}

下面我们通过JDK动态代理来对目标类进行动态代理，步骤：

1. 创建类，实现InvocationHandler接口，通过重写invoke(Object proxy, Method method, Object[] args)方法来自定义执行逻辑，换句话说，也就是目标类方法的主要逻辑实现都在此方法中完成。它有三个形参，分别代表：
   1. proxy：代理对象，也就是newProxyInstance方法生成的对象；
   2. method：当前调度的方法，也就是目标类中需要增强的方法；
   3. args：调度方法的参数，没有则为null；
2. 通过Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)来生成一个代理对象，其三个参数分为代表：
   1. loader：目标类的类加载器；
   2. InvocationHandler：目标类所实现的接口；
   3. h：实现InvocationHandler的类；

public class MyInvocationHandler implements InvocationHandler {

    //目标类对象
    private Object target;

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

    /**
     * 代理方法逻辑实现
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("what type of this animals??");
        Object returnVal = method.invoke(target, args);
        System.out.println("dog have 4 legs");
        return returnVal;
    }

    /**
     * 通过newProxyInstance方法生成一个代理对象并返回
     * @return
     */
    public Object getProxy() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

运行测试：

    @Test
    public void jdKProxy() {
        MyInvocationHandler myIH = new MyInvocationHandler(new AnimalImpl());
        Animal animalProxy = (Animal) myIH.getProxy();
        String returnVal = animalProxy.dog();

        //该方法的返回值
        System.out.println(returnVal);
    }

 如上，通过(Animal) myIH.getProxy()得到的Animal对象animalProxy，再执行animalProxy.dog()方法，其实际上就是执行的invoke()方法。

 output：

what type of this animals??
this is a dog
dog have 4 legs
this is return value

 CGLIB动态代理

CGLIB动态代理和JDK动态代理的主要区别：

• CGLIB动态代理是第三方所提供的技术，而JDK动态代理是JDK自带的功能；
• JDK动态代理，目标类必须实现接口，而CGLIB动态代理不需要，所以使用CGLIB会更简单一些；

它们的理念和实现的方法都是相似的，所以当你学会了JDK动态代理之后，很容易就能掌握CGLIB。

主要使用到MethodInterceptor接口和Enhancer对象。

因为是由第三方提供，所以我们在使用之前要导入它的Maven依赖：

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

编写一个目标类，它不需要实现任何接口：

public class Person {
    public String student(){
        System.out.println("name:Jack");
        return "this is return value";
    }
}

1. 创建一个类，实现MethodInterceptor接口，通过重写intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)方法来自定义执行逻辑，它的作用与JDK中invoke()方法类似，它有四个形参：
   1. o：代理对象，也就是newProxyInstance方法生成的对象；
   2. method：目标类中需要被增强的方法；
   3. objects：需要被增强方法的参数，没有为null；
   4. methodProxy：用来调用目标类中被增强的方法；
2. 创建Enhancer对象，通过setClassLoader()、setSuperclass()、setCallback()方法来分别设置目标类的类加载器、目标类、实现MethodInterceptor接口的实例，最后通过create()方法来生成一个代理类；

public class MyMethodInterceptor implements MethodInterceptor {

    //目标类
    private Object target;

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

    /**
     * 代理方法逻辑实现
     * @param o
     * @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("执行方法：" + method.getName());
        Object returnValue = methodProxy.invokeSuper(o, objects);
        System.out.println("age:19");
        return returnValue;
    }

    /**
     * 创建Enhancer对象 使用create方法来生成一个代理对象 并且返回
     * @return
     */
    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(target.getClass().getClassLoader());
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
}

运行测试：

    @Test
    public void cglibProxy() {
        MyMethodInterceptor myMI = new MyMethodInterceptor(new Person());
        Person personProxy = (Person)myMI.getProxy();
        String returnValue = personProxy.student();

        //该方法的返回值
        System.out.println(returnValue);
    }

output：

执行方法：student
name:Jack
age:19
this is return value