Java中的动态代理

代理模式是常用的设计模式之一，使用代理我们可以在执行被代理类的方法时对其进行增强，比如说被代理类的方法执行的是去访问数据库的数据，但是对于访问者的身份没有做判断，我们可以在代理类中对其进行增强，执行当前方法前判断访问者身份，达到安全的目的。
代理模式又分静态代理和动态代理。我们主要说动态代理。
Java中一般有两种动态代理方式，一种是jdk自带的JDK动态代理、还有一个是引用第三方库的CGLIB动态代理

一、JDK动态代理

1.1相关介绍

JDK动态代理使用java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy来提供动态生成代理类的能力，但是JDK动态代理要求被代理类必须实现一个接口
主要的步骤如下

1. 获取被代理类的引用，通过反射获取被代理类的实现的接口的信息。
2. JDK动态代理会去重新生成一个类，该类同样会去继承被代理类实现的所有的接口
3. 生成的类中包含被代理类中实现的方法
4. 编译新生成的class文件
5. JVM加载运行

1.2使用方式(代码)

创建接口

public interface Consumer {
   
    void findLove(String name, Double high);
}

创建实现类（被代理类）

public class HighQuanlityConsumer implements Consumer{
   
    @Override
    public void findLove(String name, Double high) {
   
        System.out.println("名字：" + name);
        System.out.println("身高：" + high);
    }
}

创建生成代理类类，需要实现InvocationHandler 接口

public class Intermediary  implements InvocationHandler {
   

    private Object target;

    public Object getInstance(Object object){
   
        this.target = object;
        Class<?> clazz = object.getClass();
        Object o = Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
        return o;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        //对原方法进行增强
        System.out.println(method.getName() + "开始执行");
        Object obj = method.invoke(this.target, args);
        System.out.println(method.getName() + "执行完毕");
        return obj;
    }
}

InvocationHandler 接口中有invoke方法，后续代理类执行的方法实际上都是要通过invoke方法来执行。

做完上述步骤后，我们就可以来生成一个代理类去执行相应的方法了

public static void main(String[] args) throws IOException {
   

        Consumer consumer = (Consumer) new Intermediary().getInstance(new HighQuanlityConsumer());
        consumer.findLove("江西彭于晏", 180d);
    }

是不是很简单，来看一下执行结果

findLove开始执行
名字：江西彭于晏
身高：180.0
findLove执行完毕

是不是感觉特别简单，但是为什么继承InvocationHandler ，执行一下Proxy中的newProxyInstance方法就可以了呢。我们不能再将代理类当成是被代理类了，代理类是一个新的类，这个类中会记录被代理类中的方法的相关信息，并创建一个method，每个方法都是如此，我们在调用代理类执行被代理类的方法时，会将method扔给Intermediary的invoke方法去执行，这也是我们为什么能对被代理类的方法进行增强的原因了。

1.3JDK动态代理的原理

上面有说JDK动态代理的实现依赖于java.lang.reflect.InvocationHandler和java.lang.reflect.Proxy，所以要看原理肯定是要进到这两个地方来看
首先来看生成代理类的入口

	/**
     * 
     * @param loader  被代理类的类加载器，不用多说，没这个怎么反射去找被代理类的信息
     * @param interfaces 被代理类实现的接口
     * @param h InvocationHandler的实现类 
     * @return
     * @throws IllegalArgumentException
     */
public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

具体到这个方法中看一下

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
   
        Objects.requireNonNull(h);
		//克隆出一份接口，防止修改原接口的信息
        final Class<?>[] intfs = interfaces.clone