设计模式--责任链模式

2021/7/27 23:35:48

本文主要是介绍设计模式--责任链模式,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

简介

​ 责任链模式(Chain of Responsibility Pattern)也叫职责链模式:是将链中每一个节点看作是一个对象,每个节点处理的请求均不同,且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时,会沿着链的路径依次传递给每一个节点对象,知道有对象处理这个请求为止。属于行为型模式。

责任链的应用场景

1、工作中的审批流程

2、游戏中的闯关

责任链模式主要是解耦了请求与处理,客户只需将请求发送到链上即可,无需关心请求的具体内容和处理细节,请求会自动进行传递直至有节点对象进行处理。适用于以下应用场景:

1、多个对象可以处理同一请求,但具体由哪个对象处理则在运行时动态决定;

2、在不明确指定接受者的情况下,向多个对象中的一个提交一个请求

3、可动态指定一组对象处理请求

责任链模式的UML类图:

从UML类图,我们可以看到,责任链模式只要包含两种角色:

抽象处理者(Handler):定义一个请求处理的方法,并维护一个下一个处理节点Handler对象的引用;

具体处理者(ConcreteHandler):对请求进行处理,如果不感兴趣,则进行转发。

责任链模式的本质是解耦请求与处理,让请求在处理链中能进行传递与被处理;理解责任链模式应当理解的是其模式而不是具体实现,责任链模式的独到之处是其将节点处理者组成了链式结构,并允许节点自身决定是否进行请求处理或转发,相当于让请求流动了起来。

责任链模式在源码中的体现

1、JDK中的应用,Filter类

public interface Filter {

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

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

    public default void destroy() {}
    
}

这个接口相当于责任链模型中的Handler抽象角色。通过doFilter()方法形成一条责任链。

public interface FilterChain {

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

}

FilterChain类中也只定义了一个doFilter()方法,那么它们是怎么串联成一个责任链呢?实际上J2EE只是定义了一个规范,具体处理逻辑是由使用者自己来实现。

  • Spring中的实现
public class MockFilterChain implements FilterChain {

	@Nullable
	private ServletRequest request;

	@Nullable
	private ServletResponse response;

	private final List<Filter> filters;

	@Nullable
	private Iterator<Filter> iterator;

    ...
        
	@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;
	}
    
    private static List<Filter> initFilterList(Servlet servlet, Filter... filters) {
		Filter[] allFilters = ObjectUtils.addObjectToArray(filters, new ServletFilterProxy(servlet));
		return Arrays.asList(allFilters);
	}
    
    ...
}

它把链条中的所有Filter放到List中,然后在调用doFilter()方法时循环迭代List,也就是说List中的Filter会顺序执行。

2、Netty中的串行化处理Pipeline就采用了责任链设计模式,它底层采用双向链表的数据结构,将链上的各个处理器串联起来。客户端每一次请求的到来,Netty都认为Pipeline中的所有处理器都有机会处理它。因此,对于入栈的请求全部从头节点开始往后传播,一直传播到尾节点才会把消息释放掉。

Netty的责任处理器接口ChannelHandler

public interface ChannelHandler {

    void handlerAdded(ChannelHandlerContext ctx) throws Exception;

    void handlerRemoved(ChannelHandlerContext ctx) throws Exception;

    @Deprecated
    void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;

  
    @Inherited
    @Documented
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface Sharable {
        // no value
    }
}

Netty对责任处理接口做了更细粒度的划分,处理器被分成了两种,一种是入栈处理器ChannelInboundHandler,另一种是出栈处理器ChannelOutboundHandler,这两个接口都继承自

ChannelHandler

而所有的处理器最终都添加到Pipeline上。所以,添加删除责任处理器额接口的行为在Netty的ChannelPipeline中进行了规定:

public interface ChannelPipeline
        extends ChannelInboundInvoker, ChannelOutboundInvoker, Iterable<Entry<String, ChannelHandler>> {

    ChannelPipeline addFirst(String name, ChannelHandler handler);

    ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler);

    ChannelPipeline addLast(String name, ChannelHandler handler);

    ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler);

    ChannelPipeline addBefore(String baseName, String name, ChannelHandler handler);

    ChannelPipeline addBefore(EventExecutorGroup group, String baseName, String name, ChannelHandler handler);
    
    ...
}

在默认实现类中将所有的Handler都串了起来(链表):

public class DefaultChannelPipeline implements ChannelPipeline {
    
    ...
        
    final AbstractChannelHandlerContext head;
    final AbstractChannelHandlerContext tail;
    
    ...
        
    protected DefaultChannelPipeline(Channel channel) {
        this.channel = ObjectUtil.checkNotNull(channel, "channel");
        succeededFuture = new SucceededChannelFuture(channel, null);
        voidPromise =  new VoidChannelPromise(channel, true);

        tail = new TailContext(this);
        head = new HeadContext(this);

        head.next = tail;
        tail.prev = head;
    }
    
    ...
    
}

在Pipeline中的任意一个节点,只要我们不手动的往下传播下去,这个事件就会终止传播在当前节点。对于入栈数据,默认会传递到尾节点进行回收。如果我们不进行下一步传播,事件就会终止在当前节点。对于出栈数据把数据写回客户端也意味着事件的终止。

责任链模式的优缺点:

优点:

1、将请求与处理解耦

2、请求处理者(节点对象)只需关注自己感兴趣的请求进行处理即可,对于不感兴趣的请求,直接转发给下一级节点对象;

3、具备链式传递处理请求功能,请求发送者无需知晓链路结构,只需等待请求处理结果;

4、链路结构灵活,可以通过改变链路结构动态的新增或删减责任;

5、易于扩展新的请求处理类(节点),符合开闭原则。

缺点:

1、责任链太长或者处理时间过长,会影响整体性能;

2、如果节点对象存在循环引用,会造成死循环,导致系统崩溃。

代码链接

责任链模式



这篇关于设计模式--责任链模式的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程