Netty源码分析之ChannelPipeline(二)—ChannelHandler的添加与删除
上篇文章中，我们对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的双向链表的添加和删除操作，整个流程还是比较简单清晰的。其中如有不足与不正确的地方还望指出与海涵
关注微信公众号，查看更多技术文章。
