设计模式-代理模式

设计模式-代理模式

代理模式（Proxy Design Pattern）在不改变原有业务代码的情况下，通过引入代理类来给原始类附加功能，一般分为静态代理和动态代理。

案例分析

如果有一个 UserServiceImpl 类，我们希望统计其中的每个方法执行耗时。

public class UserServiceImpl {

    public void test() {
        IntStream.rangeClosed(1, 100).forEach(i -> {
            if (i % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

}

我们很容易想到的就是创建一个 UserServiceImpl 的示例，在调用前后记录时间并计算差值

public class Main {

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        UserServiceImpl userService = new UserServiceImpl();
        userService.test();
        long end = System.currentTimeMillis();
        System.out.println("test耗时:" + (end - start) + "ms");
    }

}

但是一方面如果方法很多，那么所有的位置都需要加上这样的代码，另一方面这些与业务无关的代码有可能未来取消或改动，如果每次变化都修改源代码，会使程序出错的可能性变大，因此我们希望不改动原始代码来实现。

基于继承的代理实现

public class UserServiceImplProxy extends UserServiceImpl{

    @Override
    public void test() {
        long start = System.currentTimeMillis();
        super.test();
        long end = System.currentTimeMillis();
        System.out.println("test耗时:" + (end - start) + "ms");
    }

}

public class Main {

    public static void main(String[] args) {
        UserServiceImpl proxy = new UserServiceImplProxy();
        proxy.test();
    }

}

我们使 UserServiceImplProxy 类继承 UserServiceImpl 类，使用完全相同的接口，这样在创建对象时利用多态特性，父类对象指向子类实例，就可以在不改动原始代码的情况下增加记录接口调用时间的日志。

基于接口的代理实现

首先定义 UserService 接口及实现类 UserServiceImpl

public interface UserService {

    void test();

}

public class UserServiceImpl implements UserService {

    @Override
    public void test() {
        IntStream.rangeClosed(1, 100).forEach(i -> {
            if (i % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

}

我们创建一个新的类 UserServiceImplProxy 也实现这个接口

public class UserServiceImplProxy implements UserService {

    private UserServiceImpl userService;

    public UserServiceImplProxy(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void test() {
        long start = System.currentTimeMillis();
        userService.test();
        long end = System.currentTimeMillis();
        System.out.println("test耗时:" + (end - start) + "ms");
    }

}

在 Proxy 代理类中，通过注入或构造器等把默认实现类传入，这样也可以达到我们的目的。

动态代理

在上述的两种实现中，不难看出这些都需要我们创建一些新的类，当类的数量很多时这是个很大的工作量，而且会影响编译和启动速度，动态代理可以在运行的过程中动态生成这样的类。

public interface UserService {
    void test();
}

public class UserServiceImpl implements UserService {
    @Override
    public void test() {
        IntStream.rangeClosed(1, 100).forEach(i -> {
            if (i % 10 == 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

以下是生成动态代理对象的代码：

public class DynamicProxy {

    public Object createProxy(Object proxiedObject) {
        Class<?>[] interfaces = proxiedObject.getClass().getInterfaces();
        DynamicProxyHandler handler = new DynamicProxyHandler(proxiedObject);
        return Proxy.newProxyInstance(proxiedObject.getClass().getClassLoader(), interfaces, handler);
    }

    private class DynamicProxyHandler implements InvocationHandler {

        private Object proxiedObject;

        public DynamicProxyHandler(Object proxiedObject) {
            this.proxiedObject = proxiedObject;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long startTimestamp = System.currentTimeMillis();
            Object result = method.invoke(proxiedObject, args);
            long endTimeStamp = System.currentTimeMillis();
            long responseTime = endTimeStamp - startTimestamp;
            String apiName = proxiedObject.getClass().getName() + ":" + method.getName();
            System.out.println("执行:" + apiName + "耗时:" + responseTime + "ms");
            return result;
        }
    }

}

测试代码：

public class Main {

    public static void main(String[] args) {
        DynamicProxy serviceImplProxy = new DynamicProxy();
        UserService userService = (UserService)serviceImplProxy.createProxy(new UserServiceImpl());
        userService.test();
    }

}

动态代理其实就是在运行过程中动态地创建原始类对应的代理类，然后在系统中用代理类替换掉原始类。

我们常说 Spring AOP 就是基于动态代理实现的，同时 Spring 的事务中也用到了动态代理，那么看完上述的实现过程自然也知道了为什么 private 修饰的方法事务无法失效了～