上篇文章中，我们对Netty中ChannelPipeline的构造与初始化进行了分析与总结，本篇文章我们将对ChannelHandler的添加与删除操作进行具体的的代码分析；
一、ChannelHandler的添加
下面是Netty官方的一段demo源码，可以看到在服务端初始化时执行了向ChannelPipeline中添加自定义channelHandler的操作。
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 100)
.handler(new LoggingHandler(LogLevel.INFO)).childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
if (sslCtx != null) {
p.addLast(sslCtx.newHandler(ch.alloc()));
}
// p.addLast(new LoggingHandler(LogLevel.INFO));
// 向ChannelPipeline中添加自定义channelHandler
p.addLast(serverHandler);
}
});
我们可以看到上面的代码中调用ChannelPipeline的addLast方法实现了channelHandler的添加，下面我们就分析下addLast方法的具体源码实现
首先看下addLast方方法的具体源码实现
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
final AbstractChannelHandlerContext newCtx;
synchronized (this) {
//判断handler是否被重复添加
checkMultiplicity(handler);
//创建ChannelHandlerContext节点 filterName检查名称是否重复
newCtx = newContext(group, filterName(name, handler), handler);
//双向链表中增加ChannelHandlerContext
addLast0(newCtx);
// If the registered is false it means that the channel was not registered on an eventLoop yet.
// In this case we add the context to the pipeline and add a task that will call
// ChannelHandler.handlerAdded(...) once the channel is registered.
if (!registered) {
newCtx.setAddPending();
callHandlerCallbackLater(newCtx, true);
return this;
}
EventExecutor executor = newCtx.executor();
if (!executor.inEventLoop()) {//判断是否在同一线程中
callHandlerAddedInEventLoop(newCtx, executor);
return this;
}
}
callHandlerAdded0(newCtx);
return this;
}
分析addLast方法代码可以看到，ChannelHandler的添加基本可以分为四步
1、验证ChannelHandler是否重复添加
我们看下checkMultiplicity方法的具体实现
private static void checkMultiplicity(ChannelHandler handler) {
if (handler instanceof ChannelHandlerAdapter) {
ChannelHandlerAdapter h = (ChannelHandlerAdapter) handler;
if (!h.isSharable() && h.added) {//如果该handler非共享且已经被添加
throw new ChannelPipelineException(
h.getClass().getName() +
" is not a @Sharable handler, so can't be added or removed multiple times.");
}
h.added = true;//添加过之后,修改标识
}
}
2、创建一个HandlerContext对象
我们之前说过netty会把一个channelhandler封装成一个ChannelHandlerContext对象，如下面代码所示
newCtx = newContext(group, filterName(name, handler), handler);
封装对象时，我们可以给要添加的channelhandler起一个名字，filterName方法可以判断该handler的命名是否重复
private String filterName(String name, ChannelHandler handler) {
if (name == null) {
return generateName(handler);//返回一个默认名称
}
checkDuplicateName(name);
return name;
}
checkDuplicateName方法会遍历链表中节点如果查询到有重复的name则会抛出异常
private void checkDuplicateName(String name) {
if (context0(name) != null) { //遍历节点,查找是否有重复name
throw new IllegalArgumentException("Duplicate handler name: " + name);
}
}
private AbstractChannelHandlerContext context0(String name) {
AbstractChannelHandlerContext context = head.next;
while (context != tail) {
if (context.name().equals(name)) {
return context;
}
context = context.next;
}
return null;
}
3、向链表中添加添加context
前面进行了一系列判断后，通过addLast0方法我们把ChannelHandlerContext添加到pipeline中的双向链表中
//相当于在tail节点前面插入一个节点，也就是addLast
private void addLast0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext prev = tail.prev;//拿到tail节点的前置节点
newCtx.prev = prev;//把当前context的前置节点置为 prev
newCtx.next = tail;//把当前context的后置节点置为tail
prev.next = newCtx;//把prev节点的后置节点置为context
tail.prev = newCtx;//把tail节点的前置节点置为context
}
addLast0内部实现很简单，就是在tail节点前面插入一个节点，也就是把该ChannelHandlerContext放在链表的最后。
4、调用回调方法，通知添加成功
这一步就是当ChannelHandler添加到Pipeline中时调用，通过callHandlerAdded()回调方法通知ChannelHandler添加成功，执行handlerAdded()方法；
首先判断当前线程与eventloop线程是否一致，不一致的话封装成task提交给eventloop线程，是同一线程直接执行callHandlerAdded0方法，我们看下方法具体实现
private void callHandlerAdded0(final AbstractChannelHandlerContext ctx) {
try {
ctx.callHandlerAdded();//调用callHandlerAdded回调方法
} catch (Throwable t) {
boolean removed = false;
try {
remove0(ctx);//如果出现异常的话，把该ctx删除
ctx.callHandlerRemoved();//调用callHandlerRemoved回调方法
removed = true;
} catch (Throwable t2) {
if (logger.isWarnEnabled()) {
logger.warn("Failed to remove a handler: " + ctx.name(), t2);
}
}
if (removed) {
fireExceptionCaught(new ChannelPipelineException(
ctx.handler().getClass().getName() +
".handlerAdded() has thrown an exception; removed.", t));
} else {
fireExceptionCaught(new ChannelPipelineException(
ctx.handler().getClass().getName() +
".handlerAdded() has thrown an exception; also failed to remove.", t));
}
}
}
final void callHandlerAdded() throws Exception {
// We must call setAddComplete before calling handlerAdded. Otherwise if the handlerAdded method generates
// any pipeline events ctx.handler() will miss them because the state will not allow it.
if (setAddComplete()) {//在添加handler之前，保证状态为可添加状态
handler().handlerAdded(this);
}
}
通过上面代码实现，我们就可以通过重写ChannelHandler的handlerAdded方法，执行一些当ChannelHandler添加到Pipeline中时需要触发的功能逻辑。
二、ChannelHandler的删除
ChannelHandler的删除主要是通过ChannelPipeline的remove方法来实现的
我们先看下remove方法源码具体实现
@Override
public final ChannelPipeline remove(ChannelHandler handler) {
remove(getContextOrDie(handler));//删除handler
return this;
}
private AbstractChannelHandlerContext remove(final AbstractChannelHandlerContext ctx) {
//不能删除头节点和尾节点
assert ctx != head && ctx != tail;
//加锁，保证线程安全
synchronized (this) {
remove0(ctx);//在链表中删除context对象
// If the registered is false it means that the channel was not registered on an eventloop yet.
// In this case we remove the context from the pipeline and add a task that will call
// ChannelHandler.handlerRemoved(...) once the channel is registered.
//这里主要判断下该pipline对应channel是否已经注册到eventloop上
if (!registered) {
callHandlerCallbackLater(ctx, false);
return ctx;
}
EventExecutor executor = ctx.executor();
if (!executor.inEventLoop()) {//判断是否在同一线程中
executor.execute(new Runnable() {
@Override
public void run() {
callHandlerRemoved0(ctx);
}
});
return ctx;
}
}
//调用回调方法，通知handler已删除
callHandlerRemoved0(ctx);
return ctx;
}
删除操作整个流程与添加类似
1、获取ChannelHandlerContext对象
//根据传入的handler拿到其包装的ChannelHandlerContext对象
private AbstractChannelHandlerContext getContextOrDie(ChannelHandler handler) {
//根据context方法从链表中获取该handler的ChannelHandlerContext对象
AbstractChannelHandlerContext ctx = (AbstractChannelHandlerContext) context(handler);
if (ctx == null) {
throw new NoSuchElementException(handler.getClass().getName());
} else {
return ctx;
}
}
@Override
public final ChannelHandlerContext context(ChannelHandler handler) {
if (handler == null) {
throw new NullPointerException("handler");
} AbstractChannelHandlerContext ctx = head.next;
//遍历链表拿到该handler封装的ChannelHandlerContext对象
for (;;) { if (ctx == null) {
return null;
} if (ctx.handler() == handler) {
return ctx;
} ctx = ctx.next;
}
}
2、判断是否是首尾节点
首先判断删除的节点既不是头节点也不是尾节点
//不能删除头节点和尾节点
assert ctx != head && ctx != tail;
3、执行删除操作
然后通过remove0方法删除指定Context节点
private static void remove0(AbstractChannelHandlerContext ctx) {
AbstractChannelHandlerContext prev = ctx.prev;//获取当前节点的前置节点
AbstractChannelHandlerContext next = ctx.next;//获取当前节点的后置节点
prev.next = next;//把prev后置节点设置为next
next.prev = prev;//把next前置节点设置为prev
}
4、调用回调方法，通知删除成功
同样会判断当前线程与eventloop线程是否一致，不一致的话封装成task提交给eventloop线程
EventExecutor executor = ctx.executor();
if (!executor.inEventLoop()) {//判断是否在同一线程中
executor.execute(new Runnable() {
@Override
public void run() {
callHandlerRemoved0(ctx);
}
});
return ctx;
}
//调用回调方法，通知handler已删除
callHandlerRemoved0(ctx);
调用callHandlerRemoved()回调方法，通知触发handlerRemoved删除成功。
private void callHandlerRemoved0(final AbstractChannelHandlerContext ctx) {
// Notify the complete removal.
try {
ctx.callHandlerRemoved();//调用ctx中的回调方法
} catch (Throwable t) {
fireExceptionCaught(new ChannelPipelineException(
ctx.handler().getClass().getName() + ".handlerRemoved() has thrown an exception.", t));
}
}
final void callHandlerRemoved() throws Exception {
try {
// Only call handlerRemoved(...) if we called handlerAdded(...) before.
if (handlerState == ADD_COMPLETE) {
handler().handlerRemoved(this);//通知handler删除成功事件
}
} finally {
// Mark the handler as removed in any case.
setRemoved();
}
}
三、总结
通过上面的内容，我们梳理了channelHandler被封装成ChannelHandlerContext对象后，基于ChannelPipeline的双向链表的添加和删除操作，整个流程还是比较简单清晰的。其中如有不足与不正确的地方还望指出与海涵
关注微信公众号，查看更多技术文章。