一、Channel介绍
Channel中的NioServerSocketChannel 和 NioSocketChannel 分别于 NIO中的 ServerSocketChannel、SocketChannel对应。不同的是，Netty的Channel将NIO中的Channel聚合在自己对象内部，并提供其他的功能操作。
二、Channel源码介绍
1. 常用方法介绍
| eventLoop() | Channel需要注册到EventLoop上的多路复用器上，通过该方法可获取到Channel注册的EventLoop（EventLoop本质就是处理网络读写事件的Reactor线程） |
| metadata() | 获取当前Channel的TCP参数配置 |
| parent() | 对于服务端而言，它的parent为空；对于客户端而言，它的父Channel就是创建它的ServerSocketChannel |
| id() | 获取Channel唯一标识对象 |
2. NioServerSocketChannel 和 NioSocketChannel 继承关系图
3. AbstractChannel源码分析
3.1 成员变量
private final Channel parent;//父类channel
private final ChannelId id; //Channel唯一标识
private final Unsafe unsafe;
private final DefaultChannelPipeline pipeline; // 当前Channel对应的默认的pipeline
private final VoidChannelPromise unsafeVoidPromise = new VoidChannelPromise(this, false);
private final CloseFuture closeFuture = new CloseFuture(this);
private volatile SocketAddress localAddress;
private volatile SocketAddress remoteAddress;
private volatile EventLoop eventLoop; //当前Channel绑定的EventLoop
private volatile boolean registered; //是否注册成功，在channelRegister(..)中被使用
private boolean closeInitiated;
private Throwable initialCloseCause;
/** Cache for the string representation of this channel */
private boolean strValActive;
private String strVal;
3.2 网络读写操作
Netty基于事件驱动，当Channel进行IO操作时会产生对应的IO事件，然后驱动事件在ChannelPipeline中传播，由对应的ChannelHandler对事件进行拦截处理。
@Override
public ChannelFuture connect(SocketAddress remoteAddress) {
return pipeline.connect(remoteAddress);
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
return pipeline.connect(remoteAddress, localAddress);
}
@Override
public ChannelFuture disconnect() {
return pipeline.disconnect();
} ...
4. AbstractNioChannel源码分析
4.1 成员变量
//由于NioServerSocketChannel和NioSocketChannel都继承了该类，所以让这里持有ServerSocketChannel和SocketChannel的父类，用于操作不同的Channel
private final SelectableChannel ch;
protected final int readInterestOp;//对应SeclectionKey.OP_READ
//Channel注册到EventLoop后返回的选择键，Channel会面临多线程操作，可能修改了SelectionKey，volitile保证其可见性
volatile SelectionKey selectionKey;
/**
* The future of the current connection attempt. If not null, subsequent
* connection attempts will fail.
*/
private ChannelPromise connectPromise;//连接操作结果
private ScheduledFuture<?> connectTimeoutFuture;//连接超时定时器
private SocketAddress requestedRemoteAddress;//请求通信地址信息
4.2 Channel注册
protected void doRegister() throws Exception {
boolean selected = false;//是否操作成功
for (;;) {
try {
// 调用SelectableChannel的register，将当前Channel注册到EventLoop的多路复用器上
// 这里注册的是0，表示不对任何事件感兴趣，只做注册操作
selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
return;
} catch (CancelledKeyException e) {
// 如果当前注册返回的SelectionKey已经被取消，则抛出CancelledKeyException
if (!selected) {
// 如果是第一次处理该异常，则将已经取消的SelectionKey从多路复用器上删除
eventLoop().selectNow();
selected = true;
} else {
// 第二次注册失败，而且没有取消的SelectionKey可以删除，不应该出现
throw e;
}
}
}
}
5. AbstractNioByteChannel源码分析
5.1 成员变量
// 负责继续写半包消息
private final Runnable flushTask = new Runnable() {
@Override
public void run() {
((AbstractNioUnsafe) unsafe()).flush0();
}
};
5.2 doWrite(...)
循环写，如果写完了则更新操作位后返回；如果指定循环次数没写完，或缓冲区写满了，则说明此次写了半包，注册写操作，继续写。
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
// 获取循环发送次数，默认16次
int writeSpinCount = config().getWriteSpinCount();
do {
// 从消息环形数组中弹出一条消息
Object msg = in.current();
if (msg == null) {
// 如果消息为空，说明所有消息发送数组中数据已发送完毕，清除半包标识，直接结束
clearOpWrite();
return;
}
// 还有待发送消息，继续处理并返回处理有效数（发送成功返回1，发送失败返回0）
writeSpinCount -= doWriteInternal(in, msg);
} while (writeSpinCount > 0);
// 写完后的操作，走到这里，说明in.current()依然还有值，还有数据没有发送完毕
incompleteWrite(writeSpinCount < 0);
}
// 清除写操作位
protected final void clearOpWrite() {
final SelectionKey key = selectionKey();
if (!key.isValid()) {
return;
}
final int interestOps = key.interestOps();
if ((interestOps & SelectionKey.OP_WRITE) != 0) {//说明是isWritable，需要清除写操作
key.interestOps(interestOps & ~SelectionKey.OP_WRITE);
}
}
private int doWriteInternal(ChannelOutboundBuffer in, Object msg) throws Exception {
if (msg instanceof ByteBuf) {
ByteBuf buf = (ByteBuf) msg;
if (!buf.isReadable()) {
in.remove();
return 0;
}
//进行消息发送，并返回发送了多少字节
final int localFlushedAmount = doWriteBytes(buf);
if (localFlushedAmount > 0) {
// 更新发送进度
in.progress(localFlushedAmount);
if (!buf.isReadable()) {//判断是否发送完成，完成则删除
in.remove();
}
return 1;
}
} else if (msg instanceof FileRegion) {
FileRegion region = (FileRegion) msg;
if (region.transferred() >= region.count()) {
in.remove();
return 0;
}
//进行消息发送
long localFlushedAmount = doWriteFileRegion(region);
if (localFlushedAmount > 0) {
in.progress(localFlushedAmount);
if (region.transferred() >= region.count()) {
in.remove();
}
return 1;
}
} else {
throw new Error();
}
// 写满了，无法再写了
return WRITE_STATUS_SNDBUF_FULL;//Integer.MAX_VALUE;
}
protected final void incompleteWrite(boolean setOpWrite) {
if (setOpWrite) {
// 还没彻底完成写操作，设置写操作
setOpWrite();
} else {
// 清除写操作位
clearOpWrite();
// 刷新计划，以便处理其他任务
eventLoop().execute(flushTask);
}
}
6. AbstractNioMessageChannel源码分析
6.1 该类无成员变量，主要实现方法只有一个：doWrite(..)
同样的，先获取数据，发送成功则删除，发送失败则设置半包标识，发送完了跳出循环。
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
final SelectionKey key = selectionKey();
final int interestOps = key.interestOps();
for (;;) {
Object msg = in.current();
if (msg == null) {
// Wrote all messages.
if ((interestOps & SelectionKey.OP_WRITE) != 0) {
key.interestOps(interestOps & ~SelectionKey.OP_WRITE);
}
break;
}
try {
boolean done = false;
for (int i = config().getWriteSpinCount() - 1; i >= 0; i--) {
// 发送消息并返回成功与否
if (doWriteMessage(msg, in)) {
done = true;
break;
}
}
if (done) {
// 发送成功则删除已发送部分
in.remove();
} else {
// 发送失败，设置半包标识
if ((interestOps & SelectionKey.OP_WRITE) == 0) {
key.interestOps(interestOps | SelectionKey.OP_WRITE);
}
break;
}
} catch (Exception e) {
if (continueOnWriteError()) {
in.remove(e);
} else {
throw e;
}
}
}
}
7. NioServerSocketChannel源码分析
7.1 成员变量 & 静态方法 & 构造方法
private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);
// 用于创建Channel和Selector的工厂类
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioServerSocketChannel.class);
public NioServerSocketChannel() {
this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}
// 打开ServerSocketChannel通道
private static ServerSocketChannel newSocket(SelectorProvider provider) {
try {
return provider.openServerSocketChannel();
} catch (IOException e) {
throw new ChannelException(
"Failed to open a server socket.", e);
}
}
// 用于配置ServerSocketChannel的TCP参数
private final ServerSocketChannelConfig config;
7.2 一些方法：这些方法都是获取ServerSocketChannel，然后使用它进行操作
@Override
public boolean isActive() {
// As java.nio.ServerSocketChannel.isBound() will continue to return true even after the channel was closed
// we will also need to check if it is open.
return isOpen() && javaChannel().socket().isBound();
}
@Override
public InetSocketAddress remoteAddress() {
return null;
}
@Override
protected ServerSocketChannel javaChannel() {
return (ServerSocketChannel) super.javaChannel();
}
@Override
protected SocketAddress localAddress0() {
return SocketUtils.localSocketAddress(javaChannel().socket());
}
@Override
protected void doBind(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
javaChannel().bind(localAddress, config.getBacklog());
} else {
javaChannel().socket().bind(localAddress, config.getBacklog());
}
}
@Override
protected void doClose() throws Exception {
javaChannel().close();
}
7.3 doMessageRead(..)
ServerSocketChannel接受新的客户端连接，如果SocketChannel不为空，则创建NioSocketChannel。
protected int doReadMessages(List<Object> buf) throws Exception {
// 接受客户端连接
SocketChannel ch = SocketUtils.accept(javaChannel());
try {
if (ch != null) {
// 将SocketChannel包装成NioSocketChannel
buf.add(new NioSocketChannel(this, ch));
return 1;
}
} catch (Throwable t) {
logger.warn("Failed to create a new channel from an accepted socket.", t);
try {
ch.close();
} catch (Throwable t2) {
logger.warn("Failed to close a socket.", t2);
}
}
return 0;
}
8. NioSocketChannel源码分析
8.1 连接操作：doConnect(..)
TCP连接操作，共三种情况：
1. 连接成功，返回连接成功；
2. 连接失败，关闭客户端连接；
3. 连接无响应，返回未连接成功，注册连接监听操作位。
protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
// 1. 本地Socket不为空，则绑定本地Socket
if (localAddress != null) {
doBind0(localAddress);
}
boolean success = false;
try {
// 2. 发起TCP连接
boolean connected = SocketUtils.connect(javaChannel(), remoteAddress);
if (!connected) {
// 2.1暂时未连接上，服务器无应答，不确定，注册监听操作
selectionKey().interestOps(SelectionKey.OP_CONNECT);
}
// 2.2 连接成功
success = true;
return connected;
} finally {
if (!success) {
// 3. 连接失败，关闭客户端连接
doClose();
}
}
}
private void doBind0(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
SocketUtils.bind(javaChannel(), localAddress);
} else {
SocketUtils.bind(javaChannel().socket(), localAddress);
}
}
8.2 写半包
doWrite(..)通过循环的方式发送数据：
1. 读完了，清除OP_WRITE标识，返回
2. 没读完，将数据放进ByteBuffer数组中，根据数组大小进行不同的处理：
2.1. 数组大小为0：还有一些其他的东西没写，调用AbstractNioByteChannel直接写
2.2. 数组大小为1：将ByteBuffer写进SocketChannel中，如果写成功了，动态调整下次ByteBuffer数组大小并删除已写数据；如果写失败了，说明缓冲区已满，加写半包标识
2.3. 数组大小大于1：将ByteBuffer数组写进SocketChannel中，如果写成功了，动态调整下次ByteBuffer数组大小，并删除已写数据；如果写失败了，说明缓冲区已满，加写半包标识
这里有个adjustMaxBytesPerGatheringWrite(..)，该方法的作用是，通过本次写入数据和待写入数据进行动态调整ByteBuffer大小：
1. 如果待写入数据等于写入数据，也就是说全写进去了，说明我设置的ByteBuffer大小优点保守，下次可以多写点，扩大每次写入的大小限制
2. 如果待写入数据大于已写入数据，也就是说没写完，分两种情况：
2.1 如果待写入数据比较大(大于4M)，并且本次写入的还没有我的一半多，那说明你每次写入的太少了，这样下去要写多少次才能完，直接扩大到我的一半，写快点
2.2 其他情况（数据并不大，或者一次性写入的挺多的），说明ByteBuffer大小正合适，不需要调整
protected void doWrite(ChannelOutboundBuffer in) throws Exception {
// 1 获取SocketChannel和默认循环发送次数
SocketChannel ch = javaChannel();
int writeSpinCount = config().getWriteSpinCount();
// 2. 循环发送数据
do {
if (in.isEmpty()) {
// 读完了，清除写半包标识，return掉
clearOpWrite();
return;
}
// 每次最多写多少，用以控制ByteBuffer大小
int maxBytesPerGatheringWrite = ((NioSocketChannelConfig) config).getMaxBytesPerGatheringWrite();
// in.nioBuffers(ByteBuffer数组最大容量, 每个ByteBuffer最大Max字节)
ByteBuffer[] nioBuffers = in.nioBuffers(1024, maxBytesPerGatheringWrite);
// 获取要发送的ByteBuffer数组个数nioBufferCnt
int nioBufferCnt = in.nioBufferCount();
switch (nioBufferCnt) {
case 0:
// 还有其他的东西待写，调用AbstractNioByteChannel进行写操作
writeSpinCount -= doWrite0(in);
break;
case 1: {
// 只有一个ByteBuffer，直接写
ByteBuffer buffer = nioBuffers[0];
int attemptedBytes = buffer.remaining();
final int localWrittenBytes = ch.write(buffer);
if (localWrittenBytes <= 0) {//缓冲区已满
incompleteWrite(true);
return;
}
// 动态调整下次的ByteBuffer容量，
adjustMaxBytesPerGatheringWrite(attemptedBytes, localWrittenBytes, maxBytesPerGatheringWrite);
in.removeBytes(localWrittenBytes);
--writeSpinCount;
break;
}
default: {
// 需要发送的总字节数
long attemptedBytes = in.nioBufferSize();
// ch.write(需要发送的ByteBuffer数组, 数组偏移量, 要发送的个数)，返回写入SocketChannel字节数
final long localWrittenBytes = ch.write(nioBuffers, 0, nioBufferCnt);
if (localWrittenBytes <= 0) {//缓冲区已满
incompleteWrite(true);
return;
}
// 根据本次写入情况动态调整下次写入数量
adjustMaxBytesPerGatheringWrite((int) attemptedBytes, (int) localWrittenBytes, maxBytesPerGatheringWrite);
in.removeBytes(localWrittenBytes);
--writeSpinCount;
break;
}
}
} while (writeSpinCount > 0);
incompleteWrite(writeSpinCount < 0);
}
// 动态调整每次发送数据的大小
private void adjustMaxBytesPerGatheringWrite(int attempted, int written, int oldMaxBytesPerGatheringWrite) {
if (attempted == written) {
// 数据全写进去了，说明缓冲区还挺大，一次性可以多写点，扩大一次性写入限制
if (attempted << 1 > oldMaxBytesPerGatheringWrite) {
((NioSocketChannelConfig) config).setMaxBytesPerGatheringWrite(attempted << 1);
}
} else if (attempted > MAX_BYTES_PER_GATHERING_WRITE_ATTEMPTED_LOW_THRESHOLD && written < attempted >>> 1) {
// MAX_BYTES_PER_GATHERING_WRITE_ATTEMPTED_LOW_THRESHOLD = 4096
// 本次写的少，数据又比较大，直接把最大限制设置为待写入数据的一半大
((NioSocketChannelConfig) config).setMaxBytesPerGatheringWrite(attempted >>> 1);
}
}