一、概要
上一篇把netty的基本思路介绍了一下，从这一篇文章开始我们将把netty的每一个组件分别进行拆解分析。针对核心的源码进行剖析。
本篇先重点分析下channel，netty的channel到底是一个什么样的概念。
二、channel是什么？
channel.png
channel代表的一个连接，每个client请求会对应到具体的一个channel。
我们可以看到channel对应有几个重要的组件。
- channelHandler
- channelHandlerContext
- channelPipeline
三、ChannelHandlerContext
ChannelHandlerContext维护ChannelHandler的上下文内容。
什么是上下文？
- 维护ChannelHandler的一些状态信息的存储
-
ChannelHandler之间互相通讯的桥梁(通过ChannelHandlerContext,我们可以把上一个ChannelHandler的处理结果传递给下一个ChannelHandler )
ChannelHandlerContext类图
DefaultChannelHandlerContext
final class DefaultChannelHandlerContext extends AbstractChannelHandlerContext {
private final ChannelHandler handler;
DefaultChannelHandlerContext(
DefaultChannelPipeline pipeline, EventExecutor executor, String name, ChannelHandler handler) {
super(pipeline, executor, name, handler.getClass());
this.handler = handler;
}
@Override
public ChannelHandler handler() {
return handler;
}
}
channelHandler是业务逻辑的核心处理类。
DefaultChannelHandlerContext会关联到一个唯一的ChannelHandler。
AbstractChannelHandlerContext
abstract class AbstractChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractChannelHandlerContext.class);
volatile AbstractChannelHandlerContext next;
volatile AbstractChannelHandlerContext prev;
我只截取了部分代码，可以看到AbstractChannelHandlerContext维护了一个双向链表，分别指向前后的两个结点。
接下来我们看next和prev这两个指针(虽然不是指针，但是作用跟C的指针的类似的)其实是通过DefaultChannelPipeline来进行维护的。
DefaultChannelPipeline
DefaultChannelPipeline类图
pipeline，顾名思义就是channel的管道。Pipeline把channelHandler和Context给连接起来。
/**
* The default {@link ChannelPipeline} implementation. It is usually created
* by a {@link Channel} implementation when the {@link Channel} is created.
*/
public class DefaultChannelPipeline implements ChannelPipeline {
...
...
//双向链表，维护了Context的首位指针
final AbstractChannelHandlerContext head;
final AbstractChannelHandlerContext tail;
//关联一个对应的channel
private final Channel channel;
...
//把context添加到链表的尾部
private void addLast0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext prev = tail.prev;
newCtx.prev = prev;
newCtx.next = tail;
prev.next = newCtx;
tail.prev = newCtx;
}
...
@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 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;
}
我们可以看到ChannelPipeline通过Context把ChannelHandler给连接起来。并且在添加Handler的时候会触发ChannelHandler.handlerAdded的方法。
ChannelHandler
ChannelHandler 有多个不同的实现类，最顶层的接口就是这个。
public interface ChannelHandler {
/**
* Gets called after the {@link ChannelHandler} was added to the actual context and it's ready to handle events.
*/
void handlerAdded(ChannelHandlerContext ctx) throws Exception;
/**
* Gets called after the {@link ChannelHandler} was removed from the actual context and it doesn't handle events
* anymore.
*/
void handlerRemoved(ChannelHandlerContext ctx) throws Exception;
/**
* Gets called if a {@link Throwable} was thrown.
*
* @deprecated if you want to handle this event you should implement {@link ChannelInboundHandler} and
* implement the method there.
*/
@Deprecated
void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;
/**
* Indicates that the same instance of the annotated {@link ChannelHandler}
* can be added to one or more {@link ChannelPipeline}s multiple times
* without a race condition.
* <p>
* If this annotation is not specified, you have to create a new handler
* instance every time you add it to a pipeline because it has unshared
* state such as member variables.
* <p>
* This annotation is provided for documentation purpose, just like
* <a href="http://www.javaconcurrencyinpractice.com/annotations/doc/">the JCIP annotations</a>.
*/
@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Sharable {
// no value
}
}
四、总结
本篇主要分析了一个Channel组成的核心组件有哪些，后面再对每一个组件做一一分析。
