• 职责链模式简介

    概念：

    职责链模式是一种行为设计模式，它允许将请求沿着处理者链进行传递，直到有一个处理者能够处理该请求为止。每个处理者都可以选择将请求传递给下一个处理者或自行处理。

    特点：

    1. 解耦发送者和接收者：发送者不需要知道具体的接收者，只需将请求发送给第一个处理者即可。
    2. 动态组合：可以根据需要动态地组合和调整职责链中的各个节点。
    3. 灵活性：可以灵活地添加、修改或删除职责链上的节点。

    优点：

    1. 提高代码复用性：每个节点都只关心自己负责的部分，易于扩展和维护。
    2. 易于扩展新功能：通过增加新的节点来扩展功能而无需修改现有代码。
    3. 可以动态改变顺序和条件：可以根据实际情况动态调整节点之间的顺序或添加条件判断。

    缺点：

    1. 请求可能无法被正确处理：如果没有合适的节点能够处理某个请求，则该请求可能会被忽略。
    2. 性能开销较大：由于需要遍历整个职责链来找到合适的处理器，因此在大型职责链中可能会影响性能。

    适用场景：

    1. 有多个对象可以处理同一请求，但具体的处理者在运行时才能确定。
    2. 需要动态地指定可处理请求的对象集合。
    3. 在不明确接收者的情况下，将一个请求传递给多个对象中的一个或几个。

    实现方式：

    链表方式

    使用链表或数组来存储职责链节点，并在每个节点中定义一个方法来处理请求。每个节点都持有下一个节点的引用

    实现原理：

    1. 创建一个抽象的处理者类，其中包含一个指向下一处理者的引用。
    2. 派生具体的处理者类，并重写父类中的方法，在该方法中判断是否能够处理请求，如果可以则进行处理；否则将请求传递给下一位处理者。
    3. 在客户端代码中创建职责链并连接各个节点。

    实现代码:

    1. // 抽象处理者类
    2.  abstract class Handler {
    3.     protected Handler nextHandler;
    4.  
    5.     public void setNextHandler(Handler handler) {
    6.         this.nextHandler = handler;
    7.     }
    8.  
    9.     public abstract void handleRequest(Request request);
    10. }
    11.  
    12. // 具体处理者类A
    13. class ConcreteHandlerA extends Handler {
    14.     @Override
    15.     public void handleRequest(Request request) {
    16.         if (request.getType().equals("TypeA")) {
    17.             // 处理请求
    18.             System.out.println("ConcreteHandlerA处理了请求：" + request.getContent());
    19.         } else {
    20.             // 无法处理，传递给下一个处理者
    21.             if (nextHandler != null) {
    22.                 nextHandler.handleRequest(request);
    23.             } else {//已经遍历完了，表示没有节点能处理了
    24.                 System.out.println("无法处理该请求:" + request.getContent());
    25.             }
    26.         }
    27.     }
    28. }
    29.  
    30. // 具体处理者类B
    31. class ConcreteHandlerB extends Handler {
    32.     @Override
    33.     public void handleRequest(Request request) {
    34.         if (request.getType().equals("TypeB")) {
    35.             // 处理请求
    36.             System.out.println("ConcreteHandlerB处理了请求：" + request.getContent());
    37.         } else {
    38.             // 无法处理，传递给下一个处理者
    39.             if (nextHandler != null) {
    40.                 nextHandler.handleRequest(request);
    41.             } else {//已经遍历完了，表示没有节点能处理了
    42.                 System.out.println("无法处理该请求:" + request.getContent());
    43.             }
    44.         }
    45.     }
    46. }
    47.  
    48. // 请求类
    49. class Request {
    50.     private String type;
    51.     private String content;
    52.  
    53.     public Request(String type, String content) {
    54.         this.type = type;
    55.         this.content = content;
    56.     }
    57.  
    58.     public String getType() {
    59.         return type;
    60.     }
    61.  
    62.     public String getContent() {
    63.         return content;
    64.     }
    65. }
    66.  
    67.  
    68. public class Main {
    69.  
    70.     public static void main(String[] args) {
    71.         Handler handlerA = new ConcreteHandlerA();
    72.         Handler handlerB = new ConcreteHandlerB();
    73.  
    74.         handlerA.setNextHandler(handlerB);
    75.  
    76.         Request request1 = new Request("TypeA", "请求内容1");
    77.         handlerA.handleRequest(request1);  // 输出：ConcreteHandlerA处理了请求：请求内容1
    78.  
    79.         Request request2 = new Request("TypeB", "请求内容2");
    80.         handlerA.handleRequest(request2); // 输出：ConcreteHandlerB处理了请求：请求内容2
    81.  
    82.         Request request3 = new Request("TypeC", "请求内容3");
    83.         handlerA.handleRequest(request3);  // 输出：无法处理该请求
    84.  
    85.     }
    86. }

    在上述示例中，我们创建了两个具体的处理者类`ConcreteHandlerA`和`ConcreteHandlerB`，它们分别能够处理类型为"TypeA"和"TypeB"的请求。如果无法处理某个类型的请求，则将其传递给下一个处理者。

    客户端代码中创建了职责链，并将具体的处理者按照顺序连接起来。然后通过调用第一个节点（即`handlerA`）的`handleRequest()`方法来触发整个职责链的执行。在实际应用中，可以根据实际需求进行扩展和修改，例如添加新的具体处理者类或修改判断条件等。

    递归调用

    使用递归调用，在每个节点中判断是否需要继续传递请求给下一个节点

    实现原理

    使用递归调用可以实现请求沿着职责链依次传递的功能。当一个处理者无法处理请求时，它会将请求传递给下一个处理者，并继续调用下一个处理者的处理方法，直到找到能够处理该请求的处理者为止。

    实现代码

    1. abstract class Handler {
    2.     private Handler nextHandler;
    3.  
    4.     public void setNextHandler(Handler nextHandler) {
    5.         this.nextHandler = nextHandler;
    6.     }
    7.  
    8.     public void handleRequest(Request request) {
    9.         if (canHandle(request)) {
    10.             processRequest(request);
    11.         } else if (nextHandler != null) {
    12.             nextHandler.handleRequest(request);
    13.         } else {
    14.             System.out.println("无法处理该请求");
    15.         }
    16.     }
    17.  
    18.     protected abstract boolean canHandle(Request request);
    19.  
    20.     protected abstract void processRequest(Request request);
    21. }
    22.  
    23. class ConcreteHandlerA extends Handler {
    24.     @Override
    25.     protected boolean canHandle(Request request) {
    26.         return "TypeA".equals(request.getType());
    27.     }
    28.  
    29.     @Override
    30.     protected void processRequest(Request request) {
    31.         System.out.println("ConcreteHandlerA处理了请求：" + request.getContent());
    32.         // 具体处理逻辑...
    33.     }
    34. }
    35.  
    36. class ConcreteHandlerB extends Handler {
    37.     @Override
    38.     protected boolean canHandle(Request request) {
    39.         return "TypeB".equals(request.getType());
    40.     }
    41.  
    42.     @Override
    43.     protected void processRequest(Request request) {
    44.         System.out.println("ConcreteHandlerB处理了请求：" + request.getContent());
    45.         // 具体处理逻辑...
    46.     }
    47. }
    48.  
    49. class Request {
    50.     private String type;
    51.     private String content;
    52.  
    53.     public Request(String type, String content) {
    54.         this.type = type;
    55.         this.content = content;
    56.     }
    57.  
    58.     public String getType() {
    59.         return type;
    60.     }
    61.  
    62.     public String getContent() {
    63.         return content;
    64.     }
    65. }
    66.  
    67.  
    68. public class Main {
    69.  
    70.     public static void main(String[] args) {
    71.         Handler handlerA = new ConcreteHandlerA();
    72.         Handler handlerB = new ConcreteHandlerB();
    73.  
    74.         handlerA.setNextHandler(handlerB);
    75.  
    76.         Request request1 = new Request("TypeA", "请求内容1");
    77.         handlerA.handleRequest(request1);  // 输出：ConcreteHandlerA处理了请求：请求内容1
    78.  
    79.         Request request2 = new Request("TypeB", "请求内容2");
    80.         handlerA.handleRequest(request2);  // 输出：ConcreteHandlerB处理了请求：请求内容2
    81.  
    82.         Request request3 = new Request("TypeC", "请求内容3");
    83.         handlerA.handleRequest(request3);  // 输出：无法处理该请求
    84.     }
    85. }

    在上述示例中，我们创建了一个抽象处理者类Handler，实现了一个递归调用的处理方法，如果无法处理某个类型的请求，则将其递归传递给下一个处理者。然后创建了两个具体的处理者类ConcreteHandlerA和ConcreteHandlerB，它们分别能够处理类型为"TypeA"和"TypeB"的请求。

    客户端代码中创建了职责链，并将具体的处理者按照顺序连接起来。然后通过调用第一个节点（即handlerA）的handleRequest()方法来触发整个职责链的执行。

    在使用递归调用实现职责链模式时需要注意以下问题：

    1. 无限循环：如果职责链中存在循环引用或某个节点错误地将请求再次发送给自己，则可能导致无限循环。为了避免这种情况发生，我们需要在代码中添加合适的条件来控制结束递归。
    2. 性能影响：由于每个节点都会进行递归调用，可能导致性能方面的影响。特别是当职责链较长且层级较深时，可能会增加系统开销和延迟。

    注解方式

    使用注解方式来动态生成职责链，提高灵活性和可配置性。

    实现原理及代码

    首先，我们需要定义一个抽象处理者类Handler，它包含了设置下一个处理者的方法和处理请求的抽象方法。具体的处理者类将继承该抽象类并实现自己的业务逻辑。

    创建Handle.java

    1. public abstract class Handler {
    2.     private Handler nextHandler;
    3.  
    4.     public void setNextHandler(Handler nextHandler) {
    5.         this.nextHandler = nextHandler;
    6.     }
    7.  
    8.     public void handleRequest(Request request) {
    9.         if (canHandle(request)) {
    10.             process(request);
    11.         } else if (nextHandler != null) {
    12.             nextHandler.handleRequest(request);
    13.         } else {
    14.             System.out.println("无法护理该请求.");
    15.         }
    16.     }
    17.  
    18.     protected abstract boolean canHandle(Request request);
    19.  
    20.     protected abstract void process(Request request);
    21. }

    接下来，我们创建两个具体的处理者类ConcreteHandlerA和ConcreteHanderB。这里假设它们分别能够处理类型为"TypeA"和"TypeB"的请求。

    创建HandlerAnnotation.java

    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    5.  
    6. @Retention(RetentionPolicy.RUNTIME)
    7. @Target(ElementType.TYPE)
    8. public @interface HandlerAnnotation {
    9.     String type();
    10. }

    创建ConcreteHanlderA.java

    1. @HandlerAnnotation(type = "TypeA")
    2. public class ConcreteHanlderA extends Handler {
    3.  
    4.     @Override
    5.     protected boolean canHandle(Request request) {
    6.         return "TypeA".equals(request.getType());
    7.     }
    8.  
    9.     @Override
    10.     protected void process(Request request) {
    11.         // 处理 TypeA 类型请求的逻辑
    12.         System.out.println("ConcreteHandlerA 处理了请求");
    13.     }
    14. }

    创建ConcreteHanlderB.java

    1. @HandlerAnnotation(type = "TypeB")
    2. public class ConcreteHandlerB extends Handler {
    3.  
    4.     @Override
    5.     protected boolean canHandle(Request request) {
    6.         return "TypeB".equals(request.getType());
    7.     }
    8.  
    9.     @Override
    10.     protected void process(Request request) {
    11.         // 处理 TypeB 类型请求的逻辑
    12.         System.out.println("ConcreteHandlerB处理了请求");
    13.     }
    14. }

    在上述代码中，我们使用了HandlerAnnotation注解来标识具体处理者类能够处理的请求类型。

    接下来，我们创建一个简单的请求类Request，它包含一个类型属性和相应的getter方法。

    创建Request.java

    1. public class Request {
    2.     private String type;
    3.  
    4.     public Request(String type) {
    5.         this.type = type;
    6.     }
    7.  
    8.     public String getType() {
    9.         return type;
    10.     }
    11. }

    最后，在客户端代码中扫描并构建职责链，并触发整个职责链的执行。

    创建Main.java

    1. import java.lang.annotation.*;
    2. import java.util.ArrayList;
    3. import java.util.List;
    4. import java.io.File;
    5. import java.io.IOException;
    6. import java.net.URL;
    7. import java.util.ArrayList;
    8. import java.util.Enumeration;
    9. import java.util.List;
    10.  
    11.  
    12.  
    13.  
    14. public class Main {
    15.  
    16.     public static void main(String[] args) {
    17.         List handlers = new ArrayList<>();
    18.  
    19.         // 扫描具体处理者类上的注解信息，并创建处理者对象
    20.         for (Class clazz : getClasses()) {
    21.             Annotation annotation = clazz.getAnnotation(HandlerAnnotation.class);
    22.             if (annotation != null && Handler.class.isAssignableFrom(clazz)) {
    23.                 try {
    24.                     Handler handler = (Handler) clazz.getDeclaredConstructor().newInstance();
    25.                     handlers.add(handler);
    26.                 } catch (Exception e) {
    27.                     e.printStackTrace();
    28.                 }
    29.             }
    30.         }
    31.  
    32.         // 按照顺序连接处理者对象形成职责链
    33.         int size = handlers.size();
    34.         for (int i = 0; i < size - 1; i++) {
    35.             handlers.get(i).setNextHandler(handlers.get(i + 1));
    36.         }
    37.  
    38.         // 使用第一个节点（即handlers.get(0)）来触发整个职责链的执行
    39.         Request requestA = new Request("TypeA");
    40.         handlers.get(0).handleRequest(requestA);
    41.  
    42.         Request requestB = new Request("TypeB");
    43.         handlers.get(0).handleRequest(requestB);
    44.  
    45.         Request requestC = new Request("TypeC");
    46.         handlers.get(0).handleRequest(requestC);
    47.     }
    48.  
    49.     private static List> getClasses() {
    50.         // 在这里返回具体处理者类所在的包路径下的所有类，或通过其他方式获取需要扫描的具体处理者类
    51.         List> classes = new ArrayList<>();
    52.         String packageName = "com.example.posttest"; // 替换为具体处理者类所在的包路径
    53.  
    54.         try {
    55.             ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    56.             String path = packageName.replace('.', '/');
    57.             Enumeration resources = classLoader.getResources(path);
    58.  
    59.             while (resources.hasMoreElements()) {
    60.                 URL resource = resources.nextElement();
    61.                 File file = new File(resource.getFile());
    62.  
    63.                 if (file.isDirectory()) {
    64.                     for (File f : file.listFiles()) {
    65.                         if (f.isFile() && f.getName().endsWith(".class")) {
    66.                             String className = packageName + '.' + f.getName().substring(0, f.getName().length() - 6);
    67.                             Class clazz = Class.forName(className);
    68.                             classes.add(clazz);
    69.                         }
    70.                     }
    71.                 }
    72.             }
    73.         } catch (IOException | ClassNotFoundException e) {
    74.             e.printStackTrace();
    75.         }
    76.  
    77.         return classes;
    78.     }
    79. }

    在上述示例中，我们为每个具体处理者类添加了HandlerAnnotation注解，该注解标识了处理者所能处理的请求类型以及其在职责链中的位置。然后在客户端代码中扫描具体处理者类上的注解信息，并根据order值排序构建职责链。

  • 相关阅读:
    零基础学python之列表
    python常用进制转换
    存储型XSS和BEEF浏览器攻击框架
    网络与信息安全基础知识-- Internet及应用
    含文档+PPT+源码等]精品基于Uniapp实现的鲜花商城App[包运行成功]
    生产制造业ERP管理系统能解决哪些问题？
    U-Boot初始化及工作流程分析
    并网型虚拟同步发电机控制仿真（Matlab&simulink仿真实现)
    Linux-网络工具MTR
    7.3 调用函数
  • 原文地址：https://blog.csdn.net/aidscooler/article/details/132896942