How Netty Builds and Manages Its Channel Pipeline: Creation, Adding, and Destruction

Chain Creation Process

The responsibility chain is instantiated when a Channel is initialized. In AbstractChannel the constructor creates a DefaultChannelPipeline instance, which becomes the channel's pipeline.

<code>// 责任链的创建是在Channel的初始化的时候进行的
// AbstractChannel.java
protected AbstractChannel(Channel parent) {
    this.parent = parent;
    id = newId();
    unsafe = newUnsafe();
    pipeline = newChannelPipeline();
}

// 创建默认的责任链实例对象
protected DefaultChannelPipeline newChannelPipeline() {
    return new DefaultChannelPipeline(this);
}
</code>

The default pipeline class is DefaultChannelPipeline . Its constructor links a head and a tail context using a doubly‑linked list.

<code>// DefaultChannelPipeline.java
protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise = new VoidChannelPromise(channel, true);
    tail = new TailContext(this);
    head = new HeadContext(this);
    head.next = tail;
    tail.prev = head;
}
</code>

Both HeadContext and TailContext call setAddComplete() to mark their handlers as fully added, ensuring ordered execution of subsequent handlers.

Adding Handlers

Handlers are added via ChannelPipeline.addLast() . The method creates a new DefaultChannelHandlerContext , links it before the tail, and, if the channel is already registered, invokes the handler’s handlerAdded method immediately.

<code>@Override
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
    final AbstractChannelHandlerContext newCtx;
    synchronized (this) {
        checkMultiplicity(handler);
        newCtx = newContext(group, filterName(name, handler), handler);
        addLast0(newCtx);
        if (!registered) {
            newCtx.setAddPending();
            callHandlerCallbackLater(newCtx, true);
            return this;
        }
    }
    callHandlerAdded0(newCtx);
    return this;
}
</code>

During handlerAdded , the context calls setAddComplete() before invoking the handler’s own handlerAdded implementation.

Listening for Connection Events

The server’s NioServerSocketChannel runs an event‑loop that repeatedly calls select() and then processes ready keys. When an ACCEPT event is ready, the ServerBootstrapAcceptor adds a child channel’s handler to the child’s pipeline.

<code>void init(Channel channel) {
    ChannelPipeline p = channel.pipeline();
    p.addLast(new ChannelInitializer<Channel>() {
        @Override
        public void initChannel(final Channel ch) {
            final ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = config.handler();
            if (handler != null) {
                pipeline.addLast(handler);
            }
            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                        ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}
</code>

The acceptor’s channelRead method registers the new child channel and attaches the configured child handler.

<code>public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;
    child.pipeline().addLast(childHandler);
    setChannelOptions(child, childOptions, logger);
    setAttributes(child, childAttrs);
    try {
        childGroup.register(child).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (!future.isSuccess()) {
                    forceClose(child, future.cause());
                }
            }
        });
    } catch (Throwable t) {
        forceClose(child, t);
    }
}
</code>

Reading Requests

When a read‑ready key is detected, NioSocketChannel ’s unsafe read() method pulls bytes from the socket, fires channelRead and channelReadComplete events down the pipeline, and handles any exceptions.

<code>void read() {
    try {
        do {
            doReadBytes(byteBuff);
            pipeline.fireChannelRead(byteBuf);
        } while (continueReading());
        pipeline.fireChannelReadComplete();
        if (close) {
            closeOnRead(pipeline);
        }
    } catch (Throwable t) {
        handleReadException(pipeline, byteBuf, t, close, allocHandle);
    } finally {
        if (!readPending && !config.isAutoRead()) {
            removeReadOp();
        }
    }
}
</code>

Writing Data

Outbound data is written by invoking ctx.writeAndFlush(msg) inside a handler. The write propagates through the pipeline, ultimately reaching the HeadContext , which delegates to the channel’s unsafe write and flush methods.

<code>void invokeWriteAndFlush(Object msg, ChannelPromise promise) {
    if (invokeHandler()) {
        invokeWrite0(msg, promise);
        invokeFlush0();
    } else {
        writeAndFlush(msg, promise);
    }
}

private void invokeWrite0(Object msg, ChannelPromise promise) {
    try {
        ((ChannelOutboundHandler) handler()).write(this, msg, promise);
    } catch (Throwable t) {
        notifyOutboundHandlerException(t, promise);
    }
}

private void invokeFlush0() {
    try {
        ((ChannelOutboundHandler) handler()).flush(this);
    } catch (Throwable t) {
        notifyHandlerException(t);
    }
}
</code>

Channel and Handler Lifecycles

A channel progresses through creation, initialization, registration, event handling, and finally destruction when close() is called. The pipeline is torn down as part of the channel’s close operation, propagating channelInactive and cleanup events.

<code>// AbstractChannel.java (close path)
try {
    doClose0(promise);
} finally {
    invokeLater(new Runnable() {
        @Override
        public void run() {
            if (outboundBuffer != null) {
                outboundBuffer.failFlushed(cause, notify);
                outboundBuffer.close(closeCause);
            }
            fireChannelInactiveAndDeregister(wasActive);
        }
    });
}
</code>

Handlers follow a similar lifecycle: handlerAdded is invoked when the handler becomes part of the pipeline, and handlerRemoved is called during pipeline teardown. The internal state machine (INIT, ADD_PENDING, ADD_COMPLETE, REMOVE_COMPLETE) guarantees ordered execution.

In summary, Netty’s event‑driven architecture relies on a well‑structured responsibility chain that is created during channel construction, dynamically extended with handlers, and cleanly dismantled when the channel closes, ensuring deterministic processing of inbound and outbound events.