结构型模式之--代理模式

游戏代理

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上。

游戏代练帮忙打怪升级

游戏者接口，抽象游戏过程：

public interface IGamePlayer {
    //登录游戏
    public void login(String user,String password);
    //杀怪，网络游戏的主要特色
    public void killBoss();
    //升级
    public void upgrade();
}

游戏者（被代理类），覆写所有方法：

public class GamePlayer implements IGamePlayer {
    private String name = "";

    //通过构造函数传递名称
    public GamePlayer(String _name){
        this.name = _name;
    }
    //打怪
    public void killBoss() {
        System.out.println(this.name + "在打怪！");
    }
    //登录
    public void login(String user, String password) {
        System.out.println("登录名为"+user+"的用户"+this.name+"登录成功！");
    }
    //升级
    public void upgrade() {
        System.out.println(this.name + " 又升了一级！");
    }
}

代练者（代理类），实际调用的类：

public class GamePlayerProxy implements IGamePlayer {
    private IGamePlayer gamePlayer = null;

    //通过构造函数传递要对谁进行代练
    public GamePlayerProxy(IGamePlayer _gamePlayer){
        this.gamePlayer = _gamePlayer;
    }
    //代练杀怪
    public void killBoss() {//调用实际类的方法
        this.gamePlayer.killBoss();
    }
    //代练登录
    public void login(String user, String password) {
        this.gamePlayer.login(user, password);
    }
    //代练升级
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
}

场景类：

public class Client {
    public static void main(String[] args) {
        //定义一个玩家（创建被代理类的对象）
        IGamePlayer player = new GamePlayer("张三");
        //然后再定义一个代练者（创建代理类的对象）
        IGamePlayer proxy = new GamePlayerProxy(player);

        //通过代理对象执行方法
        proxy.login("zhangSan", "password");
        //开始杀怪
        proxy.killBoss();
        //升级
        proxy.upgrade();
    }
}

代理模式的定义

Provide a surrogate or placeholder for another object to control access to it.
为其他对象提供一种代理以控制对这个对象的访问。

静态代理
通用类图：

• Subject抽象主题类：可以是抽象类也可以是接口，定义业务类型。
• RealSubject具体主题类：委托角色、被代理角色。是业务逻辑的具体执行者。
• Proxy代理主题类：叫做委托类、代理类。负责对真实角色的应用，把所有抽象主题类定义的方法限制
  委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。

通用代码：
抽象主题类：

public interface Subject {
    //定义一个方法
    public void request();
}

真实主题类（被代理类）：

public class RealSubject implements Subject {
    //实现方法
    public void request() {
        //业务逻辑处理
    }
}

代理类：

public class Proxy implements Subject {
    //实现类（被代理类对象）
    private Subject subject = null;
    //默认被代理者
    public Proxy(){
        this.subject = new Proxy();
    }
    //通过构造函数传递代理者
    public Proxy(Subject _subject){
        this.subject = _subject;
    }
    //实现接口中定义的方法
    public void request() {
        this.before();
        this.subject.request();
        this.after();
    }
    //预处理
    private void before(){
        //do something
    }
    //善后处理
    private void after(){
        //do something
    }
}

代理模式的应用

优点：

• 职责清晰：真实的角色就是实现实际的业务逻辑，不用关心其他非本职责的事务，通过后期的代理
  完成事务。
• 高扩展性：由于代理类和被代理类都实现了接口，当被代理类的具体实现逻辑方法发生变化时，其他代码无需修改。
• 智能化：动态代理体现

应用：
像由律师代理打官司，你不用参与中间过程的是是非非，只要完成自己的答辩就成，其他的比如事前调查、事后追查都由律师来搞定，这就是为了减轻你的负担。

Spring AOP，是一个非常典型的动态代理。

代理模式的扩展

普通代理就是我们要知道代理的存在，也就是类似的 GamePlayerProxy 这个类的存在，然后才能访问；强制代理则是调用者直接调用真实角色，而不用关心代理是否存在，其代理的产生是由真实角色决定的。

普通代理

要求客户端只能访问代理角色，而不能访问真实角色。即不能再客户端new 一个被代理类的实例。代理类需要在构造函数中 new 一个 被代理类的实例，然后调用相应的方法。

在这种改造下，系统更加简洁了，调用者只知道代理存在就可以，不用知道代理了谁。

场景类不能再直接new一个GamePlayer对象了，必须由 GamePlayerProxy 来进行模拟场景。

需要修改 GamePlayerProxy 的构造函数，只传入 name；
GamePlayer的构造函数增加了 _gamePlayer 参数：

修改类图：

被代理类：

在构造函数中，传递进来一个IGamePlayer对象，检查谁能创建真实的角色，当然还可以有其他的限制，比如类名必须为Proxy类等，读者可以根据实际情况进行扩展。

public class GamePlayer implements IGamePlayer {
    private String name = "";
    //构造函数限制谁能创建对象，并同时传递姓名
    public GamePlayer(IGamePlayer _gamePlayer,String _name) throws Exception{
        if(_gamePlayer == null ){
            throw new Exception("不能创建真实角色！");
        }else{
            this.name = _name;
        }
    }
    //打怪
    public void killBoss() {
        System.out.println(this.name + "在打怪！");
    }
    //登录
    public void login(String user, String password) {
        System.out.println("登录名为"+user + "的用户" + this.name + "登录成功！");
    }
    //升级
     public void upgrade() {
        System.out.println(this.name + " 又升了一级！");
    }
}

代理类：

public class GamePlayerProxy implements IGamePlayer {
    private IGamePlayer gamePlayer = null;
    //通过构造函数传递要对谁进行代练
    public GamePlayerProxy(String name){
        try {
            gamePlayer = new GamePlayer(this,name);
        } catch (Exception e) {
            // TODO 异常处理
        }
    }
    //代练杀怪
    public void killBoss() {
        this.gamePlayer.killBoss();
    }
    //代练登录
    public void login(String user, String password) {
        this.gamePlayer.login(user, password);
    }
    //代练升级
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
}

场景类：

不用再 new 一个 被代理类。直接通过代理类进行相应操作。

public class Client {
    public static void main(String[] args) {
    //然后再定义一个代练者
    IGamePlayer proxy = new GamePlayerProxy("张三");
     proxy.login("zhangSan", "password");
    //开始杀怪
    proxy.killBoss();
    //升级
    proxy.upgrade();
    }
}

运行结果完全相同。在该模式下，调用者只知代理而不用知道真实的角色是谁，更加屏蔽了真实角色的变更对高层模块的影响，真实的主题角色想怎么修改就怎么修改，对高层次的模块没有任何的影响，只要你实现了接口所对应的方法，该模式非常适合对扩展性要求较高的场合。当然，在实际的项目中，一般都是通过约定来禁止new一个真实的角色，这也是一个非常好的方案。

强制代理

强制代理的概念就是要从真实角色查找到代理角色，不允许直接访问真实角色。高层模块只要调getProxy就可以访问真实角色的所有方法，它根本就不需要产生一个代理出来，代理的管理已经由真实角色自己完成。

接口类：

增加了一个getProxy方法，指定要访问自己必须通过哪个代理。

public interface IGamePlayer {
    //登录游戏
    public void login(String user,String password);
    //杀怪
    public void killBoss();
    //升级
    public void upgrade();
    //每个人都可以找一下自己的代理
    public IGamePlayer getProxy();
}

被代理类：

getProxy()函数 new 了一个自己代理的实例，并返回。
所有方法访问前都需要判断检查是否是自己指定的代理，是指定的代理则允许访问，否则不允许访问。

public class GamePlayer implements IGamePlayer {
    private String name = "";
    //我的代理是谁
    private IGamePlayer proxy = null;

    public GamePlayer(String _name){
            this.name = _name;
    }
    //找到自己的代理
    public IGamePlayer getProxy(){
        this.proxy = new GamePlayerProxy(this);
        return this.proxy;
    }
    //打怪，最期望的就是杀老怪
    public void killBoss() {
        if(this.isProxy()){
            System.out.println(this.name + "在打怪！");
        }else{
            System.out.println("请使用指定的代理访问");
        }
    }
    //进游戏之前你肯定要登录吧，这是一个必要条件
    public void login(String user, String password) {
        if(this.isProxy()){
            System.out.println("登录名为"+user+"的用户"+this.name+"登录成功！");
        }else{
            System.out.println("请使用指定的代理访问");;
        }
    }
    //升级，升级有很多方法，花钱买是一种，做任务也是一种
    public void upgrade() {
        if(this.isProxy()){
            System.out.println(this.name + " 又升了一级！");
        }else{
            System.out.println("请使用指定的代理访问");
        }
    }
    //校验是否是代理访问
    private boolean isProxy(){
        if(this.proxy == null){
            return false;
        }else{
            return true;
        }
    }
}

代理类：

public class GamePlayerProxy implements IGamePlayer {
    private IGamePlayer gamePlayer = null;
    //构造函数传递用户名
    public GamePlayerProxy(IGamePlayer _gamePlayer){
        this.gamePlayer = _gamePlayer;
    }
    //代练杀怪
    public void killBoss() {
        this.gamePlayer.killBoss();
    }
    //代练登录
    public void login(String user, String password) {
        this.gamePlayer.login(user, password);
    }
    //代练升级
    public void upgrade() {
        this.gamePlayer.upgrade();
    }
    //代理的代理暂时还没有，就是自己
    public IGamePlayer getProxy(){
        return this;
    }
}

场景类：
直接new一个真实角色，.然后调用 getProxy() 方法返回代理对象，才能调用相应的方法。

public class Client {
    public static void main(String[] args) {
        //定义一个游戏的角色
        IGamePlayer player = new GamePlayer("张三");
        //获得指定的代理
        IGamePlayer proxy = player.getProxy();

        proxy.login("zhangSan", "password");
        //开始杀怪
        proxy.killBoss();
        //升级
        proxy.upgrade();
    }
}

代理是有个性的

代理类不仅仅可以实现主题接口，也可以实现其他接口完成更多的任务。而且代理的目的是在目标对象方法的基础上作增强，这种增强的本质通常就是对目标对象的方法进行拦截和过滤。

代理类可以为真实角色预处理消息、过滤消息、消息转发、事后处理消息等功能。

比如：游戏代理是需要收费的，升一级需要5元钱，这个计算功能就是代理类的个性，它应该在代理的接口中定义。

增加了一个IProxy接口，其作用是计算代理的费用。

计算代理费的接口：

public interface IProxy {
    //计算费用
    public void count();
}

代理类：
代理类也实现了计费接口，实现了计费功能。

public class GamePlayerProxy implements IGamePlayer,IProxy {
    private IGamePlayer gamePlayer = null;
    //通过构造函数传递要对谁进行代练
    public GamePlayerProxy(IGamePlayer _gamePlayer){
        this.gamePlayer = _gamePlayer;
    }
    //代练杀怪
    public void killBoss() {
        this.gamePlayer.killBoss();
    }
    //代练登录
    public void login(String user, String password) {
        this.gamePlayer.login(user, password);
    }
    //代练升级
    public void upgrade() {
        this.gamePlayer.upgrade();
        this.count();
    }
    //计算费用
    public void count(){
        System.out.println("升级总费用是：150元");
    }
}

一个代理类，可以代理多个真实角色，并且真实角色之间可以有耦合关系，通过实现多接口。

动态代理

上面的需要自己 new 代理类的方式都是静态代理。

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建被代理类的代理对象。

动态代理使用场合:

• 调试
• 远程方法调用

InvocationHandler接口和GamePlayIH类，作用就是产生一个对象的代理对象，其中InvocationHandler是JDK提供的动态代理接口，对被代理类的方法进行代理。

接口类和被代理类不变：

public interface IGamePlayer {
    //登录游戏
    public void login(String user,String password);
    //杀怪，网络游戏的主要特色
    public void killBoss();
    //升级
    public void upgrade();
}

public class GamePlayer implements IGamePlayer {
    private String name = "";

    //通过构造函数传递名称
    public GamePlayer(String _name){
        this.name = _name;
    }
    //打怪
    public void killBoss() {
        System.out.println(this.name + "在打怪！");
    }
    //登录
    public void login(String user, String password) {
        System.out.println("登录名为"+user+"的用户"+this.name+"登录成功！");
    }
    //升级
    public void upgrade() {
        System.out.println(this.name + " 又升了一级！");
    }
}

动态代理类：
动态代理类不用再像静态代理类那样实现 IGamePlayer 接口，
通过InvocationHandler接口，所有方法都由该Handler来进行处理，即所有被代理的方法都由InvocationHandler接管实际的处理任务。

public class GamePlayIH implements InvocationHandler {
    //实现了接口的被代理类的对象的声明
    Object obj = null;
    //动态生成一个给定对象（被代理对象）的 代理对象，并返回
    public Object blind(Object _obj){
        this.obj = _obj;
        //参数：(被代理类的类加载器，被代理类的的全部接口，GamePlayIH对象本身)
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }
    //调用被代理的方法
    //当通过代理类的对象发起对被代理的方法的调用时，都会转换为对如下的invoke方法的调用
    @Override    //参数：(被代理的对象,要调用的方法,方法调用时所需要的参数)
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnVal= method.invoke(this.obj, args);
        return returnVal;
    }
}

场景类:

public class Client {
    public static void main(String[] args) throws Throwable {
        //1.被代理类的对象
        IGamePlayer player = new GamePlayer("张三");
        //2.创建一个实现了 InvacationHandler接口的类的对象
        GamePlayIH handler = new GamePlayIH();
        //3.调用blind()方法，动态的返回一个同样实现了player所在类实现的接口IGamePlayer的代理类的对象。
        IGamePlayer proxy = (IGamePlayer)handler.blind(player );

        //登录
        proxy.login("zhangSan", "password");
         //开始杀怪
        proxy.killBoss();
        //升级
        proxy.upgrade();
    }
}

可以通过动态代理类，动态的向 执行原被代理类的方法时，加入执行额外的代码。这就是AOP编程。
如可以通过下面方法，在登陆时打印 登陆消息：

    //调用被代理的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(this.obj, args);
        //如果是登录方法，则发送信息
        if(method.getName().equalsIgnoreCase("login")){
            System.out.println("有人在用我的账号登录！");
        }
        return result;
    }

动态代理与AOP（Aspect Orient Programming)

对于日志、事务、权限等都可以在系统设计阶段不用考虑，而在设计后通过AOP的方式切过去。

使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理
这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理

可以在动态生成代理类对象前切入，也可以在执行被代理对象方法前、后切入。

下面的例子过于麻烦，在具有通用性，是在动态生成代理类对象前切入，也可以在执行被代理对象方法前、后切入，简单的案例参考 https://blog.csdn.net/zxm1306192988/article/details/57084061

两条独立发展的线路。动态代理实现代理的职责，业务逻辑Subject实现相关的逻辑功能，两者之间没有必然的相互耦合的关系。通知Advice从另一个切面切入，最终在高层模块也就是Client进行耦合，完成逻辑的封装任务。

抽象主题：

public interface Subject {
    //业务操作
    public void doSomething(String str);
}

真实主题：

public class RealSubject implements Subject {
    //业务操作
    public void doSomething(String str) {
        System.out.println("do something!---->" + str);
    }
}

动态代理的Handler类 ：
所有通过动态代理实现的方法全部通过invoke方法调用

public class MyInvocationHandler implements InvocationHandler {
    //被代理的对象
    private Object target = null;
    //通过构造函数传递一个对象
    public MyInvocationHandler(Object _obj){
        this.target = _obj;
    }
    //代理方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //执行被代理的方法
        return method.invoke(this.target, args);
    }
}

动态代理类：

public class DynamicProxy<T> {
    public static <T> T newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
        //寻找JoinPoint连接点，AOP框架使用元数据定义
        if(true){
            //执行一个前置通知
            (new BeforeAdvice()).exec();
        }
        //执行目标，并返回结果，返回动态生成的代理类的对象
        return (T)Proxy.newProxyInstance(loader,interfaces, h);
    }
}

通知接口及实现：

public interface IAdvice {
    //通知只有一个方法，执行即可
    public void exec();
}

public class BeforeAdvice implements IAdvice{
    public void exec(){
        System.out.println("我是前置通知，我被执行了！");
    }
}

场景类：

public class Client {
    public static void main(String[] args) {
        //定义一个主题
        Subject subject = new RealSubject();
        //定义一个Handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        //定义主题的代理
        Subject proxy = DynamicProxy.newProxyInstance(subject.getClass().getClassLoader(), subject.getClass().getInterfaces(),handler);
        //代理的行为
        proxy.doSomething("Finish");
    }
}

运行结果：
我是前置通知，我被执行了！
do something!—->Finish

DynamicProxy类是一个通用类，我们再产生一个实现类，简化调用过程：
具体业务的动态代理：

public class SubjectDynamicProxy extends DynamicProxy{
    public static <T> T newProxyInstance(Subject subject){
        //获得ClassLoader
        ClassLoader loader = subject.getClass().getClassLoader();
        //获得接口数组
        Class<?>[] classes = subject.getClass().getInterfaces();
        //获得handler
        InvocationHandler handler = new MyInvocationHandler(subject);
        return newProxyInstance(loader, classes, handler);
    }
}

高层模块对代理的访问会更加简单：

public class Client {
    public static void main(String[] args) {
        //定义一个主题
        Subject subject = new RealSubject();
        //定义主题的代理
        Subject proxy = SubjectDynamicProxy.newProxyInstance(subject);
        //代理的行为
        proxy.doSomething("Finish");
    }
}

最佳实践

有了AOP大家写代理就更加简单了，有类似Spring AOP和AspectJ这样非常优秀的工具，拿来主义即可！
在学习AOP框架时，弄清楚几个名词：切面（Aspect）、切入点（JoinPoint）、通知（Advice）、织入（Weave）。

参考资料：
【1】《设计模式之禅》-秦小波
【2】尚硅谷 java反射 https://blog.csdn.net/zxm1306192988/article/details/57084061