设计模式七：责任链模式-CFANZ编程社区

文章目录

1、责任链模式

责任链模式为请求创建了一个接收者对象的链，在这种模式下，通常每个节点都包含对另一个节点者的引用。每个节点针对请求，处理自己感兴趣的内容，处理完之后可以结束，也可以向下一个节点传递继续处理；

角色：

抽象处理者角色：处理请求的抽象类，定义了处理请求的抽象方法；(抽象类或接口实现)；
具体处理者角色：处理请求的具体实现类；(持有下家对象的引用)；

例：请假流程都是先由本部门审核，根据时间长短再进行下一级审批

在这里插入图片描述

//抽象类
public abstract class Handler {
    /**
     * 请假天数
     */
    public int maxday;
    /**
     * 请假人
     */
    public String name;

    public Handler(String name, int maxday) {
        this.maxday = maxday;
        this.name = name;
    }

    private Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    /**
     * 处理请假：判断请假天数，超过本部门限定时间则交由上一级部门
     */

    public final void handlingFakeSlips(int day) {
        if (this.maxday >= day) {
            this.agree(day);
        }
        else {
            if (nextHandler != null) {
                System.out.println(name+":天数已超过我的审批权限，已提交我的上级审批");
                nextHandler.handlingFakeSlips(day);
            }
            else {
                System.out.println("天数时间过长，准备辞职吧！！！");
            }
        }
    }

    /**
     * 审批动作：子类来实现
     * @param day
     */
    abstract void agree(int day);
}

//部门实现类
public class RDDepartment extends Handler{
    public RDDepartment(String name, int maxday) {
        super(name, maxday);
    }
    @Override
    void agree(int maxday) {
        System.out.println(name + "：研发部门请假审批通过，请假天数：" + maxday);
    }
}

//主管实现类
public class Supervisor extends Handler{
    public Supervisor(String name, int maxday) {
        super(name, maxday);
    }
    @Override
    void agree(int maxday) {
        System.out.println(name + "：主管请假审批通过，请假天数：" + maxday);
    }
}

//董事实现类
public class Director extends Handler{
    public Director(String name, int maxday) {
        super(name, maxday);
    }
    @Override
    void agree(int maxday) {
        System.out.println(name + "：请假董事审批通过，请假天数：" + maxday);
    }
}

//组装链
public class HandlerChain {
    private Handler head;
    private Handler tail;
    public HandlerContext(){
        RDDepartment rdDepartment = new RDDepartment("研发部门",5);
        Supervisor supervisor = new Supervisor("项目主管",30);
        Director director = new Director("董事",180);

        rdDepartment.setNextHandler(supervisor);
        supervisor.setNextHandler(director);

        head = rdDepartment;
        tail = director;
    }
    public void doHandler(Integer days){
        head.handlingFakeSlips(days);
    }
}


//请求
public class Request {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        handlerChain.doHandler(360);
    }
}

2、spring中的责任链模式

Spring Interceptor

回顾springmvc处理请求的流程：DispatcherServlet接收到请求后，执行doDispatcher()方法，流程回顾请求处理流程图

其中通过HandlerMapping获得的是HandlerExecutionChain 对象

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    //......
    HandlerExecutionChain mappedHandler = null;
	//......
    mappedHandler = getHandler(processedRequest);
    //......     
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
	//......
}

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        for (HandlerAdapter adapter : this.handlerAdapters) {
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }
    throw new ServletException("No adapter for handler [" + handler +
                               "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

HandlerExecutionChain 中包含一个handler对象（后面匹配能处理handler的适配器对象执行，详情对应适配器模式中讲解），还有一个拦截器列表List<HandlerInterceptor> interceptorList，所有的实现了HandlerInterceptor接口的类都会被加载进这个集合中，在请求处理前后分别以责任链的形式调用拦截器的preHandle和postHandle

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HandlerInterceptor[] interceptors = getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for (int i = 0; i < interceptors.length; i++) {
            HandlerInterceptor interceptor = interceptors[i];
            if (!interceptor.preHandle(request, response, this.handler)) {
                triggerAfterCompletion(request, response, null);
                return false;
            }
            this.interceptorIndex = i;
        }
    }
    return true;
}

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
    throws Exception {

    HandlerInterceptor[] interceptors = getInterceptors();
    if (!ObjectUtils.isEmpty(interceptors)) {
        for (int i = interceptors.length - 1; i >= 0; i--) {
            HandlerInterceptor interceptor = interceptors[i];
            interceptor.postHandle(request, response, this.handler, mv);
        }
    }
}

Servlet Filter

servlet中Filter的调用也是通过责任链模式，通过FilterChain作为链条的管理者

//FilterChain接口
public interface FilterChain {
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException;
}

//FilterChain实现类
public class MockFilterChain implements FilterChain {
	
    //......
	private final List<Filter> filters;
	//......
    
	@Override
	public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
		Assert.notNull(request, "Request must not be null");
		Assert.notNull(response, "Response must not be null");
		Assert.state(this.request == null, "This FilterChain has already been called!");

		if (this.iterator == null) {
			this.iterator = this.filters.iterator();
		}

		if (this.iterator.hasNext()) {
			Filter nextFilter = this.iterator.next();
			nextFilter.doFilter(request, response, this);
		}

		this.request = request;
		this.response = response;
	}
}

//Filter接口
public interface Filter {

    default public void init(FilterConfig filterConfig) throws ServletException {}

    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain)
            throws IOException, ServletException;

    default public void destroy() {}
}

//Filter实现类
public class AuthFilter extends AuthenticationFilter {
   //......
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = toLowerCase((HttpServletRequest)request);
        String tokenString = httpRequest.getParameter("delegation");
        if (tokenString != null) {
            filterChain.doFilter(httpRequest, response);
        } else {
            super.doFilter(httpRequest, response, filterChain);
        }
    }
    //......
}

Netty

Netty中的handler使用了责任链模式，但是其中回调过多，责任链模式的体现不清晰，参考该文章**Spring中如何使用责任链模式**，将责任链抽离出来，完成在spring中的调用

在这里插入图片描述

我们先仅看Filter事件这一条链，整个结构由Pipeline管理整条链

在这里插入图片描述

//Pipelie接口
public interface Pipeline {
    Pipeline fireTaskFiltered();
}

//Pipeline实现类
Component("pipeline")
@Scope("prototype")
public class DefaultPipeline implements Pipeline, ApplicationContextAware, InitializingBean {
    // 创建一个默认的handler，将其注入到首尾两个节点的HandlerContext中，其作用只是将链往下传递
    private static final Handler DEFAULT_HANDLER = new Handler() {};

    // 将ApplicationContext注入进来的主要原因在于，HandlerContext是prototype类型的，因而需要
    // 通过ApplicationContext.getBean()方法来获取其实例
    private ApplicationContext context;

    // 创建一个头结点和尾节点，这两个节点内部没有做任何处理，只是默认的将每一层级的链往下传递，
    // 这里头结点和尾节点的主要作用就是用于标志整个链的首尾，所有的业务节点都在这两个节点中间
    private HandlerContext head;
    private HandlerContext tail;

    // 用于业务调用的request对象，其内部封装了业务数据
    private Request request;
    // 用于执行任务的task对象
    private Task task;

    // 最初始的业务数据需要通过构造函数传入，因为这是驱动整个pipeline所需要的数据，
    // 一般通过外部调用方的参数进行封装即可
    public DefaultPipeline(Request request) {
        this.request = request;
    }

    // 这里我们可以看到，每一层级的调用都是通过HandlerContext.invokeXXX(head)的方式进行的，
    // 也就是说我们每一层级链的入口都是从头结点开始的，当然在某些情况下，我们也需要从尾节点开始链
    // 的调用，这个时候传入tail即可。

    // 触发任务过滤的链调用
    @Override
    public Pipeline fireTaskFiltered() {
        HandlerContext.invokeTaskFiltered(head, task);
        return this;
    }

    // 用于往Pipeline中添加节点的方法，读者朋友也可以实现其他的方法用于进行链的维护
    void addLast(Handler handler) {
        HandlerContext handlerContext = newContext(handler);
        tail.prev.next = handlerContext;
        handlerContext.prev = tail.prev;
        handlerContext.next = tail;
        tail.prev = handlerContext;
    }

    // 这里通过实现InitializingBean接口来达到初始化Pipeline的目的，可以看到，这里初始的时候
    // 我们通过ApplicationContext实例化了两个HandlerContext对象，然后将head.next指向tail节点，
    // 将tail.prev指向head节点。也就是说，初始时，整个链只有头结点和尾节点。
    @Override
    public void afterPropertiesSet() throws Exception {
        head = newContext(DEFAULT_HANDLER);
        tail = newContext(DEFAULT_HANDLER);
        head.next = tail;
        tail.prev = head;
    }

    // 使用默认的Handler初始化一个HandlerContext
    private HandlerContext newContext(Handler handler) {
        HandlerContext context = this.context.getBean(HandlerContext.class);
        context.handler = handler;
        return context;
    }

    // 注入ApplicationContext对象
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
    }
}

@Component
@Scope("prototype")
public class HandlerContext {

    HandlerContext prev;
    HandlerContext next;
    Handler handler;

    private Task task;

    public void fireTaskFiltered(Task task) {
        invokeTaskFiltered(next(), task);
    }

    /**
     * 处理任务过滤事件
     */
    static void invokeTaskFiltered(HandlerContext ctx, Task task) {
        if (null != ctx) {
            try {
                ctx.handler().filterTask(ctx, task);
            } catch (Throwable e) {
                ctx.handler().exceptionCaught(ctx, e);
            }
        }
    }

    private HandlerContext next() {
        return next;
    }

    private Handler handler() {
        return handler;
    }
}

public interface Handler {
    /**
     * 查询到task之后，进行task过滤的逻辑
     */
    default void filterTask(HandlerContext ctx, Task task) {
        ctx.fireTaskFiltered(task);
    }
}

@Component
public class DurationHandler implements Handler {
    @Override
    public void filterTask(HandlerContext ctx, Task task) {
        System.out.println("时效性检验");
        ctx.fireTaskFiltered(task);
    }
}

@Component
public class RiskHandler implements Handler {
    @Override
    public void filterTask(HandlerContext ctx, Task task) {
        System.out.println("风控拦截");
        ctx.fireTaskFiltered(task);
    }
}

@Component
public class TimesHandler implements Handler {
    @Override
    public void filterTask(HandlerContext ctx, Task task) {
        System.out.println("次数限制检验");
        ctx.fireTaskFiltered(task);
    }
}

以上可以由spring完成，通过生命实现接口BeanPostProcessor的类，实现postProcessAfterInitialization方法，可以在初始化完Pipeline后，获取所有实现了Handler的bean，并添加到pipeline中，spring自动调用该方法

@Component
public class HandlerBeanProcessor implements BeanPostProcessor, ApplicationContextAware {

    private ApplicationContext context;

    // 该方法会在一个bean初始化完成后调用，这里主要是在Pipeline初始化完成之后获取所有实现了
    // Handler接口的bean，然后通过调用Pipeline.addLast()方法将其添加到pipeline中
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof DefaultPipeline) {
            DefaultPipeline pipeline = (DefaultPipeline) bean;
            Map<String, Handler> handlerMap = context.getBeansOfType(Handler.class);
            handlerMap.forEach((name, handler) -> pipeline.addLast(handler));
        }

        return bean;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
    }
}

如此下来，整个过程调用如下

@Service
public class ApplicationService {

    @Autowired
    private ApplicationContext context;

    public void mockedClient(Request request) {
        Pipeline pipeline = newPipeline(request);
        pipeline.fireTaskFiltered();
    }

    private Pipeline newPipeline(Request request) {
        return context.getBean(DefaultPipeline.class, request);
    }
}

至此单条链的责任链模式已完成