• 责任链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求组的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

  • 代码：

  1. //定义一个base处理者
  2. public abstract class Handler {
  3.     protected Handler handler;
  5.     public void setHandler(Handler handler) {
  6.         this.handler = handler;
  7.     }
  9.     public abstract void handleRequest();
  10. }
  12. //定义处理者1
  13. public class FirstHandler extends Handler {
  14.     @Override
  15.     public void handleRequest() {
  16.         if (true) {
  17.             doSomething();
  18.         } else if (Objects.nonNull(handler)) {
  19.             handler.handleRequest();
  20.         }
  21.     }
  22. }
  24. //定义处理者2
  25. public class SecondHandler extends Handler {
  26.     @Override
  27.     public void handleRequest() {
  28.         if (true) {
  29.             doSomething();
  30.         } else if (Objects.nonNull(handler)) {
  31.             handler.handleRequest();
  32.         }
  33.     }
  34. }
  36. //定义处理者3
  37. public class ThirdHandler extends Handler {
  38.     @Override
  39.     public void handleRequest() {
  40.         if (true) {
  41.             doSomething();
  42.         } else if (Objects.nonNull(handler)) {
  43.             handler.handleRequest();
  44.         }
  45.     }
  46. }
  48. //入口处理方法
  49. public void method(){
  50.     //定义责任链条
  51.     Handler firstHandler = new FirstHandler();
  52.     Handler secondHandler = new SecondHandler();
  53.     Handler thirdHandler = new ThirdHandler();
  54.     firstHandler.setHandler(secondHandler);
  55.     secondHandler.setHandler(thirdHandler);
  56.     
  57.     //传递任务
  58.     firstHandler.handleRequest();
  59. }
  • 通过上述代码，可以看出，定义了责任链条之后，那么就会给满足条件的handler处理请求。

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