使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连城一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

 

一个抽象的处理者
若干个具体处理者（每个具体处理者都不知道它的继任者是谁，这个继任者由客户端决定，只负责把处理不了的请求转发给继任者）
工作流基本都可以用这个模式来设计。
我就来写个生产酱板鸭的流水线好了。
屠宰-》清洗-》卤制-》风干-》包装
简化一点，懒得写那么多类
清洗-》卤制-》包装

 鸭子类：

  1. package designpattern.chainofresponsibility;
  3. public class Duck {
  4.     public State state;
  6.     Duck(State state) {
  7.         this.state = state;
  8.     }
  10.     public enum State {
  11.         DIRTY, CLEAN, COOKED, PACKAGED
  12.     }
  14.     public State getState() {
  15.         return state;
  16.     }
  18.     public void setState(State state) {
  19.         this.state = state;
  20.     }
  22. }

抽象处理者类：

  1. package designpattern.chainofresponsibility;
  3. public abstract class Handler {
  4.     protected Handler successor;
  6.     public void setSuccessor(Handler successor) {
  7.         this.successor = successor;
  8.     }
  10.     public abstract void handleDuck(Duck duck);
  11. }

清洗者类（具体处理者）：

  1. package designpattern.chainofresponsibility;
  3. import designpattern.chainofresponsibility.Duck.State;
  5. public class DuckCleaner extends Handler {
  7.     @Override
  8.     public void handleDuck(Duck duck) {
  9.         if (duck.state == State.DIRTY) {
  10.             System.out.println("清洗员-》清理鸭子~");
  11.             duck.setState(State.CLEAN);
  12.         } else {
  13.             successor.handleDuck(duck);
  14.         }
  15.     }
  17. }

厨师类（具体处理者）：

  1. package designpattern.chainofresponsibility;
  3. import designpattern.chainofresponsibility.Duck.State;
  5. public class DuckCook extends Handler {
  6.     @Override
  7.     public void handleDuck(Duck duck) {
  8.         if (duck.state == State.CLEAN) {
  9.             System.out.println("厨师-》卤制鸭子~");
  10.             duck.setState(State.COOKED);
  11.         } else {
  12.             successor.handleDuck(duck);
  13.         }
  14.     }
  15. }

打包者类（具体处理者）：

  1. package designpattern.chainofresponsibility;
  3. import designpattern.chainofresponsibility.Duck.State;
  5. public class DuckPackager extends Handler {
  6.     @Override
  7.     public void handleDuck(Duck duck) {
  8.         if (duck.state == State.COOKED) {
  9.             System.out.println("打包员-》包装鸭子~");
  10.             duck.setState(State.PACKAGED);
  11.         }
  12.     }
  13. }

客户端：

  1. package designpattern.chainofresponsibility;
  3. import designpattern.chainofresponsibility.Duck.State;
  5. public class Client {
  6.     public static void main(String[] args) {
  7.         DuckCleaner duckCleaner = new DuckCleaner();
  8.         DuckCook duckCook = new DuckCook();
  9.         DuckPackager duckPackager = new DuckPackager();
  10.         duckCleaner.setSuccessor(duckCook);
  11.         duckCook.setSuccessor(duckPackager);
  13.         // 处理脏鸭子
  14.         Duck duck = new Duck(State.DIRTY);
  15.         duckCleaner.handleDuck(duck);
  16.         // 处理卤好的鸭子
  17.         duck.setState(State.COOKED);
  18.         duckCleaner.handleDuck(duck);
  19.     }
  20. }

结果输出：

  1. 清洗员-》清理鸭子~
  2. 打包员-》包装鸭子~
不管鸭子在哪个状态，统统传给清理者，他处理不了，会一路传下去，直到正确的人来处理。
这个模式算是一个结构比较简单的，也很好理解，只不过之前自己想的时候完全没有想出来可以用这样的方式来实现。
又能把请求传递下去又能让处理者之间，以及处理者和客户端之间解耦，真的很巧妙。
不过像上面说的，继任者是由客户端决定的，但实际上具体处理者之间有潜在的逻辑关系，如果客户端没有正确的设置链条可能会导致请求得不到处理。
比如上面的例子，直接拿洗好的鸭子去包装显然是包装不了的。
所以需要把文档写得足够清晰，以供客户端正确使用。

 

版权声明：本文为imoqian原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/imoqian/p/13907502.html