本文先介绍了责任链模式的概念及简单实现。再贴了netty中对责任链的实现。最后总结了一点点思考。
1、概念相关
1.1、概念
责任链模式为请求创建了一个接收者对象的链,每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求,那么它会把相同的请求传给下一个接收者,沿着这条链传递请求,直到有对象处理它为止。
1.2、解决了什么:
客户只需要将请求发送到职责链上即可,无须关心请求的处理细节和请求的传递,所以职责链将请求的发送者和请求的处理者解耦了。
1.3、场景:
1、有多个对象可以处理同一个请求,具体哪个对象处理该请求由运行时刻自动确定。
2、在不明确指定接收者的情况下,向多个对象中的一个提交一个请求。
3、可动态指定一组对象处理请求。
2、简单实现
2.1 代码
注:代码中getter 和 setter都省略
定义一个请求
1 2 3 4 5 6 7 | public class Request { private String name; private int days; } |
定义一个返回结果
1 2 3 4 5 6 7 8 | public class Result { private boolean agree; public Result( boolean agree) { this .agree = agree; } } |
定义一个处理接口
1 2 3 4 5 6 7 8 9 10 11 | public interface Handler { // 每个处理器持有链,能取到链上的请求或者传递请求 Result deal(Chain chain); interface Chain { // 获取请求 Request request(); // 传递请求 Result proceed(Request request); } } |
定义一个处理接口的链
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | public class HandlerChain implements Handler.Chain { // 持有链要处理的请求 private Request request; // 持有链上所有的处理器 private Queue<Handler> handlers; public HandlerChain(Request request) { this .request = request; } // 添加一个处理器 public HandlerChain addHandler(Handler handler) { if (handlers == null ) { handlers = new LinkedList<>(); } handlers.add(handler); return this ; } // 实现接口的方法- 获取请求 public Request request() { return request; } // 实现接口的方法- 处理请求 public Result proceed(Request request) { // 取队首的处理器开始请求。如果队首的处理器处理了,直接返回结果 // 如果队首的处理器选择传递请求,又会进这个proceed方法。取新的队首处理 // 为什么是传递而不是直接遍历队列,如果result = null,继续;result != null,返回呢? 因为传递的方式,可以对request再次处理。A处理器可以做简单处理,再传递给B。 Handler handler = handlers.poll(); return handler.deal( this ); } } |
定义三个处理者
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | public class AHandler implements Handler{ public Result deal(Chain chain) { Request request = chain.request(); // 只处理小于等于1的请求,大于1的请求被传递了 if (request.getDays() > 1 ) { // 这里可以对request做部分处理,再传递 return chain.proceed(request); } System.out.println( "A处理了" ); return new Result( true ); } } public class BHandler implements Handler { public Result deal(Chain chain) { Request request = chain.request(); // 只处理小于等于2的请求,大于2的请求被传递了 if (request.getDays() > 2 ) { return chain.proceed(request); } System.out.println( "B处理了" ); return new Result( true ); } } public class CHandler implements Handler { public Result deal(Chain chain) { Request request = chain.request(); // 只处理小于等于3的请求,大于3的请求被传递了 if (request.getDays() > 3 ) { return chain.proceed(request); } System.out.println( "C处理了" ); return new Result( true ); } } |
测试
1 2 3 4 5 6 7 8 9 10 11 | public class Test { public static void main(String[] args) { // new 一个链,往链上添加处理器 Request request1 = new Request( "hhy" , 3 ); HandlerChain chains = new HandlerChain(request1).addHandler( new AHandler()).addHandler( new BHandler()).addHandler( new CHandler()); Result result1 = chains.proceed(request1); System.out.println( "结果:" + result1.isAgree()); } } |
结果
传入3:
返回:
C处理了
结果:true传入2:
返回:
B处理了
结果:true传入1:
返回:
A处理了
结果:true
3. netty中的责任链模式
用过netty的同学看到下面这个代码应该很熟悉了,非常简单netty客户端,创建连接,设置编解码器,发送请求。
1 2 3 4 5 6 7 8 9 10 11 12 13 | public static void main(String[] args) { EventLoopGroup group = new NioEventLoopGroup(); NioSocketChannel channel = new NioSocketChannel(); Bootstrap bootstrap = new Bootstrap(); bootstrap.group(group).option(ChannelOption.TCP_NODELAY, true ); InetSocketAddress address = new InetSocketAddress(InetAddress.getByName(httpRequest.host), httpRequest.port); group.register(channel); channel.connect(address).sync(); channel.pipeline().addLast( "http-decoder" , new HttpResponseDecoder()); channel.pipeline().addLast( "http-encoder" , new HttpRequestEncoder()); channel.pipeline().addLast( "http-client" , new HttpHandler(HttpClient. this )); channel.writeAndFlush(httpRequest); } |
通过我们上面的例子,不难猜测到 channel.pipeline() 应该就是一个链,持有了channel上所有的处理器。pipeline()方法返回一个ChannelPipeline接口,我们直接看它的实现类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | public class DefaultChannelPipeline implements ChannelPipeline { final AbstractChannelHandlerContext head; final AbstractChannelHandlerContext tail; @Override public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) { final AbstractChannelHandlerContext newCtx; synchronized ( this ) { checkMultiplicity(handler); // 把handler封装成AbstractChannelHandlerContext newCtx = newContext(group, filterName(name, handler), handler); // 调用了 addLast0方法 addLast0(newCtx); ... } callHandlerAdded0(newCtx); return this ; } private void addLast0(AbstractChannelHandlerContext newCtx) { // 把新加入的处理器设置成尾部的前驱,原尾部的前驱设置成新处理器的后继 AbstractChannelHandlerContext prev = tail.prev; newCtx.prev = prev; newCtx.next = tail; prev.next = newCtx; tail.prev = newCtx; } } |
通过addLast0, 我们看到DefaultChannelPipeline使用了链表的形式存储了处理器。
继续看这个类的其他方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | public class DefaultChannelPipeline implements ChannelPipeline { ... @Override public final Channel channel() { return channel; } @Override public final ChannelPipeline fireChannelActive() { AbstractChannelHandlerContext.invokeChannelActive(head); return this ; } ... } |
返回当前的channel,处理channel上的事件。(就类似于我们上面的链里面有getRequest(),proceed()方法 )
继续跟踪invokeChannelActive方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | abstract class AbstractChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint { static void invokeChannelActive(final AbstractChannelHandlerContext next) { EventExecutor executor = next.executor(); if (executor.inEventLoop()) { next.invokeChannelActive(); } else { executor.execute( new Runnable() { @Override public void run() { next.invokeChannelActive(); } }); } } // 调用了invokeChannelActive private void invokeChannelActive() { // 判断是不是要处理 if (invokeHandler()) { try { // 处理 ((ChannelInboundHandler) handler()).channelActive( this ); } catch (Throwable t) { invokeExceptionCaught(t); } } else { // 事件传递 fireChannelActive(); } } @Override public ChannelHandlerContext fireChannelActive() { // 执行前需要先找到一个合适的处理器 invokeChannelActive invokeChannelActive(findContextInbound(MASK_CHANNEL_ACTIVE)); return this ; } private AbstractChannelHandlerContext findContextInbound( int mask) { AbstractChannelHandlerContext ctx = this ; EventExecutor currentExecutor = executor(); do { // 循环,找到一个合适的处理器并返回 ctx = ctx.next; } while (skipContext(ctx, currentExecutor, mask, MASK_ONLY_INBOUND)); return ctx; } } |
其实看到这,这个链已经非常的明显了。 pipline持有处理器,AbstractChannelHandlerContext做了一些封装,使得链上的处理器能对事件进行传递和处理。
最后再看下handler的实现类
1 2 3 4 5 6 7 8 | public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler { ...... @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { ctx.fireChannelActive(); } ...... } |
以这个ChannelInboundHandlerAdapter为例,在channel收到激活事件通知的时候,它调用了ctx.fireChannelActive();方法传递了事件。ctx是ChannelHandlerContext类型,很熟悉,它是个接口,我们上面看到的AbstractChannelHandlerContext是它的实现类。就这样,一个激活事件就在链上传递了起来。而链上的处理器就是我们最初始的测试方法里面addLast进去的。
4、思考
在netty中,事件在责任链中有序传播,事件处理器可以处理自己关心的功能,可以拦截,也可以继续传播(向前或向后)事件。上层的业务只需要关心自己的逻辑。整个架构层次分明。
OA系统的工作流 似乎也特别适合责任链模式,正如我们一开始的例子,不同人审批不同的时长的假期。
对于代码里某些冗长的if else ,是不是也有改造成责任链的可能?
if (通过第一关) {
进入第二关
if (通过第二关) {
进入第三关
...
}
}
改成通过第一关后传递事件,反之结束。这期间还可以灵活的做跳跃,得到某个奖励,直接跳到第三关。如果要添加第四关,也比if else灵活的多。
当然并不是if else 都适合改造成责任链模式,还是要具体的业务及效率上综合考虑。个人觉得在流程上有顺序依赖的,非常适合。
到此这篇关于Java设计模式之责任链模式的概念、实现以及netty中的责任链模式的文章就介绍到这了,更多相关责任链模式的概念实现及netty的责任链模式内容请搜索自学编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持自学编程网!
[1] https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html
- 本文固定链接: https://zxbcw.cn/post/202503/
- 转载请注明:必须在正文中标注并保留原文链接
- QQ群: PHP高手阵营官方总群(344148542)
- QQ群: Yii2.0开发(304864863)