代理模式

定义

代理模式(Proxy)：为其它对象提供一种代理以控制对这个对象的访问。

类图

实现要点

• 代理类实现被代理类实现的相同接口，来保证代理类和被代理类功能一致

• 代理类保存一个被代理类的引用，实际调用改引用来实现接口

Java示例

接口：

public interface UserService {

    boolean sign(String name);
}

被代理类：

public class UserServiceImpl implements UserService {
    @Override
    public boolean sign(String name) {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(name + " signin");
        return true;
    }
}

代理类：

public class StaticProxy implements UserService {

    private UserServiceImpl userServiceImpl;

    public StaticProxy(UserServiceImpl userServiceImpl) {
        this.userServiceImpl = userServiceImpl;
    }

    @Override
    public boolean sign(String name) {
        System.out.println("StaticProxy=>sign start");
        long start = System.currentTimeMillis();
        boolean result = userServiceImpl.sign(name);
        System.out.println("StaticProxy=>sign end, cost " + (System.currentTimeMillis() - start) + "ms");
        return result;
    }

    public static void main(String[] args) {
        UserServiceImpl userServiceImpl = new UserServiceImpl();
        StaticProxy proxy = new StaticProxy(userServiceImpl);

        proxy.sign("cdfive");
    }
}

输出结果：
StaticProxy=>sign start
cdfive signin
StaticProxy=>sign end, cost 200ms

这里的StaticProxy类实现了被代理类UserServiceImpl相关的接口UserService，通过一个变量保存了被代理类的引用UserServiceImpl；
接口实现里，调用UserServiceImpl的sign方法，并在调用前后打印了日志以及耗时情况。

这种用一个代理类对业务接口的实现类进行包装，称之为静态代理。

优点：简单直观
缺点：如果其他业务接口也需要类似处理，比如打印日志及耗时，按这种方式则需要每个接口类添加一个代理类，并且多个代理类存在代码重复。

JDK动态代理

JDK动态代理是代理类不是编码阶段创建，而是在程序调用时，JVM根据传进来的业务实现类对象以及方法名，动态地创建了一个代理类的class文件并被字节码引擎执行，然后通过该代理类对象进行方法调用。

实现方式：利用JDK提供的java.lang.reflect包下的相关类实现，包括：InvocationHandler、Proxy、Method。

示例1：

public class JDKDynamicProxy {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class<?>[]{UserService.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("JDKDynamicProxy=>" + method.getName() + " start");
                        long start = System.currentTimeMillis();
                        Object result = method.invoke(userService, args);
                        System.out.println("JDKDynamicProxy=>" + method.getName() + " end, cost " + (System.currentTimeMillis() - start) + "ms");
                        return result;
                    }
                });

        proxy.sign("cdfive");
    }
}

通过Proxy类的静态方法：public static Object Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)方法创建代理对象；
其中第3个参数是一个接口：

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

通过Object result = method.invoke(userService, args);来调用实际对象方法，注意invoke的第1个参数为实际被代理类的对象。

示例2：

public class JDKDynamicProxyFactory implements InvocationHandler {

    private Object target;

    public <T> T bind(Object target) {
        this.target = target;

        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("JDKDynamicProxy=>" + method.getName() + " start");
        long start = System.currentTimeMillis();

        Object result = method.invoke(target, args);

        System.out.println("JDKDynamicProxy=>" + method.getName() + " end, cost " + (System.currentTimeMillis() - start) + "ms");
        return result;
    }
}

public class JDKDynamicProxy2 {
    public static void main(String[] args) {
        UserServiceImpl userServiceImpl = new UserServiceImpl();

        JDKDynamicProxyFactory proxyFactory = new JDKDynamicProxyFactory();
        UserService userService = proxyFactory.bind(userServiceImpl);

        userService.sign("cdfive");
    }
}

示例2对做了一个小优化：
封装了一个通用的JDKDynamicProxyFactory类，它实现InvocationHandler 接口；
保存了target引用，通过定义的bind方法返回实际被代理对象；// 注：这里bind方法的返回值没有定义为Object，而是通过泛型<T> T定义，这样避免了使用时进行强制转换。
实现的invoke方法逻辑不变。

通过这种方式支持不同接口对象代理，并且消除了使用时的重复代码。
比如另一个业务接口实现XxxServiceImpl，也可以用proxyFactory.bind(xxxServiceImpl)绑定来进行代理。