Spring

1.4 Java动态代理

1.4.1 静态代理（引入）

在引入动态代理之前，先看看静态代理的概念。

在代理模式中，一般涉及到真实对象，代理对象，代理接口几个重要的概念。真实对象包含一组实际的处理操作实现，代理接口中定义了这一组操作，代理对象则要为真实对象服务，对那一组实际的操作进行方法的增强。

实际场景中，不同的代理对象进行不同的方法增强。

下面展示一个静态代理的代码示例

代理接口

package com.jia.staticagent;

/**
 * 需要代理的接口，通常是实际场景下需要做的一些操作
 */
public interface ProxyInterface {

    public void task1();
    public  void task2();
}

真实对象

package com.jia.staticagent;

public class RealObject implements ProxyInterface {

    public void task1() {
        System.out.println("task1");
    }

    public void task2() {
        System.out.println("task2");

    }
}

代理对象

示例中将真实对象作为一个成员变量传入，可以理解为代理对象为真实对象服务，对真实对象的一些操作进行增强

package com.jia.staticagent;

public class ProxyObject implements ProxyInterface {

    ProxyInterface realObject;

    public void setRealObject(ProxyInterface realObject) {
        this.realObject = realObject;
    }

    public void task1() {
        System.out.println("pre...........");
        realObject.task1();
        System.out.println("post..........");
    }

    public void task2() {
        System.out.println("pre...........");
        realObject.task2();
        System.out.println("post..........");
    }
}

测试

public class Main {
    public static void main(String[] args) {

        RealObject realObject = new RealObject();
        ProxyObject proxyObject = new ProxyObject();
        proxyObject.setRealObject(realObject);

        proxyObject.task1();
        proxyObject.task2();
    }
}

结果

pre...........
task1
post..........
pre...........
task2
post..........

1.4.2 动态代理概念

接下来进入正题

动态代理有两种实现方式

• jdk动态代理（基于接口）

  java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。

• cglib动态代理（基于子类，继承）

  cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

• spring框架中动态代理的实现

  1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
  2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

  3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

在java动态代理机制中有两个很重要的接口。一个就是java.lang.reflect.InvocationHandler，另一个就是java.lang.reflect.Proxy

InvocationHandler

下面是jdk 8的官方api，如果刚刚接触java的动态代理，会觉得下面的注释部分难以理解，但是在真正理解了java的动态代理后，会发现没有官方文档解释得更加详细的了。如果实在不理解，后面会进一步介绍。

public interface InvocationHandler
//InvocationHandler是由代理实例的调用处理程序实现的接口  。
//每个代理实例都有一个关联的调用处理程序。  当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。 

Object invoke(Object proxy,Method method,
              Object[] args)throws Throwable
       //处理代理实例上的方法调用并返回结果。 当在与之关联的代理实例上调用方法时，将在调用处理程序中调用此方法。
       //共有三个参数
       //1.proxy:调用该方法的代理实例(也就是后面谈到的程序在运行时动态生成的一个代理类的实例)
       //2.method: 该参数是代理的方法
       //3. 代理方法中接收的参数

Proxy

public class Proxy extends Object 
	implements SerializableProxy

//提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

//其中一个最重要的方法
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
//返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。 
//三个参数
//1. 真实需要代理对象的ClassLoader，也就是真实对象的ClassLoader
 //2. 需要代理对象（也就是真实对象）的一组接口
  //3. 参数是一个InvocationHandler对象，表示关联到某一个handler上。
    
protected InvocationHandler h 
//该代理实例的调用处理程序。  这个成员变量非常重要，程序运行时生成的动态代理类最终会使用到这个对象，主要是调用invoke方法对需要代理的方法进行增强。

1.4.3 动态代理示例程序

下面展示一个具体的java动态代理的示例程序

代理接口

package com.jia.dynamicproxy;

public interface ProxyInterface {
    public void task1();
    public  void task2();
}

真实对象

package com.jia.dynamicproxy;

public class RealObject implements ProxyInterface {

    public void task1() {
        System.out.println("task1");
    }

    public void task2() {
        System.out.println("task2");
    }
}

自定义调用处理程序

package com.jia.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 代理实例的处理程序，需要自己定义，实现InvocationHandler接口
 */
public class MyInvocationHandler implements InvocationHandler {

    private ProxyInterface realObject;

    public MyInvocationHandler(ProxyInterface realObject) {
        this.realObject = realObject;
    }

    //invoke方法对代理接口中的方法进行增强，程序动态生成的代理实例调用代理接口中的某个方法时，
    // 会转到代理实例对应的 调用处理程序（也就是目前我们创建该类）的invoke方法
    //第一个参数是 动态生成的代理实例，而并非真实对象，这一点要搞清楚
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("pre...........");
        //这里不做过多的介绍，这是反射的应用，
        Object invoke = method.invoke(realObject, args);
        System.out.println("post..........");
        return invoke;
    }
}

测试

package com.jia.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Main {
    public static void main(String[] args) {

        //1.创建被代理的对象,ProxyInterface接口的实现类
        RealObject realObject = new RealObject();
        // 2. 获取对应的 ClassLoader
        ClassLoader classLoader = realObject.getClass().getClassLoader();
        // 3. 获取被代理对象所有接口的Class，这里的RealObject只实现了一个接口ProxyInterface，
        Class[] interfaces = realObject.getClass().getInterfaces();
        // 4. 创建一个将传给代理类的调用请求处理器，处理所有的代理对象上的方法调用
        //    这里创建的是一个自定义的调用处理程序对象，须传入真实对象 realObject
        InvocationHandler myInvocationHandler = new MyInvocationHandler(realObject);
        /*
         5.根据上面提供的信息，创建代理对象 在这个过程中，
               a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码
               b.然后根据相应的字节码转换成对应的class，
               c.然后调用newInstance()创建代理实例
       */
        ProxyInterface proxy = (ProxyInterface) Proxy.newProxyInstance(classLoader, interfaces, myInvocationHandler);
        // 代理实例调用代理的方法
        proxy.task1();
        proxy.task2();
    }
}

对比静态代理，可以发现，并没有实际编写代理类，而是在程序运行时 ,通过如下程序，动态创建了一个代理实例，如果细究底层，会发现在下面代码运行后，会生成一个代理类的字节码文件，通过反编译插件，可以查看代理类的实际面貌。

ProxyInterface proxy = (ProxyInterface) Proxy.newProxyInstance(classLoader, interfaces, myInvocationHandler);

该示例中动态生成的代理类大概是如此（实际生成的代理类名称可能有误）

public final class RealObjectProxy extends Proxy implements UserService {
	//.......
	//代理类中会有一系列Method[]成员，其中就包括了真实对象中那一些方法
	//可以看到这里是继承了Proxy类，这一点很重要，因为上文一直提到的myInvocationHandler是交由Proxy管理的，而代理类中实际上并没有依赖我们自定义的调用处理程序对象，在代理实例调用代理方法时，就会调用super.h.invoke来负责实际的调用处理逻辑
}

编写代理类，而是在程序运行时 ,通过如下程序，动态创建了一个代理实例，如果细究底层，会发现在下面代码运行后，会生成一个代理类的字节码文件，通过反编译插件，可以查看代理类的实际面貌。

ProxyInterface proxy = (ProxyInterface) Proxy.newProxyInstance(classLoader, interfaces, myInvocationHandler);

该示例中动态生成的代理类大概是如此（实际生成的代理类名称可能有误）

public final class RealObjectProxy extends Proxy implements UserService {
	//.......
	//代理类中会有一系列Method[]成员，其中就包括了真实对象中那一些方法
	//可以看到这里是继承了Proxy类，这一点很重要，因为上文一直提到的myInvocationHandler是交由Proxy管理的，而代理类中实际上并没有依赖我们自定义的调用处理程序对象，在代理实例调用代理方法时，就会调用super.h.invoke来负责实际的调用处理逻辑
}