设计模式(三) chain of responsibility ——责任链模式

在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

应用实例

1. JAVA WEB 中 Apache Tomcat 对 Encoding 的处理
2. Struts2 的拦截器
3. jsp servlet 的 Filter。

优点

1. 降低耦合度。它将请求的发送者和接收者解耦。
2. 简化了对象。使得对象不需要知道链的结构。
3. 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4. 增加新的请求处理类很方便。

缺点

1. 不能保证请求一定被接收。
2. 系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3. 可能不容易观察运行时的特征，有碍于除错。

使用场景

1. 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
2. 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3. 可动态指定一组对象处理请求。

示例——模拟Servlet中的Filter

package com.liqk.dp.chain;

import java.util.ArrayList;
import java.util.List;

/**
 * 责任链模式
 * Java中的Filter用的就是chain of responsibility模式
 * 基本上过滤器和拦截器都是用的责任链模式
 *
 * 手写Filter的处理过程
 *
 * 需求：一个请求发送至过滤链  之后过滤链会按照指定的过滤顺序依次执行过滤内容 直到最后一个过滤器完成后
 * 再逆序处理响应内容
 *
 * 角色：
 * Filter接口 (核心:定义责任链中的任务接口)
 * FilterChain (核心：控制责任链传递)
 * 模拟Request
 * 模拟Response
 * 以及具体的过滤类
 */
public class ChainOfResponsibility {

    public static void main(String[] args) {

        Request req = new Request();
        req.setStr("你好，这里是测试语句 <script> This is Test 金钱豹...");
        Response resp = new Response();
        resp.setStr("response:");

        FilterChain chian = new FilterChain();
        chian.add(new HtmlFilter()).add(new SensitiveFilter());
        chian.doFilter(req,resp);

        System.out.println(req);
        System.out.println(resp);
    }

}

/**自定义请求对象*/
class Request{
    private String str;//模拟请求内容

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Request{" +
                "str='" + str + '\'' +
                '}';
    }
}

/**自定义响应对象*/
class Response{
    private String str;//模拟响应内容

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Response{" +
                "str='" + str + '\'' +
                '}';
    }
}

/**过滤器接口 所有过滤操作 全部实现该接口*/
interface Filter{
   void doFilter(Request req,Response rep,FilterChain chain);
}

/**过滤链 用来处理过滤的执行顺序*/
class FilterChain {
    //用来存储所有的过滤器集合
    private List<Filter> flist = new ArrayList<>();
    //用来记录当前执行到的顺序
    int index =0;

    public FilterChain add(Filter filter){
        flist.add(filter);
        return this;
    }


    /**
     * 利用递归来处理请求过滤和响应过滤
     * @param req  待处理的请求参数
     * @param resp  待处理的响应参数
     */
    public void doFilter(Request req, Response resp) {
        //递归出口 -- 当index 抵达过滤器集合的最后一个时 跳出
        if(index == flist.size()) return ;
        Filter f = flist.get(index);
        index++;//执行顺序+1 用来调用下一个过滤器 也是递归的出口变量
        f.doFilter(req,resp,this);
    }
}

/**
 * 定义实际过滤器 -- 处理内容中的非法字符
 * 此处将 <script> 中的 <> 替换成 []
 */
class HtmlFilter implements  Filter{

    @Override
    public void doFilter(Request req, Response resp, FilterChain chain) {
        String s = req.getStr().replaceAll("<","[").replaceAll(">","]");
        req.setStr(s);
        chain.doFilter(req,resp);//调用过滤链 向后执行
        resp.setStr(resp.getStr()+"=---HtmlFilter");
    }
}

/**
 * 定义实际过滤器 -- 替换内容中的敏感字符
 * 此处将"金钱" 处理成"***"
 */
class SensitiveFilter implements Filter{

    @Override
    public void doFilter(Request req, Response resp, FilterChain chain) {
        req.setStr(req.getStr().replaceAll("金钱","***"));
        chain.doFilter(req,resp);
        resp.setStr(resp.getStr()+"--SensitiveFilter");
    }
}

输出结果

Request{str='你好，这里是测试语句 [script] This is Test ***豹...'}
Response{str='response:--SensitiveFilter=---HtmlFilter'}