15ChannelInitializer

ChannelInitializer

• ChannelInitializer 是一种特殊的 ChannelHandler&＃xff0c;它也是一种 ChannelInboundHandler&＃xff0c;它提供了在通道注册到 EventLoop 后初始化通道的简单方法&＃xff1b;其主要目的是在某个 Channel 注册到 EventLoop 后&＃xff0c;对这个 Channel 执行一些初始化操作。在初始化完成之后&＃xff0c;ChannelInitializer 会 将自己从 Pipeline 中移除&＃xff0c;不会影响后续的操作。

• 作用&＃xff1a;在某个Channel注册到EventLoop后&＃xff0c;对这个Channel执行一些初始化操作&＃xff0c;初始化操作完成后会将自身从Pipeline中移除。

一、继承关系

二、源码

2.1 注释

• 源码注释如下&＃xff1a;

/*** 一个特殊的ChannelInboundHandler&＃xff0c;提供了一个便捷的方式在Channel注册到EventLoop的时候来初始化这个Channel* A special {&＃64;link ChannelInboundHandler} which offers an easy way to initialize a {&＃64;link Channel} once it was* registered to its {&＃64;link EventLoop}.** 很多时候是在 Bootstrap#handler/ServerBootstrap#handler或者ServerBootstrap#childHandler 方法中使用&＃xff0c;* 用于初始化 Channel 的 ChannelPipeline* * Implementations are most often used in the context of {&＃64;link Bootstrap#handler(ChannelHandler)} ,* {&＃64;link ServerBootstrap#handler(ChannelHandler)} and {&＃64;link ServerBootstrap#childHandler(ChannelHandler)} to* setup the {&＃64;link ChannelPipeline} of a {&＃64;link Channel}.**

* 使用示例如下&＃xff1a;* public class MyChannelInitializer extends {&＃64;link ChannelInitializer} {*     public void initChannel({&＃64;link Channel} channel) {*         channel.pipeline().addLast("myHandler", new MyHandler());*     }* }** {&＃64;link ServerBootstrap} bootstrap &＃61; ...;* ...* bootstrap.childHandler(new MyChannelInitializer());* ...* 

2.2 源码分析

• initChannel 方法是我们需要自行实现的

/*** This method will be called once the {&＃64;link Channel} was registered. After the method returns this instance* will be removed from the {&＃64;link ChannelPipeline} of the {&＃64;link Channel}.*

* Channel被注册到EventLoop的时候initChannel会被调用&＃xff0c;ChannelInitializer实现类必须重写该方法。* 并且该方法调用返回之后&＃xff0c;ChannelInitializer实例会从ChannelPipeline移除** &＃64;param ch the {&＃64;link Channel} which was registered.* &＃64;throws Exception is thrown if an error occurs. In that case it will be handled by* {&＃64;link #exceptionCaught(ChannelHandlerContext, Throwable)} which will by default close* the {&＃64;link Channel}.*/protected abstract void initChannel(C ch) throws Exception;


• initChannel(ChannelHandlerContext ctx) 初始化&＃xff0c;执行handler的添加逻辑

&＃64;SuppressWarnings("unchecked")private boolean initChannel(ChannelHandlerContext ctx) throws Exception {// Guard against re-entrance. 解决并发问题&＃xff0c;原来没有放进去的话会返回null&＃xff0c;原来有就不会放进去&＃xff0c;返回旧值if (initMap.putIfAbsent(ctx, Boolean.TRUE) &＃61;&＃61; null) {try {//1.初始化通道&＃xff0c;调用用户自己的实现添加 handlerinitChannel((C) ctx.channel());} catch (Throwable cause) {//2.发生异常时&＃xff0c;执行异常处理&＃xff0c;记录日志并关闭 ChannelHandlerContext// Explicitly call exceptionCaught(...) as we removed the handler before calling initChannel(...).// We do so to prevent multiple calls to initChannel(...).exceptionCaught(ctx, cause);} finally {//3.从 pipeline 移除 ChannelInitializer 自身(这行日志是我自己添加的)logger.info("initChannel移除: " &＃43; ctx&＃43; ", 内部的handler是: " &＃43; ctx.handler()&＃43; ", handler类型是: " &＃43; ctx.handler().getClass()&＃43; ", ctx 类型是: " &＃43; ctx.getClass());remove(ctx);}//4.初始化成功return true;}//5.初始化失败return false;}


• 其他代码

&＃64;Sharable
public abstract class ChannelInitializer<C extends Channel> extends ChannelInboundHandlerAdapter {private static final InternalLogger logger &＃61; InternalLoggerFactory.getInstance(ChannelInitializer.class);// We use a ConcurrentMap as a ChannelInitializer is usually shared between all Channels in a Bootstrap /// ServerBootstrap. This way we can reduce the memory usage compared to use Attributes./*** 由于 ChannelInitializer 通常可以在所有的 Bootstrap/ServerBootstrap 通道中共享&＃xff0c;因此我们用一个 ConcurrentMap* 这种方式相对于使用 Attributes 方式&＃xff0c;可以减少内存的使用&＃xff0c;相当于不同的通道&＃xff0c;对应的 ChannelHandlerContext 不同&＃xff0c;由* ConcurrentMap 来解决了并发问题*/private final ConcurrentMap<ChannelHandlerContext, Boolean> initMap &＃61; PlatformDependent.newConcurrentHashMap();/*** Handle the {&＃64;link Throwable} by logging and closing the {&＃64;link Channel}. Sub-classes may override this.*/&＃64;Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {if (logger.isWarnEnabled()) {logger.warn("Failed to initialize a channel. Closing: " &＃43; ctx.channel(), cause);}ctx.close();}private void remove(ChannelHandlerContext ctx) {try {ChannelPipeline pipeline &＃61; ctx.pipeline();//1.从 pipeline 找到 ChannelHandler 对应的 ChannelHandlerContext 节点//(pipeline 中的节点是ChannelHandlerContext&＃xff0c;ChannelHandlerContext包装了ChannelHandler)if (pipeline.context(this) !&＃61; null) {//2.移除对应的handler(ChannelInitializer也是一种handler&＃xff0c;内部会把 handler 包// 装成的ChannelHandlerContext 节点&＃xff0c;再删除节点&＃xff0c;pipeline内部是链表结构&＃xff0c;节点// 是ChannelHandlerContext类型)pipeline.remove(this);}} finally {//3.从initMap移除initMap.remove(ctx);}}
}


2.3 handlerAdded和channelRegistered

• handlerAdded 内部会判断 Channel 是否已经注册&＃xff0c;注册的话会调用 initChannel 来执行自定义的handler 添加逻辑&＃xff1b;
• 在 Channel 注册到 EventLoop 上后&＃xff0c;会触发 Channel Registered 事件。那么 ChannelInitializer 的 channelRegistered(ChannelHandlerContext ctx) 方法会得到执行&＃xff0c;内部调用 initChannel 方法
• 二者代码如下&＃xff1a;

/*** {&＃64;inheritDoc} If override this method ensure you call super!*/&＃64;Overridepublic void handlerAdded(ChannelHandlerContext ctx) throws Exception {//1.已注册if (ctx.channel().isRegistered()) {//添加该行日志调试logger.info("ChannelInitializer 的 handlerAdded 方法执行... " );// This should always be true with our current DefaultChannelPipeline implementation.// The good thing about calling initChannel(...) in handlerAdded(...) is that there will be no ordering// surprises if a ChannelInitializer will add another ChannelInitializer. This is as all handlers// will be added in the expected order.initChannel(ctx);}}&＃64;Override&＃64;SuppressWarnings("unchecked")public final void channelRegistered(ChannelHandlerContext ctx) throws Exception {// Normally this method will never be called as handlerAdded(...) should call initChannel(...) and remove// the handler.//添加该行日志调试logger.info("进入 ChannelInitializer 的 channelRegistered 方法... " );// 初始化 Channelif (initChannel(ctx)) {//添加该行日志调试logger.info("ChannelInitializer 的 channelRegistered 方法进入if逻辑执行... " );// we called initChannel(...) so we need to call now pipeline.fireChannelRegistered() to ensure we not// miss an event.// 重新触发 Channel Registered 事件ctx.pipeline().fireChannelRegistered();} else {// 继续向下一个节点传播Channel Registered 事件// Called initChannel(...) before which is the expected behavior, so just forward the event.ctx.fireChannelRegistered();}}


• 换言之&＃xff0c;用户自定义的 ChannelInitializer 初始化逻辑&＃xff0c;看会被这两个方法调用执行&＃xff0c;结合添加了日志后调试情况和查资料来看&＃xff0c;几乎都是 handlerAdded 方法调用的&＃xff0c;不知道什么情况下会由 channelRegistered 调用执行 initChannel(C ch) &＃xff1b;
• 具体调用逻辑&＃xff0c;按照调用栈可以回到 AbstractChannel.AbstractUnsafe#register0 方法&＃xff0c;如下&＃xff1a;

private void register0(ChannelPromise promise) {// ... 其他逻辑pipeline.invokeHandlerAddedIfNeeded();//7.回调通知promise执行成功safeSetSuccess(promise);//8.触发通知已注册事件pipeline.fireChannelRegistered();// ... 其他逻辑}


三、使用示例

• ChannelInitializer的 initChannel 抽象方法在 Channel 被注册到 EventLoop 的时候会被调用&＃xff0c;ChannelInitializer 实现类必须重写该方法。

• 如下是使用代码

//启动器中设置 ChannelInitializer.childHandler(new MyChannelInitializer());//自定义的ChannelInitializerpublic class MyChannelInitializer extends ChannelInitializer {&＃64;Overrideprotected void initChannel(Channel ch) throws Exception {System.out.println("MyChannelInitializer begin ... ");ch.pipeline().addLast("logging",new LoggingHandler(LogLevel.INFO));ch.pipeline().addLast(new EchoServerHandler());}
}


• 前面提到该方法调用是在 Channel 被注册到 EventLoop 的时候调用&＃xff0c;因此运行服务端之后&＃xff0c;启动客户端&＃xff0c;连接成功之后就会触发方法的调用&＃xff0c;下面的代码打印示例&＃xff1a;

//server端日志Connected to the target VM, address: &＃39;127.0.0.1:65446&＃39;, transport: &＃39;socket&＃39;
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/C:/Users/intellif/.m2/repository/org/slf4j/slf4j-simple/1.7.25/slf4j-simple-1.7.25.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/C:/Users/intellif/.m2/repository/org/apache/logging/log4j/log4j-slf4j-impl/2.7/log4j-slf4j-impl-2.7.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.SimpleLoggerFactory]
Thread[nioEventLoopGroup-2-1,10,main]: register
Thread[nioEventLoopGroup-2-1,10,main]: user handler
[nioEventLoopGroup-2-1] INFO io.netty.channel.ChannelInitializer - ChannelInitializer 的 handlerAdded 方法执行...
[nioEventLoopGroup-2-1] INFO io.netty.channel.ChannelInitializer - initChannel移除: ChannelHandlerContext(ServerBootstrap$1#0, [id: 0x024ee434]), 内部的handler是: io.netty.bootstrap.ServerBootstrap$1&＃64;5a308693, handler类型是: class io.netty.bootstrap.ServerBootstrap$1, ctx 类型是: class io.netty.channel.DefaultChannelHandlerContext
Thread[nioEventLoopGroup-2-1,10,main]: PendingRegistrationPromise
Thread[nioEventLoopGroup-2-1,10,main]: ServerBootstrapAcceptor
Thread[nioEventLoopGroup-2-1,10,main]: bind[nioEventLoopGroup-2-2] INFO io.netty.channel.ChannelInitializer - ChannelInitializer 的 handlerAdded 方法执行...
Thread[nioEventLoopGroup-2-2,10,main]: register //这里客户端连接成功
MyChannelInitializer begin ... // MyChannelInitializer 执行&＃xff0c;后面会移除 MyChannelInitializer
EchoServerHandler 构造方法执行 ... //添加自定义的handler
[nioEventLoopGroup-2-2] INFO io.netty.channel.ChannelInitializer - initChannel移除: ChannelHandlerContext(MyChannelInitializer#0, [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196]), 内部的handler是: com.intellif.channelinitializer.MyChannelInitializer&＃64;332f2ee9, handler类型是: class
com.intellif.channelinitializer.MyChannelInitializer, ctx 类型是: class io.netty.channel.DefaultChannelHandlerContext
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] REGISTERED
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] ACTIVE
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] READ: 12B&＃43;-------------------------------------------------&＃43;| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
&＃43;--------&＃43;-------------------------------------------------&＃43;----------------&＃43;
|00000000| 4e 65 74 74 79 20 72 6f 63 6b 73 21 |Netty rocks! |
&＃43;--------&＃43;-------------------------------------------------&＃43;----------------&＃43;
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] WRITE: 12B&＃43;-------------------------------------------------&＃43;| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
&＃43;--------&＃43;-------------------------------------------------&＃43;----------------&＃43;
|00000000| 4e 65 74 74 79 20 72 6f 63 6b 73 21 |Netty rocks! |
&＃43;--------&＃43;-------------------------------------------------&＃43;----------------&＃43;
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] READ COMPLETE
Server received: Netty rocks!
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] WRITE: 0B
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] FLUSH
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 - R:/127.0.0.1:49196] CLOSE
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 ! R:/127.0.0.1:49196] INACTIVE
[nioEventLoopGroup-2-2] INFO io.netty.handler.logging.LoggingHandler - [id: 0x38a1d03f, L:/127.0.0.1:12345 ! R:/127.0.0.1:49196] UNREGISTERED


• 本文主要关于 ChannelInitializer 的用法&＃xff0c;主要是通过重写 initChannel 函数来添加需要的 handler 处理器&＃xff0c;当当前的 channel 被注册到 Eventloop 之后该方法会被调用&＃xff1b;