责任链模式（ Chain of Responsibility Pattern）为请求创建了一个处理对象的链，每一个链条处理一件事情；

 类似于上面图的情况，每个部分做的事情不同，并不感染，感觉就像是一个个组件进行组装

责任链的好处

• 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
• 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
• 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
• 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
• 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点

• 不能保证每个请求都被处理，有可能这个处理并不会到末端就抛出掉了某个请求
• 对比较长的职责链，对象是非常多的，有可能会出现占用资源过大的问题
• 职责链建立的合理性要靠客户端来保证，因此也可能出现写出错的情况

在netty中主要就是利用责任链模式，进行业务上处理，达到netty的耦合降低，扩展性好的特点。

实现责任链模式 

一定有四个要素：

• 处理抽象类 抽象出方法用于链条的传递 next 方法
• 具体的处理器实现类   用于处理链条之间的数据
• 保存处理器信息  无论是数组实现  还是链条实现  都需要一个容器来存储这些实现类然后让链条连接起来
• 处理执行   开始执行的方法  执行器

代码实现

• 抽象处理类以及   处理抽象类   Pipeline  来进行管理并持有 抽象处理类

/*** 主要持有类* * @author**/
public class Pipeline {/*** handler上下文，主要负责维护链 ,和链的执行*/class HandlerChainContext {HandlerChainContext next;// 持有下一个节点AbstractHandler handler;public HandlerChainContext(AbstractHandler handler) {this.handler = handler;}// 将节点持有下去void handler(Object arg0) {this.handler.doHandler(this, arg0);}/*** 继续执行下一个*/void runNext(Object arg0) {if (this.next != null) {this.next.handler(arg0);}}}/*** 抽象处理类 用于处理链条之间的数据* * @author**/static abstract class AbstractHandler {abstract void doHandler(HandlerChainContext context, Object arg0);}}

• 对Pipeline 进行完善  

// 持有上下文public HandlerChainContext context = new HandlerChainContext(new AbstractHandler() {@Overridevoid doHandler(HandlerChainContext context, Object arg0) {System.out.println("这是头部");context.runNext(arg0);}});

• 增加责任链的方法及调用方法

// 添加责任链public void addLast(AbstractHandler handler) {HandlerChainContext next = context;while (next.next != null) {next = next.next;}next.next = new HandlerChainContext(handler);}// 开始调用public void requestProcess(Object arg0) {context.handler(arg0);}

• 最后创建一个具体实现处理类 和测试代码

static class Handler1 extends AbstractHandler {@Overridevoid doHandler(HandlerChainContext handlerChainContext, Object arg0) {arg0 = arg0.toString() + "..handler1的的处理.....";System.out.println("我是Handler1的实例，我在处理：" + arg0);// 继续执行下一个handlerChainContext.runNext(arg0);}}public static void main(String[] args) {Pipeline p = new Pipeline();p.addLast(new Handler1());p.requestProcess("开始了....");}

得到下面的打印结果

这是头部
我是Handler1的实例，我在处理：开始了........这是头部......handler1的的处理.....

完整代码

/*** 主要持有类* * @author**/
public class Pipeline {// 持有上下文public HandlerChainContext context = new HandlerChainContext(new AbstractHandler() {@Overridevoid doHandler(HandlerChainContext context, Object arg0) {System.out.println("这是头部");context.runNext(arg0 + "....这是头部....");}});// 添加责任链public void addLast(AbstractHandler handler) {HandlerChainContext next = context;while (next.next != null) {next = next.next;}next.next = new HandlerChainContext(handler);}// 开始调用public void requestProcess(Object arg0) {context.handler(arg0);}/*** handler上下文，主要负责维护链 ,和链的执行*/class HandlerChainContext {HandlerChainContext next;// 持有下一个节点AbstractHandler handler;public HandlerChainContext(AbstractHandler handler) {this.handler = handler;}// 将节点持有下去void handler(Object arg0) {this.handler.doHandler(this, arg0);}/*** 继续执行下一个*/void runNext(Object arg0) {if (this.next != null) {this.next.handler(arg0);}}}/*** 具体的处理器实现类   用于处理链条之间的数据* * @author**/static abstract class AbstractHandler {abstract void doHandler(HandlerChainContext context, Object arg0);}static class Handler1 extends AbstractHandler {@Overridevoid doHandler(HandlerChainContext handlerChainContext, Object arg0) {arg0 = arg0.toString() + "..handler1的的处理.....";System.out.println("我是Handler1的实例，我在处理：" + arg0);// 继续执行下一个handlerChainContext.runNext(arg0);}}public static void main(String[] args) {Pipeline p = new Pipeline();p.addLast(new Handler1());p.requestProcess("开始了....");}}

Netty中的ChannelPipeline责任链

在netty中实现责任链的就是Pipeline管道

• NioEventLoop的run是在初始化时就会启动run方法，然后监听是否有事件过来

 

• 在抽象类AbstractChannel中持有者pipeline 

• 会在初始化时就创建 这个pipeline

• Pipeline管道中入站事件  ，以及出站事件
• handler处理器是什么，有什么作用？
• Pipeline 如何维护 handler 的。
• handler 的执行。

   

应用层往native层写数据 连接关闭 写入数据等等都是出站事件

• 在DefaultChannelPipeline中就有头和尾 的Context  类似责任链中  持有的 具体的处理器实现类

• 初始化时 将连接起来 头和尾连接起来

• 当消息过来时就会走AbstractNioByteChannel 中read 方法做包括申请多少内存 以及   pipeline.fireChannelRead(byteBuf);  去读取数据内容   这里的ByteBuf 是封装过了ByteBuffer的一个类。

• 就是fire  开头的都是触发入站的事件

•  而对于出站事件则是 包括wite  read bind等方法来表示的

•  源码中对于入站和出战事件，完全按照 入站中头开始，出战按尾部开始

•  继续走下去找到读取的方法

•  调用到下一个channelpipline方法

  @Overridepublic ChannelHandlerContext fireChannelRead(final Object msg) {invokeChannelRead(findContextInbound(), msg);return this;}

•  在pipeline 中 add 和remove则是维护链表上的数据

 

 

• 对于context中也存在许多的读取方法等等

AbstractChannelHandlerContext

作为有  pipeline 以及context 事件的持有者，并在实现的子类中持有对应的handler  利用handler方法，而context就是为了维护链的结构而产生的

 

 所以要对事件进行做处理，因此需要实现  ChannelInboundHandlerAdapter 或者   对应的事件即可

public class EchoServerHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) {System.out.println("收到客户端数据，还给客户端：" + msg);ctx.write(msg);
//        ctx.channel().write("");}@Overridepublic void channelReadComplete(ChannelHandlerContext ctx) {ctx.flush();}@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {// Close the connection when an exception is raised.cause.printStackTrace();ctx.close();}
}

在使用时，添加进去就行

            ServerBootstrap b = new ServerBootstrap();// 3、配置启动器b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 100).handler(new LoggingHandler(LogLevel.INFO)).childHandler(new ChannelInitializer<SocketChannel>() {@Overridepublic void initChannel(SocketChannel ch) throws Exception {ChannelPipeline p = ch.pipeline();p.addLast(new EchoServerHandler());}});

ChannelDuplexHandler

这个Handler 是继承ChannelInboundHandlerAdapter 并且实现了ChannelOutboundHandler的既能入站 也可以出站

在源码中有很多这种handler 实现 提供给我们可以我们对入站事件和出站事件进行处理。

 Netty中事件的定义

Pipeline中的handler