设计模式

https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247519642&idx=2&sn=10e781c825922e52f5275543f71cc256&chksm=fa4af22bcd3d7b3d8379cb3be4e713a9ca7e87003fa5f5bd1a416f7f794d3b12ac76ef0abb71&mpshare=1&scene=23&srcid=0628U9jPYbXp8UxTiIw5m3Uz&sharer_sharetime=1624842311298&sharer_shareid=f770d25bc57f1c2f9159f85750f854dc%23rd

设计模式三大类：

1.结构型模式
2.创建型模式
3.行为型模式

结构性模式

- 代理模式

代理模式是最常使用的模式之一了，用一个代理来隐藏具体实现类的实现细节，通常还用于在真实的实现的前后添加一部分逻辑。
既然说是代理 ，那就要对客户端隐藏真实实现，由代理来负责客户端的所有请求。当然，代理只是个代理，它不会完成实际的业务逻辑，而是一层皮而已，但是对于客户端来说，它必须表现得就是客户端需要的真实实现。

public interface FoodService {
    Food makeChicken();
    Food makeNoodle();
}

public class FoodServiceImpl implements FoodService {
    public Food makeChicken() {
          Food f = new Chicken()
        f.setChicken("1kg");
          f.setSpicy("1g");
          f.setSalt("3g");
        return f;
    }
    public Food makeNoodle() {
        Food f = new Noodle();
        f.setNoodle("500g");
        f.setSalt("5g");
        return f;
    }
}

// 代理要表现得“就像是”真实实现类，所以需要实现 FoodService
public class FoodServiceProxy implements FoodService {

    // 内部一定要有一个真实的实现类，当然也可以通过构造方法注入
    private FoodService foodService = new FoodServiceImpl();

    public Food makeChicken() {
        System.out.println("我们马上要开始制作鸡肉了");

        // 如果我们定义这句为核心代码的话，那么，核心代码是真实实现类做的，
        // 代理只是在核心代码前后做些“无足轻重”的事情
        Food food = foodService.makeChicken();

        System.out.println("鸡肉制作完成啦，加点胡椒粉"); // 增强
          food.addCondiment("pepper");

        return food;
    }
    public Food makeNoodle() {
        System.out.println("准备制作拉面~");
        Food food = foodService.makeNoodle();
        System.out.println("制作完成啦")
        return food;
    }
}

// 客户端调用，注意，我们要用代理来实例化接口：
// 这里用代理类来实例化
FoodService foodService = new FoodServiceProxy();
foodService.makeChicken();

如下图：

image.png

我们发现没有，代理模式说白了就是做 “方法包装” 或做 “方法增强” 。在面向切面编程中，其实就是动态代理的过程。比如 Spring 中，我们自己不定义代理类，但是 Spring 会帮我们动态来定义代理，然后把我们定义在 @Before、@After、@Around 中的代码逻辑动态添加到代理中。
说到动态代理，又可以展开说，Spring 中实现动态代理有两种，一种是如果我们的类定义了接口，如 UserService 接口和 UserServiceImpl 实现，那么采用 JDK 的动态代理，感兴趣的读者可以去看看 java.lang.reflect.Proxy 类的源码；另一种是我们自己没有定义接口的，Spring 会采用 CGLIB 进行动态代理，它是一个 jar 包，性能还不错。

- 适配器模式

说完代理模式，说适配器模式，是因为它们很相似，这里可以做个比较。
适配器模式做的就是，有一个接口需要实现，但是我们现成的对象都不满足，需要加一层适配器来进行适配。
适配器模式总体来说分三种：默认适配器模式、对象适配器模式、类适配器模式。先不急着分清楚这几个，先看看例子再说。

• 1.默认适配器模式
  首先，我们先看看最简单的适配器模式默认适配器模式(Default Adapter) 是怎么样的。
  我们用 Appache commons-io 包中的 FileAlterationListener 做例子，此接口定义了很多的方法，用于对文件或文件夹进行监控，一旦发生了对应的操作，就会触发相应的方法

public interface FileAlterationListener {
    void onStart(final FileAlterationObserver observer);
    void onDirectoryCreate(final File directory);
    void onDirectoryChange(final File directory);
    void onDirectoryDelete(final File directory);
    void onFileCreate(final File file);
    void onFileChange(final File file);
    void onFileDelete(final File file);
    void onStop(final FileAlterationObserver observer);
}

此接口的一大问题是抽象方法太多了，如果我们要用这个接口，意味着我们要实现每一个抽象方法，如果我们只是想要监控文件夹中的文件创建 和文件删除 事件，可是我们还是不得不实现所有的方法，很明显，这不是我们想要的。
所以，我们需要下面的一个适配器 ，它用于实现上面的接口，但是所有的方法都是空方法 ，这样，我们就可以转而定义自己的类来继承下面这个类即可。

public class FileAlterationListenerAdaptor implements FileAlterationListener {

    public void onStart(final FileAlterationObserver observer) {
    }

    public void onDirectoryCreate(final File directory) {
    }

    public void onDirectoryChange(final File directory) {
    }

    public void onDirectoryDelete(final File directory) {
    }

    public void onFileCreate(final File file) {
    }

    public void onFileChange(final File file) {
    }

    public void onFileDelete(final File file) {
    }

    public void onStop(final FileAlterationObserver observer) {
    }
}

比如我们可以定义以下类，我们仅仅需要实现我们想实现的方法就可以了：

public class FileMonitor extends FileAlterationListenerAdaptor {
    public void onFileCreate(final File file) {
        // 文件创建
        doSomething();
    }

    public void onFileDelete(final File file) {
        // 文件删除
        doSomething();
    }
}

• 2.对象适配器模式
  来看一个《Head First 设计模式》中的一个例子，我稍微修改了一下，看看怎么将鸡适配成鸭，这样鸡也能当鸭来用。因为，现在鸭这个接口，我们没有合适的实现类可以用，所以需要适配器

public interface Duck {
    public void quack(); // 鸭的呱呱叫
    public void fly(); // 飞
}

public interface Cock {
    public void gobble(); // 鸡的咕咕叫
    public void fly(); // 飞
}

// 野鸡
public class WildCock implements Cock{
    public void gobble() {
        System.out.println("咕咕叫");
    }
    public void fly() {
        System.out.println("鸡也会飞哦");
    }
}

鸭接口有 fly() 和 quare() 两个方法，鸡 Cock 如果要冒充鸭，fly() 方法是现成的，但是鸡不会鸭的呱呱叫，没有 quack() 方法。这个时候就需要适配了：

public class CockAdapter implements Duck{
    Cock cock;

    public CockAdapter(Cock cock) {
        this.cock = cock;
    }

    // 实现鸭的呱呱叫方法
    @Override
    public void quack() {
        // 内部其实是一只鸡的咕咕叫
        cock.gobble();
    }

    @Override
    public void fly() {
        cock.fly();
    }
}

public static void main(String[] args) {
        //有一只野鸡
        Cock wildCock = new WildCock();
        // 成功将野鸡适配成鸭
        Duck duck = new CockAdapter(wildCock);
        duck.quack();
        duck.fly();
    }

输出:
咕咕叫
鸡也会飞哦

• 如下图:

  
  image.png

3.类适配器模式

image.png

看到这个图，大家应该很容易理解的吧，通过继承的方法，适配器自动获得了所需要的大部分方法。这个时候，客户端使用更加简单，直接 Target t = new SomeAdapter(); 就可以了

适配器模式总结：

• 1.类适配和对象适配的异同
  一个采用继承，一个采用组合；
  类适配属于静态实现，对象适配属于组合的动态实现，对象适配需要多实例化一个对象。
  总体来说，对象适配用得比较多

• 2.适配器模式和代理模式的异同
  比较这两种模式，其实是比较对象适配器模式和代理模式，在代码结构上，它们很相似，都需要一个具体的实现类的实例。但是它们的目的不一样，代理模式做的是增强原方法的活；适配器做的是适配的活，为的是提供“把鸡包装成鸭，然后当做鸭来使用”，而鸡和鸭它们之间原本没有继承关系

  
  image.png

- 桥梁模式

理解桥梁模式，其实就是理解代码抽象和解耦。

// 1.我们首先需要一个桥梁，它是一个接口，定义提供的接口方法
public interface DrawAPI {
    public abstract void draw(int radius, int x, int y);
}

//2.然后是一系列实现类
public class RedPen implements DrawAPI{
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用红色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }
}

public class GreenPen implements DrawAPI{
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }
}

public class BluePen implements DrawAPI{
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用蓝色笔画图，radius:" + radius + ", x:" + x + ", y:" + y);
    }
}

//3.定义一个抽象类，此类的实现类都需要使用 DrawAPI：
public abstract class Shape {
    protected DrawAPI drawAPI;
    protected Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }
    public abstract void draw();
}

//4.定义抽象类的子类：
public class Circle extends Shape{
    private int radius;
    public Circle(int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.radius = radius;
    }
    public void draw() {
        drawAPI.draw(radius, 0, 0);
    }
}

public class Rectangle extends Shape{
    private int x;
    private int y;
    public Rectangle(int x, int y, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
    }
    public void draw() {
        drawAPI.draw(0, x, y);
    }
}

//5.客户端演示
public static void main(String[] args) {
        Shape greenCircle = new Circle(10, new GreenPen());
        Shape redRectangle = new Rectangle(4, 8, new RedPen());
        greenCircle.draw();
        redRectangle.draw();
    }
}

输出：
用绿色笔画图，radius:10, x:0, y:0
用红色笔画图，radius:0, x:4, y:8

如下图：

image.png

- 装饰者模式

要把装饰模式说清楚明白，不是件容易的事情。也许读者知道 Java IO 中的几个类是典型的装饰模式的应用，但是读者不一定清楚其中的关系，也许看完就忘了，希望看完这节后，读者可以对其有更深的感悟。
首先，我们先看一个简单的图，看这个图的时候，了解下层次结构就可以了：

image.png
我们来说说装饰模式的出发点，从图中可以看到，接口 Component 其实已经有了 ConcreteComponentA 和 ConcreteComponentB 两个实现类了，但是，如果我们要增强 这两个实现类的话，我们就可以采用装饰模式，用具体的装饰器来装饰 实现类，以达到增强的目的

• 从名字来简单解释下装饰器。既然说是装饰，那么往往就是添加小功能 这种，而且，我们要满足可以添加多个小功能。最简单的，代理模式就可以实现功能的增强，但是代理不容易实现多个功能的增强，当然你可以说用代理包装代理的多层包装方式，但是那样的话代码就复杂了
• 首先明白一些简单的概念，从图中我们看到，所有的具体装饰者们 ConcreteDecorator* * 都可以作为 Component 来使用，因为它们都实现了 Component 中的所有接口。它们和 Component 实现类 ConcreteComponent 的区别是，它们只是装饰者，起装饰 作用，也就是即使它们看上去牛逼轰轰，但是它们都只是在具体的实现中加了层皮来装饰 而已

• 案例

下面来看看一个例子，先把装饰模式弄清楚，然后再介绍下 java io 中的装饰模式的应用。

• 最近大街上流行起来了“快乐柠檬”，我们把快乐柠檬的饮料分为三类：红茶(BlackTea)、绿茶(GreenTea)、咖啡(Coffee)，在这三大类的基础上，又增加了许多的口味，什么金桔柠檬红茶(LemonBlackTea)、金桔柠檬珍珠绿茶、芒果红茶(MangoBlackTea)、芒果绿茶、芒果珍珠红茶、烤珍珠红茶、烤珍珠芒果绿茶、椰香胚芽咖啡、焦糖可可咖啡等等，每家店都有很长的菜单，但是仔细看下，其实原料也没几样，但是可以搭配出很多组合，如果顾客需要，很多没出现在菜单中的饮料他们也是可以做的
• 在这个例子中，红茶、绿茶、咖啡是最基础的饮料，其他的像金桔柠檬、芒果、珍珠、椰果、焦糖等都属于装饰用的。当然，在开发中，我们确实可以像门店一样，开发这些类：LemonBlackTea、LemonGreenTea、MangoBlackTea、MangoLemonGreenTea......但是，很快我们就发现，这样子干肯定是不行的，这会导致我们需要组合出所有的可能，而且如果客人需要在红茶中加双份柠檬怎么办？三份柠檬怎么办？

// 1. 首先，定义饮料抽象基类：
public abstract class Beverage {
    // 返回描述
     public abstract String getDescription();
     // 返回价格
     public abstract double cost();
}

// 2. 然后是三个基础饮料实现类，红茶、绿茶和咖啡：
public class BlackTea extends Beverage{
    public String getDescription() {
        return "红茶";
    }

    public double cost() {
        return 10;
    }
}


public class GreenTea extends Beverage{
    public String getDescription() {
        return "绿茶";
    }

    public double cost() {
        return 11;
    }
}

// 省略咖啡类...

// 3.定义调料，也就是装饰者的基类，此类必须继承自 Beverage
public abstract class Condiment extends Beverage{}

// 4.然后我们来定义柠檬、芒果等具体的调料，它们属于装饰者，毫无疑问，这些调料肯定都需要继承调料 Condiment 类
public class Lemon extends Condiment{
    private Beverage beverage;

    // 这里很关键，需要传入具体的饮料，如需要传入没有被装饰的红茶或绿茶，
    // 当然也可以传入已经装饰好的芒果绿茶，这样可以做芒果柠檬绿茶
    public Lemon(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加柠檬";
    }

    @Override
    public double cost() {
        return beverage.cost() + 2; // 加柠檬需要 2 元
    }
}


public class Mango extends Condiment{
    private Beverage beverage;

    public Mango(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加芒果";
    }

    @Override
    public double cost() {
        return beverage.cost() + 3; // 加芒果需要 3 元
    }
}


public class Pearl extends Condiment{
    private Beverage beverage;

    public Pearl(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + ", 加珍珠";
    }

    @Override
    public double cost() {
        return beverage.cost() + 4; // 加珍珠需要 4 元
    }
}

//5.户端调用
public static void main(String[] args) {
        Beverage beverage = new GreenTea();
        // 开始装饰
        beverage = new Lemon(beverage); // 先加一份柠檬
        beverage = new Mango(beverage); // // 再加一份芒果
        System.out.println(beverage.getDescription() + " 价格：￥" + beverage.cost());
    }

输出：绿茶, 加柠檬, 加芒果 价格：￥16.0

//如果我们需要: 芒果-珍珠-双份柠檬-红茶
Beverage beverage = new Mango(new Pearl(new Lemon(new Lemon(new BlackTea()))));

输出：红茶, 加柠檬, 加柠檬, 加珍珠, 加芒果 价格：￥21.0

• 如下图:

  
  image.png

• 下面，我们再来说说 java IO 中的装饰模式。看下图 InputStream 派生出来的部分类：

  
  image.png

我们知道 InputStream 代表了输入流，具体的输入来源可以是文件（FileInputStream）、管道（PipedInputStream）、数组（ByteArrayInputStream）等，这些就像前面奶茶的例子中的红茶、绿茶，属于基础输入流。
FilterInputStream 承接了装饰模式的关键节点，它的实现类是一系列装饰器，比如 BufferedInputStream代表用缓冲来装饰，也就使得输入流具有了缓冲的功能，LineNumberInputStream 代表用行号来装饰，在操作的时候就可以取得行号了，DataInputStream 的装饰，使得我们可以从输入流转换为 java 中的基本类型值。
当然，在 java IO 中，如果我们使用装饰器的话，就不太适合面向接口编程了，如：

InputStream inputStream = 
new LineNumberInputStream(new BufferedInputStream(new FileInputStream("")));

这样的结果是，InputStream 还是不具有读取行号的功能，因为读取行号的方法定义在 LineNumberInputStream 类中
我们应该像下面这样使用：

DataInputStream is = new DataInputStream(
                              new BufferedInputStream(
                                  new FileInputStream("")));

- 门面模式

门面模式（也叫外观模式，Facade Pattern）在许多源码中有使用，比如 slf4j 就可以理解为是门面模式的应用。这是一个简单的设计模式，我们直接上代码再说吧

//1.首先，我们定义一个接口
public interface Shape {
    public abstract void draw();
}

//2.定义几个实现类：
public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Circle::draw()");
    }
}

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Rectangle::draw()");
    }
}

• 1.常规使用方式
  以下是我们常写的代码，我们需要画圆就要先实例化圆，画长方形就需要先实例化一个长方形，然后再调用相应的 draw() 方法

//客户端调用
public static void main(String[] args) {
    // 画一个圆形
      Shape circle = new Circle();
      circle.draw();

      // 画一个长方形
      Shape rectangle = new Rectangle();
      rectangle.draw();
}

• 2.门面方式

// 我们先定义一个门面
public class ShapeMaker {
    private Shape circle;
    private Shape rectangle;

    public ShapeMaker() {
        circle = new Circle();
        rectangle = new Rectangle();
    }

    /**
     * 下面定义一堆方法，具体应该调用什么方法，由这个门面来决定
     */
    public void drawCircle(){
        circle.draw();
    }
    public void drawRectangle(){
        rectangle.draw();
    }
}

// 客户端调用
public static void main(String[] args) {
    ShapeMaker shapeMaker = new ShapeMaker();
    shapeMaker.drawCircle();
}

门面模式的优点显而易见，客户端不再需要关注实例化时应该使用哪个实现类，直接调用门面提供的方法就可以了，因为门面类提供的方法的方法名对于客户端来说已经很友好了

- 组合模式

组合模式用于表示具有层次结构的数据，使得我们对单个对象和组合对象的访问具有一致性。
直接看一个例子吧，每个员工都有姓名、部门、薪水这些属性，同时还有下属员工集合（虽然可能集合为空），而下属员工和自己的结构是一样的，也有姓名、部门这些属性，同时也有他们的下属员工集合

public class Employee {
   private String name;
   private String dept;
   private int salary;
   private List<Employee> subordinates; // 下属

   public Employee(String name,String dept, int sal) {
      this.name = name;
      this.dept = dept;
      this.salary = sal;
      subordinates = new ArrayList<Employee>();
   }

   public void add(Employee e) {
      subordinates.add(e);
   }

   public void remove(Employee e) {
      subordinates.remove(e);
   }

   public List<Employee> getSubordinates(){
     return subordinates;
   }

   public String toString(){
      return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary+" ]");
   }
}

通常，这种类需要定义 add(node)、remove(node)、getChildren() 这些方法。
这说的其实就是组合模式

- 享元模式

Flyweight 是轻量级的意思，享元分开来说就是 共享 元器件，也就是复用已经生成的对象，这种做法当然也就是轻量级的了。
复用对象最简单的方式是，用一个 HashMap 来存放每次新生成的对象。每次需要一个对象的时候，先到 HashMap 中看看有没有，如果没有，再生成新的对象，然后将这个对象放入 HashMap 中

总结：前面，我们说了代理模式、适配器模式、桥梁模式、装饰模式、门面模式、组合模式和享元模式。读者是否可以分别把这几个模式说清楚了呢？在说到这些模式的时候，心中是否有一个清晰的图或处理流程在脑海里呢？
代理模式是做方法增强的，适配器模式是把鸡包装成鸭这种用来适配接口的，桥梁模式做到了很好的解耦，装饰模式从名字上就看得出来，适合于装饰类或者说是增强类的场景，门面模式的优点是客户端不需要关心实例化过程，只要调用需要的方法即可，组合模式用于描述具有层次结构的数据，享元模式是为了在特定的场景中缓存已经创建的对象，用于提高性能

行为型模式

行为型模式关注的是各个类之间的相互作用，将职责划分清楚，使得我们的代码更加地清晰

- 1.策略模式

// 1.首先，先定义一个策略接口
public interface Strategy {
    public void draw(int radius, int x, int y);
}

//2.定义具体的几个策略
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 GreenPen implements Strategy{
    @Override
    public void draw(int radius, int x, int y) {
        System.out.println("用绿色笔画图，radius:" + radius + ", x:" + x + ", y:" + 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);
    }
}

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

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeDraw(int radius, int x, int y){
        strategy.draw(radius, x, y);
    }
}

    //4.客户端调用
    Context context = new Context(new BluePen());
    context.executeDraw(2,4,8);

输出: 用蓝色笔画图，radius:2, x:4, y:8

策略模式如下图：

image.png

策略模式与桥接模式对比

image.png
桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低，结构更复杂一些

- 2.观察者模式

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

//1.首先，需要定义主题，每个主题需要持有观察者列表的引用，用于在数据变更的时候通知各个观察者
public class Subject {
    private List<Observer> observerList = new ArrayList<>();

    private int state;
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
        // 数据已变更，通知观察者们
        notifyAllObservers();
    }

    // 注册观察者
    public void attach(Observer observer){
        observerList.add(observer);
    }

    // 通知观察者们
    public void notifyAllObservers(){
        for (Observer observer : observerList) {
            observer.update();
        }
    }
}

// 2.定义观察者接口
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 subject = new Subject();
        // 定义观察者
        new BinaryObserver(subject);
        new HexaObserver(subject);

        // 模拟数据变更，这个时候，观察者们的 update 方法将会被调用
        subject.setState(11);
    }
}

输出：
订阅的数据发生变化，新的数据处理为二进制值为：1011
订阅的数据发生变化，新的数据处理为十六进制值为：B

当然，jdk 也提供了相似的支持，具体的大家可以参考 java.util.Observable和java.util.Observer 这两个类。
实际生产过程中，观察者模式往往用消息中间件来实现，如果要实现单机观察者模式，笔者建议读者使用 Guava 中的 EventBus，它有同步实现也有异步实现，本文主要介绍设计模式，就不展开说了。
还有，即使是上面的这个代码，也会有很多变种，大家只要记住核心的部分，那就是一定有一个地方存放了所有的观察者，然后在事件发生的时候，遍历观察者，调用它们的回调函数

- 3.责任链模式

责任链，顾名思义，就是用来处理相关事务责任的一条执行链，执行链上有多个节点，每个节点都有机会（条件匹配）处理请求事务，如果某个节点处理完了就可以根据实际业务需求传递给下一个节点继续处理或者返回处理完毕

场景：现实中，请假的OA申请，请假天数如果是半天到1天，可能直接主管批准即可:

• 如果是1到3天的假期，需要部门经理批准；
• 如果是3天到30天，则需要总经理审批；
• 大于30天，正常不会批准。

为了实现上述场景，我们可以采用责任链设计模式

• 1.员工提交请求类：LeaveRequest。
• 2.抽象的请假责任处理类：AbstractLeaveHandler。
• 3.直接主管审批处理类：DirectLeaderLeaveHandler。
• 4.部门经理处理类：DeptManagerLeaveHandler。
• 5.总经理处理类： GManagerLeaveHandler

员工请求发起申请到抽象的责任处理类中，根据员工的请假天数，对应的处理类完成处理。
每一个责任处理类设置下面的节点。自身处理不了则传递给下一个节点处理

image.png

// 员工提交请求类
@Data
@Builder(toBuilder = true)
public class LeaveRequest {

    /**天数*/
    private int leaveDays;

    /**姓名*/
    private String name;
}

// 抽象的请假责任处理类
public abstract class AbstractLeaveHandler {
    /**直接主管审批处理的请假天数*/
    protected int MIN = 1;

    /**部门经理处理的请假天数*/
    protected int MIDDLE = 3;

    /**总经理处理的请假天数*/
    protected int MAX = 30;

    /**领导名称*/
    protected String handlerName;

    /**下一个处理节点（即更高级别的领导）*/
    protected AbstractLeaveHandler nextHandler;

    /**设置下一节点*/
    public void setNextHandler(AbstractLeaveHandler handler){
        this.nextHandler = handler;
    }

    /**处理请假的请求，子类实现*/
    public abstract void handlerRequest(LeaveRequest request);
}

// 直接主管审批处理类
public class DirectLeaderLeaveHandler extends AbstractLeaveHandler{

    public DirectLeaderLeaveHandler(String name) {
        this.handlerName = name;
    }

    @Override
    public void handlerRequest(LeaveRequest request) {
        if(request.getLeaveDays() <= this.MIN){
            System.out.println("直接主管:" + handlerName + ",已经处理;流程结束。");
            return;
        }

        if(null != this.nextHandler){
            this.nextHandler.handlerRequest(request);
        }else{
            System.out.println("审批拒绝！");
        }
    }
}

// 部门经理处理类
public class DeptManagerLeaveHandler extends AbstractLeaveHandler{

    public DeptManagerLeaveHandler(String name) {
        this.handlerName = name;
    }


    @Override
    public void handlerRequest(LeaveRequest request) {
        if(request.getLeaveDays() > this.MIN && request.getLeaveDays() <= this.MIDDLE){
            System.out.println("部门经理:" + handlerName + ",已经处理;流程结束。");
            return;
        }

        if(null != this.nextHandler){
            this.nextHandler.handlerRequest(request);
        }else{
            System.out.println("审批拒绝！");
        }
    }
}

// 总经理处理类
public class GManagerLeaveHandler extends AbstractLeaveHandler{

    public GManagerLeaveHandler(String name) {
        this.handlerName = name;
    }

    @Override
    public void handlerRequest(LeaveRequest request) {
        if(request.getLeaveDays() > this.MIDDLE && request.getLeaveDays() <= this.MAX){
            System.out.println("总经理:" + handlerName + ",已经处理;流程结束。");
            return;
        }

        if(null != this.nextHandler){
            this.nextHandler.handlerRequest(request);
        }else{
            System.out.println("审批拒绝！");
        }
    }
}

// 客户端调用
    public static void main(String[] args) {
        LeaveRequest request = LeaveRequest.builder().leaveDays(1).name("wudy").build();
        DirectLeaderLeaveHandler directLeaderLeaveHandler = new DirectLeaderLeaveHandler("县令");
        DeptManagerLeaveHandler deptManagerLeaveHandler = new DeptManagerLeaveHandler("知府");
        GManagerLeaveHandler gManagerLeaveHandler = new GManagerLeaveHandler("京兆尹");

        directLeaderLeaveHandler.setNextHandler(deptManagerLeaveHandler);
        deptManagerLeaveHandler.setNextHandler(gManagerLeaveHandler);

        directLeaderLeaveHandler.handlerRequest(request);
    }

输出:直接主管:县令,已经处理;流程结束。

- 4.模板方法模式

在含有继承结构的代码中，模板方法模式是非常常用的。
通常会有一个抽象类:

public abstract class AbstractTemplate {
    // 这就是模板方法
    public void templateMethod() {
        init();
        apply(); // 这个是重点
        end(); // 可以作为钩子方法
    }

    protected void init() {
        System.out.println("init 抽象层已经实现，子类也可以选择覆写");
    }

    // 留给子类实现
    protected abstract void apply();

    protected void end() {
    }
}

模板方法中调用了 3 个方法，其中 apply() 是抽象方法，子类必须实现它，其实模板方法中有几个抽象方法完全是自由的，我们也可以将三个方法都设置为抽象方法，让子类来实现。也就是说，模板方法只负责定义第一步应该要做什么，第二步应该做什么，第三步应该做什么，至于怎么做，由子类来实现。
我们写一个实现类：

public class ConcreteTemplate extends AbstractTemplate{
    @Override
    protected void apply() {
        System.out.println("子类实现抽象方法 apply");
    }

    @Override
    protected void end() {
        System.out.println("我们可以把 method 当做钩子方法来使用，需要的时候覆写就可以了");
    }
}

// 客户端调用
    public static void main(String[] args) {
        AbstractTemplate template = new ConcreteTemplate();
        template.templateMethod();
    }

输出:
init 抽象层已经实现，子类也可以选择覆写
子类实现抽象方法 apply
我们可以把 method 当做钩子方法来使用，需要的时候覆写就可以了

- 5.状态模式

使用:代码中包含大量与对象状态有关的条件语句，将各种具体的状态类抽象出来，避免了过多的switch…case或if…else语句的使用。行为随状态改变而改变的场景，条件、分支判断语句的替代者。
案例：电梯，有运行状态、开门状态、闭门状态、停止状态等

//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 setContext(Context context) {
        super.setContext(context);
    }

    @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 setContext(Context context) {
        super.setContext(context);
    }

    @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.电梯停止状态:当电梯处于停止状态时，门是关闭着的，所以不能执行关门的方法；但此时是可以开门的；而停止后电梯也可以再度运行，所以存在run()方法

public class StoppingState extends LiftState{
    @Override
    public void setContext(Context context) {
        super.setContext(context);
    }

    @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("电梯停止了");
    }
}

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

public class RunningState extends LiftState{
    @Override
    public void setContext(Context context) {
        super.setContext(context);
    }

    @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();
    }
}

// 客户端调用
public static void main(String[] args) {
        Context context = new Context();

        //定义初始状态为关门（共四种初始值）
        context.setLiftState(new RunningState());
        context.open();
        context.close();
        context.run();
        context.stop();
    }

输出:
电梯运行中
电梯停止了