015行为型-职责链模式

定义

责链模式是一种设计模式，其目的是使多个对象能够处理同一请求，但是并不知道下一个处理请求的对象是谁。它能够解耦请求的发送者和接收者之间的直接耦合关系。
举个例子，假设你的公司有一个报销流程，需要依次提交给主管、经理和财务部门审核，如果一个人无法审核，那么就需要向下一个人提交审核请求。在这种情况下，职责链模式非常适用。
在职责链模式中，每个处理请求的对象都可以尝试处理请求，如果自己无法处理，则将请求传递给下一个对象，直到有一个对象能够处理请求为止。
职责链模式由以下几个部分组成：

1. 抽象处理者（Handler）：定义一个处理请求的接口，并将请求传递给下一个处理者。
2. 具体处理者（ConcreteHandler）：实现处理请求的接口，并负责处理请求或者将请求传递给下一个处理者。
3. 客户端（Client）：创建处理者对象，并将请求发送给处理者。

通过这种方式，我们可以将处理请求的对象连接成一条链，让每个对象都有机会处理请求，同时又不会知道下一个对象是谁。

标准模式实现：

如果处理器链上的某个处理器能够处理这个请求，那就不会继续往下传递请求。

这段代码是一个使用职责链模式的示例，主要包含以下几个类：

1. 抽象处理器类 Handler ：定义了一个处理器对象的公共接口，并且持有下一个处理器的引用。具体的处理器需要继承自该类并实现其 doHandle() 方法，用于实现处理逻辑。
2. 具体处理器类 HandlerA 和 HandlerB ：继承自 Handler 类，实现了 doHandle() 方法，并且在该方法中输出自己的类名。
3. 处理器链类 HandlerChain ：用于维护处理器链，实现了 addHandler() 方法用于添加处理器，实现了 handle() 方法用于处理请求。
4. 测试类 HandlerTest ：创建了一个处理器链并添加了两个处理器，然后调用 handle() 方法处理请求。

具体的实现过程如下：

1. 在抽象处理器类 Handler 中定义了一个 handle() 方法，其中先调用 doHandle() 方法来执行实际的处理逻辑，如果返回值为 false，则表示当前处理器不能处理该请求，需要将请求传递给下一个处理器。这里使用了模板方法设计模式。
2. 在具体处理器类 HandlerA 和 HandlerB 中分别实现了 doHandle() 方法，输出自己的类名，并且将返回值设置为 false。
3. 在处理器链类 HandlerChain 中，定义了一个头部处理器和尾部处理器，以及 addHandler() 方法用于添加处理器。当添加第一个处理器时，同时将头部和尾部处理器设置为该处理器；当添加多个处理器时，将新的处理器设置为尾部处理器的下一个处理器，并将尾部处理器设置为新的处理器。在 handle() 方法中，调用头部处理器的 handle() 方法，从而开始处理请求。
4. 在测试类 HandlerTest 中，创建了一个处理器链，并添加了 HandlerA 和 HandlerB 处理器。然后调用 handle() 方法处理请求，从而开始执行处理逻辑。在执行过程中，处理器链会将请求传递给每个处理器，直到找到能够处理该请求的处理器为止。在本例中，由于处理器只输出自己的类名，因此实际上并没有进行实际的处理逻辑。

public abstract class Handler {protected Handler successor = null;public void setSuccessor(Handler successor) {this.successor = successor;}/**
* 利用模版方法，抽离公共的逻辑
*/public final void handle() {boolean handled = doHandle();if (successor != null && !handled) {successor.handle();}}/**
* 此处子类实现，填充需要处理的逻辑
* 如果处理器链上的某个处理器能够处理这个请求，那就不会继续往下传递请求
*
* @return
*/protected abstract boolean doHandle();
}public class HandlerA extends Handler {@Overrideprotected boolean doHandle() {boolean handled = false;System.out.println("我是" + this.getClass().getSimpleName());return handled;}
}public class HandlerB extends Handler {@Overrideprotected boolean doHandle() {boolean handled = false;System.out.println("我是" + this.getClass().getSimpleName());return handled;}
}public class HandlerChain {private Handler head = null;private Handler tail = null;public void addHandler(Handler handler) {//将传入的节点下一步设置为nullhandler.setSuccessor(null);if (head == null) {head = handler;tail = handler;return;}//尾部增加节点tail.setSuccessor(handler);tail = handler;}public void handle(){if (head != null) {head.handle();}}
}public class HandlerTest {public static void main(String[] args) {HandlerChain chain = new HandlerChain();chain.addHandler(new HandlerA());chain.addHandler(new HandlerB());chain.handle();}
}

职责链变体

请求会被所有的处理器都处理一遍，不存在中途终止的情况。这种变体也有两种实现方式：用链表存储处理器和用数组存储处理器

使用链表实现

public abstract class Handler {protected Handler successor = null;public void setSuccessor(Handler successor) {this.successor = successor;}public final void handle() {doHandle();if (successor != null) {successor.handle();}}protected abstract void doHandle();
}public class HandlerA extends Handler {@Overrideprotected void doHandle() {System.out.println("我是" + this.getClass().getSimpleName());}
}public class HandlerB extends Handler {@Overrideprotected void doHandle() {System.out.println("我是" + this.getClass().getSimpleName());}
}public class HandlerChain {private Handler head = null;private Handler tail = null;public void addHandler(Handler handler) {handler.setSuccessor(null);if (head == null) {head = handler;tail = handler;return;}tail.setSuccessor(handler);tail = handler;}public void handle() {if (head != null) {head.handle();}}
}// 使用举例
public class Application {public static void main(String[] args) {HandlerChain chain = new HandlerChain();chain.addHandler(new HandlerA());chain.addHandler(new HandlerB());chain.handle();}
}

这段代码和上面的代码实现的是相同的职责链模式，只是实现的方式略有不同。具体区别如下：

1. 上面的代码中，抽象处理器 Handler 类的 doHandle() 方法返回 boolean 类型，表示是否处理了请求，而这里的代码中，抽象处理器 Handler 类的 doHandle() 方法返回 void 类型，表示无论是否处理请求，都会执行该方法。
2. 在上面的代码中，处理器链中的处理器如果处理了请求，则不会继续往后传递请求；而在这里的代码中，处理器链中的处理器不管是否处理了请求，都会把请求继续传递给下一个处理器。

总的来说，这两段代码的区别并不大，都是实现职责链模式的有效方式，具体的实现方式可以根据实际情况进行选择。

使用数组实现

public class HandlerChain {private final List<Handler> handlers = new ArrayList<>();public void addHandler(Handler handler) {handlers.add(handler);}public void handle() {for (Handler handler : handlers) {handler.handle();}}
}

这个改进方案的主要变化如下：

1. 将处理器链的存储方式从链表改为了数组，这样可以更加高效地遍历所有处理器。
2. 去掉了 tail 指针，因为数组可以直接按照添加的顺序来遍历，不需要链表的指针。
3. 在 handle() 方法中，直接使用 for 循环来遍历所有处理器，不需要链表中的递归调用。

这种改进方案的优点是代码更加简洁易懂，效率也更高。但是需要注意的是，这种方式只适用于处理器数量不太多的情况，如果处理器数量很大，那么这种方式的效率可能会受到影响，因为数组的大小是固定的，如果处理器数量很大，可能会导致数组空间的浪费。

应用场景

日志输出

当然，这里是一个类似于日志记录框架的职责链模式的例子。假设我们有一个需求，需要在应用程序中使用多个记录器，例如控制台记录器、文件记录器和电子邮件记录器，将日志信息记录在不同的位置，那么我们可以使用职责链模式来实现这个功能。

// Interface for all loggers in the chain
public interface Logger {void log(String message);
}// Logger implementation that writes to console
public class ConsoleLogger implements Logger {@Overridepublic void log(String message) {System.out.println("Console Logger: " + message);}
}// Logger implementation that writes to a file
public class FileLogger implements Logger {@Overridepublic void log(String message) {System.out.println("File Logger: " + message);}
}// Logger implementation that sends an email
public class EmailLogger implements Logger {@Overridepublic void log(String message) {System.out.println("Email Logger: " + message);}
}// The chain that contains all loggers
public class LoggerChain {private List<Logger> loggers = new ArrayList<>();public void addLogger(Logger logger) {this.loggers.add(logger);}public void log(String message) {for (Logger logger : loggers) {logger.log(message);}}
}// Usage example
public class ApplicationDemo {public static void main(String[] args) {LoggerChain loggerChain = new LoggerChain();loggerChain.addLogger(new ConsoleLogger());loggerChain.addLogger(new FileLogger());loggerChain.addLogger(new EmailLogger());loggerChain.log("This is a log message.");}
}

spring过滤器

Spring Boot Servlet 过滤器（Filter）：在 Web 应用程序中，可以使用过滤器来对请求进行处理。Spring Boot Servlet 过滤器使用职责链模式来实现多个过滤器的链式调用。在请求处理过程中，过滤器链中的每个过滤器都可以对请求进行处理和修改，过滤器链主要用于拦截 HTTP 请求，并在请求到达处理器之前对其进行预处理，以实现一些共性的处理逻辑，例如权限校验、日志记录、字符编码转换等。

public class CharacterEncodingFilter implements Filter {private String encoding;@Overridepublic void init(FilterConfig filterConfig) throws ServletException {encoding = filterConfig.getInitParameter("encoding");}@Overridepublic void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {request.setCharacterEncoding(encoding);chain.doFilter(request, response);}@Overridepublic void destroy() {// do nothing}
}

该过滤器的作用是将 HTTP 请求的字符编码设置为指定的编码。它实现了 Filter 接口，并重写了init、doFilter和destroy方法。在doFilter方法中，该过滤器首先将请求的字符编码设置为指定的编码，然后调用 FilterChain 的 doFilter 方法，将请求转发给下一个过滤器。

@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}@Beanpublic FilterRegistrationBean<CharacterEncodingFilter> characterEncodingFilterRegistrationBean() {FilterRegistrationBean<CharacterEncodingFilter> registrationBean = new FilterRegistrationBean<>();registrationBean.setFilter(new CharacterEncodingFilter());registrationBean.addUrlPatterns("/*");registrationBean.addInitParameter("encoding", "UTF-8");registrationBean.setName("characterEncodingFilter");registrationBean.setOrder(1);return registrationBean;}
}

在上面的代码中，我们使用了**@Bean注解来声明一个名为characterEncodingFilterRegistrationBean的 Bean。这个 Bean 是一个FilterRegistrationBean**类型的对象，它用于将 CharacterEncodingFilter 过滤器注册到应用程序中。

在characterEncodingFilterRegistrationBean方法中，

• 我们首先创建一个FilterRegistrationBean对象，并将 CharacterEncodingFilter 过滤器实例作为参数传入。
• 然后，我们使用addUrlPatterns方法来指定该过滤器所拦截的 URL 模式。在本例中，我们将其设置为拦截所有请求。
• 接下来，我们使用addInitParameter方法来设置过滤器的初始化参数。
• 最后，我们使用setName方法来指定该过滤器的名称，使用setOrder方法来指定该过滤器在过滤器链中的顺序。

通过以上的配置，我们就成功地将 CharacterEncodingFilter 过滤器注册到了应用程序中，并将其加入到了过滤器链中。当 HTTP 请求到达应用程序时，Spring Boot 将会按照过滤器链的顺序，依次将请求转发给下一个过滤器，直到请求到达处理器。

spirng 拦截器

Spring MVC 拦截器（HandlerInterceptor）：在 Spring MVC 中，可以使用拦截器来拦截请求并在处理请求之前或之后执行一些操作。Spring MVC 拦截器使用职责链模式来实现多个拦截器的链式调用。在请求处理过程中，拦截器链中的每个拦截器都可以对请求进行处理和修改。

public class SecurityInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 检查用户的权限if (!hasPermission(request)) {// 如果没有权限，返回错误信息response.sendError(HttpServletResponse.SC_FORBIDDEN, "Forbidden");return false;}return true;}private boolean hasPermission(HttpServletRequest request) {// 检查用户是否具有执行该请求的权限// ...return true;}
}public class LogInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 记录请求日志logRequest(request);return true;}private void logRequest(HttpServletRequest request) {// 记录请求日志// ...}
}public class InterceptorChainConfigurer implements WebMvcConfigurer {@Autowiredprivate SecurityInterceptor securityInterceptor;@Autowiredprivate LogInterceptor logInterceptor;@Overridepublic void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(securityInterceptor);registry.addInterceptor(logInterceptor);}
}

拦截器和过滤器的实现机制中都使用了职责链模式。
在 Spring MVC 中，拦截器是通过 HandlerInterceptor 接口实现的，它的实现类可以在 Spring MVC 的配置文件中配置，并按照顺序组成一个拦截器链。在请求处理过程中，拦截器链中的每个拦截器都可以对请求进行处理和修改，形成一个职责链。
同样，在 Servlet 中，过滤器也是使用职责链模式实现的。在 web.xml 中配置的过滤器会按照顺序形成一个过滤器链，每个过滤器都可以对请求进行处理和修改，形成一个职责链。
因此，拦截器和过滤器的实现机制都借鉴了职责链模式的思想，通过将多个拦截器或过滤器组合成一个链条，实现对请求进行处理和拦截的目的。

在 Spring MVC 中，拦截器和过滤器都是用于对请求进行处理和拦截的组件，但是它们有一些区别：

1. 拦截器是 Spring MVC 框架提供的组件，而过滤器是 Servlet 规范提供的组件。因此，使用拦截器需要在 Spring MVC 的配置文件中配置拦截器，而使用过滤器需要在 web.xml 中配置过滤器。
2. 拦截器只能拦截请求，并且只能在请求被分派到具体的处理器（Controller）之前或之后进行处理，它不能修改请求的内容。而过滤器可以拦截请求和响应，它能够修改请求和响应的内容。
3. 拦截器可以访问 Spring MVC 的上下文（如请求和响应对象、处理器对象等），并可以调用处理器方法。而过滤器只能访问 Servlet 的上下文（如请求和响应对象），它不能调用处理器方法。
4. 拦截器是基于 AOP 实现的，可以使用 AOP 的特性（如切面、通知等），因此它具有更高的灵活性和可扩展性。而过滤器只能使用 Servlet 规范中定义的特性，它的灵活性和可扩展性相对较低。

mybatis动态sql

MyBatis 使用 SQLNode 接口来表示 SQL 语句的不同部分，例如 WHERE 子句、SET 子句等等。每个 SQLNode 对象都包含一个 SQLNode 的集合，这些集合可以被视为一个责任链。在处理 SQL 语句时，MyBatis 会按照一定的顺序遍历这个责任链，让每个 SQLNode 对象对 SQL 语句进行处理。这样，MyBatis 就能够灵活地生成各种不同的 SQL 语句，而不需要编写大量的重复代码。
例如，当我们执行一个带有条件查询的 SQL 语句时，MyBatis 会生成一个带有 WHERE 子句的 SQL 语句。在生成这个 SQL 语句的过程中，MyBatis 会依次遍历责任链中的每个 SQLNode 对象，并将它们的结果拼接成最终的 SQL 语句。如果某个 SQLNode 对象无法处理当前的 SQL 语句部分，它会将处理权交给下一个 SQLNode 对象，直到整个责任链被遍历完为止。

public interface SQLNode {String process(String sql);
}public class WhereNode implements SQLNode {private SQLNode next;public WhereNode(SQLNode next) {this.next = next;}@Overridepublic String process(String sql) {String where = "WHERE ";if (next != null) {where += next.process(sql);}return where;}
}public class OrderByNode implements SQLNode {private SQLNode next;public OrderByNode(SQLNode next) {this.next = next;}@Overridepublic String process(String sql) {String orderBy = "ORDER BY id";if (next != null) {orderBy += next.process(sql);}return orderBy;}
}public class SelectNode implements SQLNode {private SQLNode next;public SelectNode(SQLNode next) {this.next = next;}@Overridepublic String process(String sql) {String select = "SELECT * FROM table";if (next != null) {select += next.process(sql);}return select;}
}// 构建责任链
SQLNode whereNode = new WhereNode(null);
SQLNode orderByNode = new OrderByNode(whereNode);
SQLNode selectNode = new SelectNode(orderByNode);// 生成 SQL 语句
String sql = selectNode.process(null);
System.out.println(sql);

在这个示例中，我们定义了三个 SQLNode 类，分别对应 SQL 语句中的 WHERE 子句、ORDER BY 子句和 SELECT 语句。每个 SQLNode 对象都包含一个 next 属性，用于指向责任链中的下一个 SQLNode 对象。
我们首先创建了 WhereNode 对象，然后创建了 OrderByNode 和 SelectNode 对象，并将它们与 WhereNode 对象连接起来，形成了一个责任链。最后，我们通过调用 selectNode.process(null) 方法来生成 SQL 语句，这样 MyBatis 就会按照责任链的顺序遍历各个 SQLNode 对象，并将它们的处理结果拼接成最终的 SQL 语句。