代理模式总结

代理模式概念：

相关角色：代理接口（Subject)；代理类(ProxySubject)；委托类(RealSubject)；客户端(Client)。

举个不太恰当的例子，某广告公司Ｃ希望请明星Ａ拍一支广告，Ａ有经纪公司B，Ｂ帮助Ａ和公司Ｃ进行沟通，也就是说，除了拍广告本身这件事情仍然由Ａ来做，其他事情都由他的经纪公司Ｂ来负责处理。
在这个例子中拍广告是代理接口；经纪公司Ｂ是代理类；明星Ａ是委托类；而广告公司Ｃ可以被认为是客户端。
一切顺利的话，事情的结果自然是公司(Client)通过经纪公司(ProxySubject)让明星A(RealSubject)替他们拍了广告。

StaticProxy

代理模式目的：

业务类只需要关注业务逻辑本身，保证了业务类的重用性。为业务对象提供一个代理，以控制对这个业务对象的访问。并且无需对业务类本身进行修改，可控制其上下文操作。

代理模式分类：

根据代理类生成的时间不同可以分为静态代理和动态代理两种。

静态代理

在程序运行之前，代理类就已经存在了。

• 优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。
• 缺点：如果接口增加了一个方法，除了所有实现类都要去实现这个方法之外，所有代理类也需要实现此方法，增加了代码维护的复杂度。

继续用上面的例子说，明星A除了会拍广告还学会了拍电影，那么经纪公司就不能只知道拍广告是什么流程了，还得知道拍电影的流程。

动态代理

在程序运行时，代理类才产生。
目的：构造通用的代理类。
思想：把所有触发RealSubject的动作交给一个触发管理器--InvocationHandler。 外界对代理类中每个方法的调用，代理类都回交给InvocationHandler来处理。
方法：在代理类中传入具体对象时，通过其class反射获取对象在方法区的结构，包括其构造方法，成员变量和实现方法等。外界要求代理调用具体的方法时，就根据反射到的内容返回出对应的信息。这些信息是在运行时才能够被确定的。

• 优点：不需要像静态代理那样被接口方法牵着鼻子走。
• 缺点：每次都需要有一个具体对象被传入到方法中，但并不是所有时候都由被实例化的对象可以被传入。

DynamicProxy.png

应用：

Spring的AOP，面向切面编程。其实就是把几个方法的公共部分提取出来做成切面类，如果这部分代码需要被修改则只需要修改这一部分，其他不同的部分用不同的代理类实现，保证了程序的灵活性。

RPC框架，远程服务调用。比如主机A上有一个服务，主机B和C都希望调用这个服务，那么主机A上首先有一个该服务对应的代理，用于解析其他服务器发来的请求中的参数，B和C也有各自的代理类，用来封装自己要发送的参数成二进制，通过网络发给A的代理，A的代理类解析之后把服务返回的内容封装好通过网络再发还给B和C的代理，B和C的代理各自解析之后就获得了对应的结果。

对于B和C来说，无需知道底层是如何操作的，就好像调用了自己本地的方法一样。

示例：

/* 自定义代理通过实现此接口实现对原方法前后的各种操作
*  proxy为要实现的代理类，method为所调用服务的原生方法，args为method的参数
*  在实现此接口的代理类中，可以在invoke方法中增加任意功能
*  比如method是一个添加用户的方法，那么在实现类中可以在此方法执行之前增加检查权限等操作
*/
public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args){
        throws Throwable;
    }
}


// 首先需要一个接口，用于被各种自定义类统一实现
public interface UserManager{
    public void addUser(String name);
}

// 然后需要一个实现此接口的类（委托类）
public class UserManagerImpl implements UserManager{
    public void addUser(String name){
        System.out.println("User " + name + " is added");
    }
}

// 自定义代理类
public CheckHandler implements InvocationHandler{
    //代理的目标对象
    private Object target;
    //通过构造函数动态传入对象
    public CheckHandler(Object target){
        this.target = target;
    }
    
    //动态代理执行操作
     @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //检查当前用户是否有权限添加user
        System.out.println("Checking...");
        //有权限就执行，可以添加判断操作，此处省略
        //此处参数为被代理对象
        return method.invoke(target, args);
        
        System.out.println("Success.");
    }    
}

// 相关的类：
public class Proxy implements java.io.Serializable{
    ……
    //此静态方法用于创建对应的代理类对象
    public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) throws IllegalArgumentException{
        Objects.requireNonNull(h);
        final Class[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
    ……
}

在客户端调用动态代理

public class Client{
    public static void main(String[] args){
        String name = "a";
        //创建要代理的对象
        UserManager um = new UserManagerImpl(name);
        //创建代理
        InvocationHandler handler = new CheckHandler(um);
        UserManager m = (UserManager)Proxy.newProxyInstance(um.getClass().getClassLoader(),um.getClass().getInterfaces(), handler);
        m.addUser(name);
    }
}

结果输出

//在不改变addUser()方法的前提下，增加了检查和反馈的操作

Checking...
User a is added.
Success.