【Reflect】动态代理(Proxy)

不念不忘少年蓝@ 2022-05-31 11:50 180阅读 0赞

**动态代理概述**

利用Java反射机制你可以在运行期动态的创建接口的实现。java.lang.reflect.Proxy类就可以实现这一功能。

这个类的名字就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛，

比如数据库连接和事物管理（transaction management）还有单元测试时用到的动态mock对象

以及AOP中的方法拦截功能等等都使用到了动态代理。  
  
**创建代理**

你可以通过使用Proxy.newProxyInstance()方法创建动态代理。newProxyInstance()方法有三个参数：

(1) 类加载器（ClassLoader）用来加载动态代理类。

(2) 一个要实现的接口的数组。

(3) 一个InvocationHandler把所有方法的调用都转到代理上。

如下例：

InvocationHandler handler = new MyInvocationHandler();

MyInterface proxy = (MyInterface) Proxy.newProxyInstance(MyInterface.class.getClassLoader(),new Class\[\]\{MyInterface.class\},handler);

在执行完这段代码之后，变量proxy包含一个MyInterface接口的的动态实现。所有对proxy的调用都被转向到实现了InvocationHandler接口的handler上。

**InvocationHandler接口**

在前面提到了当你调用Proxy.newProxyInstance()方法时，你必须要传入一个InvocationHandler接口的实现。

所有对动态代理对象的方法调用都会被转向到InvocationHandler接口的实现上，下面是InvocationHandler接口的源码：

public interface InvocationHandler\{

Object invoke(Object proxy, Method method, Object\[\] args) throws Throwable;

下面是它的实现类的定义：

public class MyInvocationHandler implements InvocationHandler\{

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

//do something "dynamic"

传入invoke()方法中的proxy参数是实现要代理接口的动态代理对象。通常你是不需要他的。

invoke()方法中的Method对象参数代表了被动态代理的接口中要调用的方法，从这个method对象中你可以获取到这个方法名字，

方法的参数，参数类型等等信息。

Object数组参数包含了被动态代理的方法需要的方法参数。注意：原生数据类型（如int，long等等）方法参数传入等价的包装对象（如Integer， Long等等）。

**动态代理使用完整实例:**

**MyInvocationHandler.java:**

package com.lanhuigu.reflect.proxys;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class MyInvocationHandler implements InvocationHandler {
        // 目标对象
        private Object target;
    
        /**
         * 构造方法
         * @param target 目标对象
         */
        public MyInvocationHandler(Object target) {
            super();
            this.target = target;
        }
    
    
        /**
         * 执行目标对象的方法
         */
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
            // 在目标对象的方法执行之前简单的打印一下
            System.out.println("------------------before------------------");
    
            // 执行目标对象的方法
            Object result = method.invoke(target, args);
    
            // 在目标对象的方法执行之后简单的打印一下
            System.out.println("-------------------after------------------");
    
            return result;
        }
    
        /**
         * 获取目标对象的代理对象
         * @return 代理对象
         */
        public Object getProxy() {
            return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
                    target.getClass().getInterfaces(), this);
        }
    }

**UserService.java:**

package com.lanhuigu.reflect.proxys;
    /**
     * 目标对象实现的接口，用JDK来生成代理对象一定要实现一个接口
     */
    public interface UserService {
        /**
         * 目标方法
         */
        public abstract void add();
    }

**UserServiceImpl.java:**

package com.lanhuigu.reflect.proxys;
    
    public class UserServiceImpl implements UserService {
        @Override
        public void add() {
            System.out.println("--------------------add---------------");
        }
    }

**TestProxy.java:**

package com.lanhuigu.reflect.proxys;
    
    public class TestProxy {
        public static void main(String[] args) {
            // 实例化目标对象
            UserService userService = new UserServiceImpl();
    
            // 实例化InvocationHandler
            MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
    
            // 根据目标对象生成代理对象
            UserService proxy = (UserService) invocationHandler.getProxy();
    
            // 调用代理对象的方法
            proxy.add();
        }
    }

**动态代理常被应用到以下几种情况中：**  
(1) 数据库连接以及事物管理  
(2) 单元测试中的动态Mock对象  
(3) 自定义工厂与依赖注入（DI）容器之间的适配器  
(4) 类似AOP的方法拦截器  
  
**数据库连接以及事物管理**

Spring框架中有一个事物代理可以让你提交/回滚一个事物。方法调用序列如下：

web controller --> proxy.execute(...);

proxy --> connection.setAutoCommit(false);

proxy --> realAction.execute();

// realAction does database work

proxy --> connection.commit();  
  
**单元测试中的动态Mock对象**

在测试类A的时候如果用到了接口B，你可以传给A一个实现了B接口的mock来代替实际的B接口实现。所有对接口B的方法调用都会被记录，

你可以自己来设置B的mock中方法的返回值。而且可以在B的mock中包装真实的B接口实现，这样所有调用mock的方法都会被记录，

然后把调用转向到真实的B接口实现。这样你就可以检查B中方法真实功能的调用情况。例如：你在测试DAO时你可以把真实的数据库连接包装到mock中。

这样的话就与真实的情况一样，DAO可以在数据库中读写数据，mock会把对数据库的读写操作指令都传给数据库，你可以通过mock来检查DAO是不是

以正确的方式来使用数据库连接，比如你可以检查是否调用了connection.close()方法。这种情况是不能简单的依靠调用DAO方法的返回值来判断的。