设计模式之————结构型设计模式

结构型设计模式

//结构型模式总结:
/*

代理模式是做方法增强的，适配器模式是把鸡包装成鸭这种用来适配接口的，桥梁模式做到了很好的解耦，装饰模式从名字上就看得出来，
适合于装饰类或者说是增强类的场景，门面模式的优点是客户端不需要关心实例化过程，只要调用需要的方法即可，组合模式用于描述具有层次结构的数据，
享元模式是为了在特定的场景中缓存已经创建的对象，用于提高性能。

*/




//

//行为型模式
/*
行为型模式关注的是各个类之间的相互作用，将职责划分清楚，使得我们的代码更加地清晰
*/
//1.策略模式
/*
下面设计的场景是，我们需要画一个图形，可选的策略就是用红色笔来画，还是绿色笔来画，或者蓝色笔来画。

首先，先定义一个策略接口：

*/
public interface Strategy {
   public void draw(int radius, int x, int y);
}

//然后我们定义具体的几个策略：
public class RedPen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
   }
}
public class GreenPen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
   }
}
public class BluePen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
   }
}

//使用策略的类：
public class Context {
   private Strategy strategy;

 
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
 
   public int executeDraw(int radius, int x, int y){
      return strategy.draw(radius, x, y);
   }
}

//客户端
public static void main(String[] args) {
    Context context = new Context(new BluePen()); // 使用绿色笔来画
      context.executeDraw(10, 0, 0);
}
/*
总结：
其实策略模式和桥梁模式非常相似，只是桥梁模式的左边加了一层抽象而已。桥梁模式的耦合更低，结构更加复杂
*/
---------------------------------------------------------------------------------------------
//观察者模式
/*

观察者模式对于我们来说，真是再简单不过了。无外乎两个操作，观察者订阅自己关心的主题和主题有数据变化后通知观察者们。

*/

//首先，需要定义主题，每个主题需要持有观察者列表的引用，用于在数据变更的时候通知各个观察者：

public class Subject {
 
   private List<Observer> observers = new ArrayList<Observer>();
   private int state;
 
   public int getState() {
      return state;
   }
 
   public void setState(int state) {
      this.state = state;
      // 数据已变更，通知观察者们
      notifyAllObservers();
   }
 
   public void attach(Observer observer){
      observers.add(observer);        
   }
 
   // 通知观察者们
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }     
}

//定义观察者接口：
public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

/*

其实如果只有一个观察者类的话，接口都不用定义了，不过，通常场景下，既然用到了观察者模式，我们就是希望一个事件出来了，会有多个不同的类需要处理相应的信息。

比如，订单修改成功事件，我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。

我们来定义具体的几个观察者类：

*/
public class BinaryObserver extends Observer {
 
      // 在构造方法中进行订阅主题
    public BinaryObserver(Subject subject) {
        this.subject = subject;
        // 通常在构造方法中将 this 发布出去的操作一定要小心
        this.subject.attach(this);
    }
 
      // 该方法由主题类在数据变更的时候进行调用
    @Override
    public void update() {
        String result = Integer.toBinaryString(subject.getState());
        System.out.println("订阅的数据发生变化，新的数据处理为二进制值为：" + result);
    }
}
 
public class HexaObserver extends Observer {
 
    public HexaObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
 
    @Override
    public void update() {
          String result = Integer.toHexString(subject.getState()).toUpperCase();
        System.out.println("订阅的数据发生变化，新的数据处理为十六进制值为：" + result);
    }
}

//客户端
public static void main(String[] args) {
    // 先定义一个主题
      Subject subject1 = new Subject();
      // 定义观察者
      new BinaryObserver(subject1);
      new HexaObserver(subject1);
 
      // 模拟数据变更，这个时候，观察者们的 update 方法将会被调用
      subject.setState(11);
}

----------------------------------------------------------------------------------------------------------------------
//责任链模式
/*
责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。
比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。

有这么一个场景，用户参加一个活动可以领取奖品，但是活动需要进行很多的规则校验然后才能放行，
比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都通过后，才能让用户领走奖品。

*/
//首先，我们要定义流程上节点的基类：
public abstract class RuleHandler {
 
      // 后继节点
    protected RuleHandler successor;
 
    public abstract void apply(Context context);
 
    public void setSuccessor(RuleHandler successor) {
        this.successor = successor;
    }
    public RuleHandler getSuccessor() {
        return successor;
    }
}

//接下来，我们需要定义具体的每个节点了。 校验用户是否是新用户


public class NewUserRuleHandler extends RuleHandler {
 
    public void apply(Context context) {
        if (context.isNewUser()) {
              // 如果有后继节点的话，传递下去
            if (this.getSuccessor() != null) {
                this.getSuccessor().apply(context);
            }
        } else {
            throw new RuntimeException("该活动仅限新用户参与");
        }
    }
 
}

//校验用户所在地区是否可以参与
public class LocationRuleHandler extends RuleHandler {
    public void apply(Context context) {
        boolean allowed = activityService.isSupportedLocation(context.getLocation);
          if (allowed) {
            if (this.getSuccessor() != null) {
                this.getSuccessor().apply(context);
            }
        } else  {
            throw new RuntimeException("非常抱歉，您所在的地区无法参与本次活动");
        }
    }
}
//奖品已经领完
public class LimitRuleHandler extends RuleHandler {
    public void apply(Context context) {
          int remainedTimes = activityService.queryRemainedTimes(context); // 查询剩余奖品
        if (remainedTimes > 0) {
            if (this.getSuccessor() != null) {
                this.getSuccessor().apply(userInfo);
            }
        } else {
            throw new RuntimeException("您来得太晚了，奖品被领完了");
        }
    }
}
//客户端
public static void main(String[] args) {
    RuleHandler newUserHandler = new NewUserRuleHandler();
      RuleHandler locationHandler = new LocationRuleHandler();
      RuleHandler limitHandler = new LimitRuleHandler();
 
      // 假设本次活动仅校验地区和奖品数量，不校验新老用户
      locationHandler.setSuccessor(limitHandler);
      locationHandler.apply(context);
}
---------------------------------------------------------------------------------------
//状态模式
/*
商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。

核心在于，我们的关注点不再是 Context 是该进行哪种操作，而是关注在这个 Context 会有哪些操作。

*/

//定义状态接口
public interface State {
   public void doAction(Context context);
}

//定义减库存状态
public class DeductState implements State {
 
   public void doAction(Context context) {
      System.out.println("商品卖出，准备减库存");
      context.setState(this);
 
      //... 执行减库存的具体操作
   }
 
   public String toString(){
      return "Deduct State";
   }
}
//补库存状态
public class RevertState implements State {
    public void doAction(Context context) {
        System.out.println("给此商品补库存");
          context.setState(this);
 
          //... 执行加库存的具体操作
    }
      public String toString() {
        return "Revert State";
    }
}

//前面用到了 context.setState(this)，我们来看看怎么定义 Context 类：
public class Context {
    private State state;
      private String name;
      public Context(String name) {
        this.name = name;
    }
 
      public void setState(State state) {
        this.state = state;
    }
      public void getState() {
        return this.state;
    }
}
//客户端

public static void main(String[] args) {
    // 我们需要操作的是 iPhone X
    Context context = new Context("iPhone X");
 
    // 看看怎么进行补库存操作
      State revertState = new RevertState();
      revertState.doAction(context);
 
    // 同样的，减库存操作也非常简单
      State deductState = new DeductState();
      deductState.doAction(context);
 
      // 如果需要我们可以获取当前的状态
    // context.getState().toString();
}