代理模式

代理模式（Proxy）

引言

​ 先说个简单的例子：游戏代练应该都听说过，许多人肯定也找过代练，曾经DNF、LOL、COC等等游戏的代练很多，当然现在各类游戏层出不穷，也都有各种代练，那这里所谓的代练是什么？就是Proxy，也即代理类，那游戏代练这件事就是一个代理模式。

如果觉得不好理解可以这么想，代练的流程是，你把自己的账号交给代练人员，让他们帮你打怪升级，而你只需要提供账号即可。那代练人员那边，他所要做的就是登陆你的账号，然后替你打游戏，从第三者的角度来看，你这个角色在打怪升级，但这个第三者并不知道是不是你本人在打游戏，他只能看到你这个账号正在打怪升级，但并不需要知道后面打游戏的是谁。这就是代理模式，由他人代理玩游戏。

​ 如果觉得这个还不好理解，那再说一个例子。假设我现在要邀请明星来上节目，我是直接给这个明星打电话吗？当然不是，是给他的经纪人打电话，然后再由经纪人通知到该明星，这里经纪人充当的就是代理的角色。

定义

允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。

结构类图

Context：状态管理器,它定义了客户感兴趣的接口，这个接口是由State去实现的；并维护一个ConcreteState子类的实例，这个实例定义当前的状态，当前状态变化的时候，会将变化后的ConcreteState返回给当前状态。
state：状态，定义一个接口以封装与Context的特定状态相关的行为，但是行为本身是空的，该行为是由ConcreteState来实现的。
ConcreteState：具体状态子类，每一个子类实现一个与Context的一个状态相关的行为。

1.Context类

环境角色具有两个职责：1处理本状态必须完成的任务，2决定是否可以过渡到其它状态。
对于环境角色，有几个不成文的约束：

• 即把状态对象声明为静态常量，有几个状态对象就声明几个状态常量

• 环境角色具有状态抽象角色定义的所有行为，具体执行使用委托方式

  public class Context {
  
      //定义状态
      public final static State STATE1 = new ConcreteState1();
      public final static State STATE2 = new ConcreteState2();
      
      //当前状态
      private State currentState;
      
      //获得当前状态
      public State getCurrentState() {
          return currentState;
      }
  
      //设置当前状态
      public void setCurrentState(State currentState) {
          this.currentState = currentState;
  //        System.out.println("当前状态：" + currentState);
          //切换状态
          this.currentState.setContext(this);
      }
      
      public void handle1() {
          this.currentState.handle1();
      }
      public void handle2() {
          this.currentState.handle2();
      }
      
  }
  

2.State抽象状态类

抽象状态中声明一个环境角色，提供给各个状态类自行访问，并且提供所有状态的抽象行为，由各个实现类实现。

public abstract class State {
    
    protected Context context;
    public void setContext(Context context) {
        this.context = context;
    }

    //行为1
    public abstract void handle1();
    //行为2
    public abstract void handle2();
    
}

3.具体状态

具体状态实现，这里以定义ConcreteState1和ConcreteState2两个具体状态类为例，ConcreteState2的具体内容同ConcreteState1。

public class ConcreteState1 extends State {

    @Override
    public void handle1() {
        //...
        System.out.println("ConcreteState1 的 handle1 方法");
    }

    @Override
    public void handle2() {
        super.context.setCurrentState(Context.STATE2);
        System.out.println("ConcreteState1 的 handle2 方法");
    }
    
}

4.Client客户端

public class Client {

    public static void main(String[] args) {
        //定义环境角色
        Context context = new Context();
        //初始化状态
        context.setCurrentState(new ConcreteState1());
        //行为执行
        context.handle1();
        context.handle2();
    }
    
}

适用性

当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式。

一个操作中含有庞大的条件语句（分支机构），并且这些分支决定于对象的状态。

优点

• 结构清晰，避免了过多的switch…case或if…else语句的使用
• 很好的体现了开闭原则和单一职责原则，想要增加状态就增加子类，想要修改状态就修改子类即可
• 封装性非常好，状态变化放置到了类的内部来实现，外部调用不需要知道类内部如何实现状态和行为的变换

缺点

导致较多的ConcreteState子类，系统变复杂

例子

我们经常坐电梯都知道，电梯有多种状态，就按最简单的来说，包括运行状态、停止状态、开门状态、闭门状态。下面就以电梯运行为例，举一个具体的实例，UML图如下：

1.环境角色Context

首先定义出电梯的所有状态，然后定义当前电梯状态，再定义四种状态对应的方法，如Openning状态是由open()方法产生的。至于这些方法中的逻辑，就用print来代替了。

public class Context {
    //定义出电梯的所有状态
    public final static LiftState OPENNING_STATE = new OpenningState();
    public final static LiftState CLOSING_STATE = new ClosingState();
    public final static LiftState RUNNING_STATE = new RunningState();
    public final static LiftState STOPPING_STATE = new StoppingState();

    //定义一个当前电梯状态
    private LiftState liftState;

    public LiftState getLiftState() {
        return liftState;
    }

    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        //通知到各个实现类中
        this.liftState.setContext(this);
    }

    public void open() {
        this.liftState.open();
    }

    public void close() {
        this.liftState.close();
    }

    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }
}

2.抽象电梯状态LiftState

这里我们定义并把Context这个环境角色聚合进来，并传递到子类。所以我们可以这样理解，Context环境角色的作用就是串联各个状态的过渡，也就是在4个具体的实现类中，各自根据自己的环境来决定如何进行状态的过渡。

public abstract class LiftState {

    protected Context context;
    
    public void setContext(Context context) {
        this.context = context;
    }
    
    //电梯门开启动作
    public abstract void open();
    //电梯门关闭动作
    public abstract void close();
    //电梯运行
    public abstract void run();
    //电梯停止
    public abstract void stop();
    
}

3. 电梯开门状态

对于开门状态，除去自身的开启电梯门的方法之外，在打开门之后应该还具备关闭电梯门的功能，而门开着的时候是不能运行也不能停止的。

public class OpenningState extends LiftState {
    
    //执行打开电梯门方法
    @Override
    public void open() {
        System.out.println("电梯门开启");
    }

    //打开后还可以关闭电梯门
    @Override
    public void close() {
        //状态修改
        super.context.setLiftState(Context.CLOSING_STATE);
        //动作委托为CLOSING_STATE执行
        super.context.getLiftState().close();
    }

    //门开着不能运行
    @Override
    public void run() {
        //什么都不做
    }

    //门开着已经停止了
    @Override
    public void stop() {
        //什么都不做
    }

}

4. 电梯闭门状态

对于闭门状态，除去自身外，电梯门关闭之后还可以再度打开，所以有open()方法；而门关了之后是可以运行的，所以有run()方法；如果关了门没有按楼层的话，此时电梯处于停止状态，所以有stop()方法。

public class ClosingState extends LiftState {

    //电梯门关了可以再开
    @Override
    public void open() {
        //置为敞门状态
        super.context.setLiftState(Context.OPENNING_STATE);
        super.context.getLiftState().open();
    }

    // * 执行电梯门关闭方法
    @Override
    public void close() {
        System.out.println("电梯门关闭");
    }

    //电梯门关了就运行
    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    //电梯门关了但没有按楼层
    @Override
    public void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }

}

5.电梯运行状态

当电梯处于运行状态时，此时当然是不能开门的；而门肯定是关了的，所以也不必执行关门方法；此时电梯可以从运行状态转变为停止状态。

public class RunningState extends LiftState {

    //运行时不能开门
    @Override
    public void open() {
        //什么都不做
    }

    //运行时门肯定是关的
    @Override
    public void close() {
        //什么都不做
    }

    // * 执行运行方法
    @Override
    public void run() {
        System.out.println("电梯运行中");
    }

    //运行后可以停止
    @Override
    public void stop() {
        //环境设置为停止状态
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.getLiftState().stop();
    }

}

6. 电梯停止状态

当电梯处于停止状态时，门是关闭着的，所以不能执行关门的方法；但此时是可以开门的；而停止后电梯也可以再度运行，所以存在run()方法。

public class StoppingState extends LiftState {

    //停下了要开门
    @Override
    public void open() {
        super.context.setLiftState(Context.OPENNING_STATE);
        super.context.getLiftState().open();
    }

    //门本来就是关着的
    @Override
    public void close() {
        //什么都不做
    }

    //停止后可以再运行
    @Override
    public void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.getLiftState().run();
    }

    //执行停止方法
    @Override
    public void stop() {
        System.out.println("电梯停止了");
    }

}

7. Client客户端

这里假设初始状态为闭门状态，大家可以自行尝试其它初始值。

public class Client {
    public static void main(String[] args) {
        Context context = new Context();        
        //定义初始状态为关门（共四种初始值）
        context.setLiftState(new ClosingState());
        context.open();
        context.close();
        context.run();
        context.stop();
    }
    
}