Netty Channel 详解

原创 于 2025-06-22 15:30:18 发布 · 719 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#netty #channel

Netty的Channel未使用nio的实现，采用自定义实现。

Channel工作原理

Channel是Netty抽象出来的网络I/O读写相关的接口，为什么不使用JDKNIO原生的Channel而要另起炉灶呢，主要原因如下。

  • JDK的SocketChannel和ServerSocketChannel没有统一的Channel接口供业务开发者使用，对于用户而言，没有统一的操作视图，使用起来并不方便。
  • JDK的SocketChannel和ServerSocketChannel的主要职责就是网络I/O操作，由于它们是SPI类接口，由具体的虚拟机厂家来提供，所以通过继承SPI功能类来扩展其功能的难度很大；直接实现ServerSocketChannel和SocketChannel抽象类，其工作量和重新开发一个新的Channel功能类是差不多的。
  • Netty的Channel需要能够跟Netty的整体架构融合在一起，例如I/O模型、基于ChanneIPipeline的定制模型，以及基于元数据描述配置化的TCP参数等，这些JDK的SocketChannel和ServerSocketChannel都没有提供，需要重新封装。
  • 自定义的Channel，功能实现更加灵活。

基于上述4个原因，Netty重新设计了Channel接口，并且给予了很多不同的实现。它的设计原理比较简单，但是功能却比较繁杂，主要的设计理念如下。

  • 在Channel接口层，采用Facade模式进行统一封装，将网络I/O操作、网络I/O相关联的其他操作封装起来，统一对外提供。
  • Channel接口的定义尽量大而全，为SocketChannel和ServerSocketChannel提供统一的视图，由不同子类实现不同的功能，公共功能在抽象父类中实现，最大程度地实现功能和接口的重用。
  • 具体实现采用聚合而非包含的方式，将相关的功能类聚合在Channel中，由Channel统一负责分配和调度，功能实现更加灵活。

Channel的主要继承关系图

类图

image-20250609150156788

源码分析

公共接口

▶ AttributeMap

public interface AttributeMap {
    <T> Attribute<T> attr(AttributeKey<T> key);
    <T> boolean hasAttr(AttributeKey<T> key);
}

▶ ChannelOutboundInvoker

ChannelOutboundInvoker 是 Netty 中的一个关键接口，主要用于 定义出站（Outbound）操作的触发方法，即所有 从应用程序向网络发送数据 的操作（如写入数据、刷新缓冲区、关闭连接等）都通过该接口的方法发起。它是 Netty 异步事件驱动模型中 出站事件 的核心抽象。

ChannelOutboundInvoker 的主要用途：

(1) 统一出站操作的调用方式

  • 它为所有出站操作（如 write、flush、connect、disconnect、close 等）提供了统一的调用接口。
  • 无论是 Channel、ChannelPipeline 还是 ChannelHandlerContext，只要涉及出站操作，都会通过 ChannelOutboundInvoker 的方法触发。

(2) 支持链式调用和异步回调

  • 所有方法返回ChannelFuture，允许开发者：
    • 链式调用（如 write().flush().addListener(...)）。
    • 添加监听器（ChannelFutureListener）以在操作完成时得到通知（如数据发送完成、连接关闭等）。

(3) 解耦业务逻辑与底层 I/O 操作

  • 通过该接口，Netty 将 业务代码（如消息编码、发送逻辑）与 底层 I/O 操作（如 Socket 写入）解耦，使开发者无需直接操作 Socket，而是通过 Netty 的抽象方法完成数据发送。

实现类

▶ AbstractChannel

public abstract class AbstractChannel extends DefaultAttributeMap implements Channel {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractChannel.class);
	//父类 Channel
    private final Channel parent;
    //
    private final ChannelId id;
    //Unsafe实例；
    private final Unsafe unsafe;

	//当前Channel对应的DefaultChannelPipeline；
    private final DefaultChannelPipeline pipeline;
    private final VoidChannelPromise unsafeVoidPromise = new VoidChannelPromise(this, false);
    private final CloseFuture closeFuture = new CloseFuture(this);
	
    private volatile SocketAddress localAddress;
    private volatile SocketAddress remoteAddress;
    //当前Channel注册的EventLoop；
    private volatile EventLoop eventLoop;
    private volatile boolean registered;
    private boolean closeInitiated;
    private Throwable initialCloseCause;

    /** Cache for the string representation of this channel */
    private boolean strValActive;
    private String strVal;
}

▶ AbstractNioChannel

public abstract class AbstractNioChannel extends AbstractChannel {


	//NioSocketChannel和NioServerSocketChannel需要共用，所以定义 了一个java.nio.SocketChannel和 java.nio.ServerSocketChannel的公共父类SelectableChannel，用于设置SelectableChannel参数和进行I/O操作。
    private final SelectableChannel ch;
    //它代表了JDKSelectionKey的OP_READ
    protected final int readInterestOp;
    //Channel注册到 EventLoop后返回的选择键
    volatile SelectionKey selectionKey;
    boolean readPending;
    private final Runnable clearReadPendingRunnable = new Runnable() {
        @Override
        public void run() {
            clearReadPending0();
        }
    };

  	//连接结果
    private ChannelPromise connectPromise;
    //超时任务
    private ScheduledFuture<?> connectTimeoutFuture;
    private SocketAddress requestedRemoteAddress;
}

▶ AbstractNioByteChannel

扩展了继续写半包的能力。

public abstract class AbstractNioByteChannel extends AbstractNioChannel {
    private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);
    private static final String EXPECTED_TYPES =
            " (expected: " + StringUtil.simpleClassName(ByteBuf.class) + ", " +
            StringUtil.simpleClassName(FileRegion.class) + ')';
      // 负责继续写半包消息  最主要的方法就是doWrite（ChannelOutboundBufferin）
    private final Runnable flushTask = new Runnable() {
        @Override
        public void run() {
            ((AbstractNioUnsafe) unsafe()).flush0();
        }
    };
    
    
   protected final int doWrite0(ChannelOutboundBuffer in) throws Exception {
        Object msg = in.current();
        if (msg == null) {
            // Directly return here so incompleteWrite(...) is not called.
            return 0;
        }
        return doWriteInternal(in, in.current());
    }

    private int doWriteInternal(ChannelOutboundBuffer in, Object msg) throws Exception {
        if (msg instanceof ByteBuf) {
            ByteBuf buf = (ByteBuf) msg;
            // 检查 ByteBuf 中是否有可读字节
            if (!buf.isReadable()) {
                // 如果没有可读字节，从 ChannelOutboundBuffer 中移除该消息
                in.remove();
                return 0;
            }

            // 调用 doWriteBytes 方法将 ByteBuf 中的字节写入底层通道，并获取实际写入的字节数
            final int localFlushedAmount = doWriteBytes(buf);
            // 检查是否成功写入了字节
            if (localFlushedAmount > 0) {
                // 更新 ChannelOutboundBuffer 中消息的写入进度
                in.progress(localFlushedAmount);
                // 再次检查 ByteBuf 中是否还有可读字节
                if (!buf.isReadable()) {
                    // 如果没有可读字节，说明该消息已全部写入，从 ChannelOutboundBuffer 中移除该消息
                    in.remove();
                }
                // 返回 1 表示进行了一次写操作
                return 1;
            }
        } else if (msg instanceof FileRegion) {
            // 将消息强制转换为 FileRegion 类型
            FileRegion region = (FileRegion) msg;
            // 检查文件区域是否已经全部传输完成
            if (region.transferred() >= region.count()) {
                // 如果已经全部传输完成，从 ChannelOutboundBuffer 中移除该消息
                in.remove();
                // 返回 0 表示没有进行写操作
                return 0;
            }

            // 调用 doWriteFileRegion 方法将文件区域写入底层通道，并获取实际写入的字节数
            long localFlushedAmount = doWriteFileRegion(region);
            // 检查是否成功写入了字节
            if (localFlushedAmount > 0) {
                // 更新 ChannelOutboundBuffer 中消息的写入进度
                in.progress(localFlushedAmount);
                // 再次检查文件区域是否已经全部传输完成
                if (region.transferred() >= region.count()) {
                    // 如果已经全部传输完成，从 ChannelOutboundBuffer 中移除该消息
                    in.remove();
                }
                // 返回 1 表示进行了一次写操作
                return 1;
            }
        } else {
            // 正常情况下不会执行到这里，因为消息类型应该只可能是 ByteBuf 或 FileRegion
            // 如果出现其他类型，抛出错误
            throw new Error();
        }
        // 如果没有成功写入任何数据，返回 WRITE_STATUS_SNDBUF_FULL 表示尝试写入但未被操作系统接受
        return WRITE_STATUS_SNDBUF_FULL;
    }
    
}

▶ ChannelOutboundBuffer

▶ AbstractNioMessageChannel

public abstract class AbstractNioMessageChannel extends AbstractNioChannel {
    
    @Override
    protected void doWrite(ChannelOutboundBuffer in) throws Exception {
        final SelectionKey key = selectionKey();
        final int interestOps = key.interestOps();

        for (;;) {
            // 从ChannelOutboundBuffer中弹出一条消息进行处理
            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;
                //循环尝试写入消息，最多尝试 config().getWriteSpinCount() 次
                for (int i = config().getWriteSpinCount() - 1; i >= 0; i--) {
                    if (doWriteMessage(msg, in)) {
                        done = true;
                        break;
                    }
                }

                if (done) {
                      // 若消息成功写入，从 ChannelOutboundBuffer 中移除该消息
                    in.remove();
                } else {
                    // Did not write all messages.
                    // 若消息未成功写入，说明还有消息未完成写入。将写操作添加到 SelectionKey 的关注操作中
                    if ((interestOps & SelectionKey.OP_WRITE) == 0) {
                        key.interestOps(interestOps | SelectionKey.OP_WRITE);
                    }
                    break;
                }
            } catch (Exception e) {
                if (continueOnWriteError()) {
                    in.remove(e);
                } else {
                    throw e;
                }
            }
        }
    }

}

AbstractNioMessageChannel和AbstractNioByteChannel的消息发送实现比较相似，不同之处在于：一个发送的是ByteBuf或者FileRegion，它们可以直接被发送。另一个发送的则是POJO对象。

▶ NioServerSocketChannel

public class NioServerSocketChannel extends AbstractNioMessageChannel
                             implements io.netty.channel.socket.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();
    }
    
    
     protected void doBind(SocketAddress localAddress) throws Exception {
         //在JDK 7+上使用更高效的直接绑定API。
        if (PlatformDependent.javaVersion() >= 7) {
            javaChannel().bind(localAddress, config.getBacklog());
        } else {
            javaChannel().socket().bind(localAddress, config.getBacklog());
        }
    }   
    

    @Override
    protected int doReadMessages(List<Object> buf) throws Exception {
        // 尝试从当前的 ServerSocketChannel 接受一个新的客户端连接
        // SocketUtils.accept 是 Netty 提供的工具方法，用于处理客户端连接的接受操作
        SocketChannel ch = SocketUtils.accept(javaChannel());

        try {
            // 检查是否成功接受了一个新的客户端连接
            if (ch != null) {
                // 若成功接受连接，将其封装为 NioSocketChannel 实例
                // 构造函数传入当前的 NioServerSocketChannel 作为父通道，以及新接受的 SocketChannel
                //。buf 最终会在 AbstractNioMessageChannel（NioMessageUnsafe） 的 read 方法里被使用
                buf.add(new NioSocketChannel(this, ch));
                // 成功添加一个新连接，返回 1
                return 1;
            }
        } catch (Throwable t) {
            // 若在创建 NioSocketChannel 过程中发生异常，记录警告日志
            logger.warn("Failed to create a new channel from an accepted socket.", t);

            try {
                // 尝试关闭已接受的 SocketChannel，避免资源泄漏
                ch.close();
            } catch (Throwable t2) {
                // 若关闭 SocketChannel 时发生异常，记录警告日志
                logger.warn("Failed to close a socket.", t2);
            }
        }

        // 没有新连接或处理过程中出现异常，返回 0
        return 0;
    }    
}

▶ NioSocketChannel

Unsafe

Unsafe接口实际上是Channel接口的辅助接口，它不应该被用户代码直接调用。实际的**I/O读写**操作都是由Unsafe接口负责完成的。

Unsafe 是定义在Channel中的 非静态内部类，生命周期随Channel。

类继承图

image-20250615091744903

  • Channel.Unsafe
  • AbstractNioChannel.NioUnsafe：增加了几个接口
  • AbstractChannel.AbstractUnsafe
  • AbstractChannel.AbstractUnsafe
  • AbstractNioChannel.AbstractNioUnsafe
  • AbstractNioByteChannel.NioByteUnsafe
  • AbstractNioMessageChannel.NioMessageUnsafe
  • NioSocketChannel.NioSocketChannelUnsafe

源码分析

▶ Channel.Unsafe

public interface Channel {
    
interface Unsafe {
		//获取当前 Channel 的接收缓冲区分配器句柄，用于高效管理接收数据的 ByteBuf 分配（如动态调整缓冲区大小）
        RecvByteBufAllocator.Handle recvBufAllocHandle();
		//获取 Channel 绑定的本地地址（IP + 端口）。
        SocketAddress localAddress();
		//获取 Channel 连接的远程地址（IP + 端口）。
        SocketAddress remoteAddress();
		//将 Channel 注册到指定的 EventLoop（事件循环线程），用于后续 I/O 操作。
        void register(EventLoop eventLoop, ChannelPromise promise);
        void bind(SocketAddress localAddress, ChannelPromise promise);
        void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);
        void disconnect(ChannelPromise promise);
        void close(ChannelPromise promise);
        void closeForcibly();
        void deregister(ChannelPromise promise);
    	//开始读取数据（触发底层 Socket 的可读事件监听）。
        void beginRead();
    	//向 Channel 写入数据（消息），promise 用于异步通知写入结果。
        void write(Object msg, ChannelPromise promise);
		//刷新输出缓冲区，确保数据真正发送到网络（如 TCP 发送缓冲区）。
        void flush();
        ChannelPromise voidPromise();
        ChannelOutboundBuffer outboundBuffer();
    }
}

▶ AbstractNioChannel.NioUnsafe

public abstract class AbstractNioChannel{
        public interface NioUnsafe extends Unsafe {
        /**
         * Return underlying {@link SelectableChannel}
         */
        SelectableChannel ch();

        /**
         * Finish connect
         */
        void finishConnect();

        /**
         * Read from underlying {@link SelectableChannel}
         */
        void read();

        void forceFlush();
    }
}

▶ AbstractChannel.AbstractUnsafe

public abstract class AbstractChannel{
    protected abstract class AbstractUnsafe implements Unsafe {
                private volatile ChannelOutboundBuffer outboundBuffer = new ChannelOutboundBuffer(AbstractChannel.this);
        private RecvByteBufAllocator.Handle recvHandle;
        private boolean inFlush0;
        /** true if the channel has never been registered, false otherwise */
        private boolean neverRegistered = true;
        
    }
}

▶ AbstractNioChannel.AbstractNioUnsafe

public abstract class AbstractNioChannel{
     protected abstract class AbstractNioUnsafe extends AbstractUnsafe implements NioUnsafe {
         
	 }
}

▶ AbstractNioByteChannel.NioByteUnsafe

public abstract class AbstractNioByteChannel{
    protected class NioByteUnsafe extends AbstractNioUnsafe {
	}
}

▶ AbstractNioMessageChannel.NioMessageUnsafe

public abstract class AbstractNioMessageChannel{
    
//不是 静态内部类，随 channel的生命周期。
    private final class NioMessageUnsafe extends AbstractNioUnsafe {

        private final List<Object> readBuf = new ArrayList<Object>();

        @Override
        public void read() {
            assert eventLoop().inEventLoop();
            final ChannelConfig config = config();
            final ChannelPipeline pipeline = pipeline();
            final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
            allocHandle.reset(config);

            boolean closed = false;
            Throwable exception = null;
            try {
                try {
                    do {
                        int localRead = doReadMessages(readBuf);
                        if (localRead == 0) {
                            break;
                        }
                        if (localRead < 0) {
                            closed = true;
                            break;
                        }

                        allocHandle.incMessagesRead(localRead);
                    } while (allocHandle.continueReading());
                } catch (Throwable t) {
                    exception = t;
                }

                int size = readBuf.size();
                // 此处开始处理 pipeline。fireChannelRead
                for (int i = 0; i < size; i ++) {
                    readPending = false;
                    pipeline.fireChannelRead(readBuf.get(i));
                }
                readBuf.clear();
                allocHandle.readComplete();
                //pipeline
                pipeline.fireChannelReadComplete();

                if (exception != null) {
                    closed = closeOnReadError(exception);
					//pipeline
                    pipeline.fireExceptionCaught(exception);
                }

                if (closed) {
                    inputShutdown = true;
                    if (isOpen()) {
                        close(voidPromise());
                    }
                }
            } finally {
                // Check if there is a readPending which was not processed yet.
                // This could be for two reasons:
                // * The user called Channel.read() or ChannelHandlerContext.read() in channelRead(...) method
                // * The user called Channel.read() or ChannelHandlerContext.read() in channelReadComplete(...) method
                //
                // See https://github.com/netty/netty/issues/2254
                if (!readPending && !config.isAutoRead()) {
                    removeReadOp();
                }
            }
        }
    }
}

▶ NioSocketChannel.NioSocketChannelUnsafe

public class NioSocketChannel{
    private final class NioSocketChannelUnsafe extends NioByteUnsafe {
    }
}

核心类

ChannelOutboundBuffer

ChannelOutboundBuffer 是 Netty 用于管理 Channel 出站数据（待发送数据）的核心组件，主要功能包括：

  • 缓冲待发送的数据（如 write() 操作写入的消息）。
  • 跟踪数据的发送状态（已写入 Socket 但未确认、完全未发送等）。
  • 高效处理内存释放（避免内存泄漏）。
  • 支持批量刷新（flush() 操作）。

核心数据结构

数据存储结构

ChannelOutboundBuffer 使用 单向链表 存储待发送的数据条目（Entry），每个 Entry 包含：

static final class Entry {
    //定义一个静态常量对象池 RECYCLER，用于管理 Entry 对象的复用。对象池可以减少对象创建和销毁带来的性能开销
        private static final ObjectPool<Entry> RECYCLER = ObjectPool.newPool(new ObjectCreator<Entry>() {
            @Override
            public Entry newObject(Handle<Entry> handle) {
                return new Entry(handle);
            }
        });
		//用于管理 Entry 对象在对象池中的生命周期。Handle 提供了 recycle 方法，用于将对象返回到对象池以便复用。
        private final Handle<Entry> handle;
    	//指向下一个 Entry 对象的引用，用于构建单向链表结构，方便管理出站缓冲区中的消息条目。
        Entry next;
    //存储待发送的消息对象，类型为 Object，说明可以存储任意类型的消息
        Object msg;
    //存储多个 ByteBuffer 对象的数组，用于批量处理 NIO 缓冲区。
        ByteBuffer[] bufs;
    //单个 ByteBuffer 对象，用于存储单个 NIO 缓冲区
        ByteBuffer buf;
    //用于表示消息发送操作的异步结果。当消息发送完成或失败时，可以通过该对象通知调用者。
        ChannelPromise promise;
    //记录消息发送的进度，即已经发送的字节数
        long progress;
    //记录消息的总字节数
        long total;
    //记录待发送消息的总大小，包括消息本身的大小和额外开销。
        int pendingSize;
    //记录 ByteBuffer 的数量，初始值为 -1，表示尚未计算
        int count = -1;
    //布尔标志，用于表示该消息条目是否已被取消。
        boolean cancelled;
}
关键字段
// 链表头节点（已写入 Socket 但未确认的数据）
private Entry flushedEntry;

// 链表尾节点（最新写入但未刷新的数据）
private Entry unflushedEntry;

// 总待发送字节数（用于流量控制）
private long totalPendingSize;

// 是否已触发 flush 操作
private boolean flushed;
核心方法分析
添加数据（write 操作）

addMessage() / addFlush()

  • 功能：将待发送的消息（如 ByteBuf）添加到缓冲区。
  • 关键逻辑：
    • 创建新的 Entry 并插入链表尾部（unflushedEntry）。
    • 更新 totalPendingSize（用于流量控制）。
    • 如果未调用过 flush()，数据会暂存到 unflushedEntry 链表。
void addMessage(Object msg, int size, ChannelPromise promise) {
    Entry entry = Entry.newInstance(msg, size, totalPendingSize, promise);
    if (unflushedEntry == null) {
        unflushedEntry = entry;
    } else {
        flushedEntry.next = entry; // 插入到已刷新链表的尾部
    }
    totalPendingSize += size;
}
刷新数据（flush 操作）

flush()

  • 功能：将 unflushedEntry 中的数据移动到 flushedEntry 链表，准备写入 Socket。
  • 关键逻辑：
    • 将 unflushedEntry 链表的所有节点转移到 flushedEntry 链表。
    • 触发底层的 Channel 的 doWrite() 方法（实际写入 Socket）。
void flush() {
    if (unflushedEntry != null) {
        if (flushedEntry == null) {
            flushedEntry = unflushedEntry;
        } else {
            // 将 unflushedEntry 链表拼接到 flushedEntry 后面
            Entry tail = flushedEntry;
            while (tail.next != null) {
                tail = tail.next;
            }
            tail.next = unflushedEntry;
        }
        unflushedEntry = null;
        // 触发底层写入
        channel.flush0();
    }
}
数据写入 Socket（底层交互）

removeBytes()

  • 功能：在 Socket 成功写入数据后，从缓冲区移除已发送的数据（释放内存）。
  • 关键逻辑：
    • 根据实际写入的字节数，逐个释放 Entry 中的 ByteBuf。
    • 更新 totalPendingSize。
void removeBytes(long writtenBytes) {
    while (writtenBytes > 0) {
        Entry e = flushedEntry;
        if (e == null) break;
        long size = e.pendingSize;
        if (size <= writtenBytes) {
            // 整个 Entry 已发送完成，释放 ByteBuf
            ReferenceCountUtil.safeRelease(e.buf);
            flushedEntry = e.next;
            totalPendingSize -= size;
            writtenBytes -= size;
        } else {
            // 部分发送，更新 pendingSize
            e.pendingSize -= writtenBytes;
            totalPendingSize -= writtenBytes;
            writtenBytes = 0;
        }
    }
}

与 EventLoop 和 Socket 的协作

  1. 写入流程：
    • 用户调用 channel.write(msg) → 数据添加到 unflushedEntry。
    • 用户调用 channel.flush() → 数据移动到 flushedEntry，触发 doWrite()。
    • doWrite() 通过底层的 SocketChannel 写入数据，成功后调用 removeBytes()。
  2. 流量控制：
    • totalPendingSize：用于实现 写水位线（Write Buffer Water Mark）：
      • 如果 totalPendingSize 超过高水位线，Channel 会暂停写入（触发 channelWritabilityChanged 事件）。
      • 当数据被确认发送后（removeBytes()），水位线下降，恢复写入。
netty中的Channel详解
技术人集结地
04-10 123
是网络通信的核心抽象，代表了一个开放的连接（如Socket连接）或组件（如文件、设备），负责处理I/O操作（读、写、连接建立、关闭等）。它是Netty异步、事件驱动模型的基础，封装了底层传输细节（如NIO、OIO、Epoll等），提供统一的API。的事件处理机制，实现了高性能、高可扩展的网络编程。开发者需关注其生命周期、线程安全及资源管理，合理使用零拷贝、内存池等优化技术，可显著提升系统吞吐量和稳定性。是网络通信的核心抽象，通过统一的API屏蔽底层传输差异，结合。定义，状态迁移触发对应事件（通过。
netty三大件之Channel详解
zaltan_cgw的博客
03-15 4093
netty之Channel详解 先祭出netty的架构概况图 BIO传统的做法是，InputStream和OutputStream接口，一个字节一个字节的读取传输，读取完毕关闭连接。NIO跟BIO最大的区别是，NIO有管道（channel）的概念，开启一个管道，传送一批数据，管道里面的Selector充当列车的角色，这个列车来回传输数据。 我们先看一个接口Channel。 /** * A ne...
Netty组件Channel介绍
weixin_38598961的博客
04-16 3652
Netty组件Channel介绍
Netty入门-Channel
CherishL_的专栏
11-07 1121
Netty Channel
Netty-Channel架构体系源码解读
weixin_38166557的博客
07-17 297
全文围绕下图,Netty-Channel的简化版架构体系图展开,从顶层Channel接口开始入手,往下递进,闲言少叙,直接开撸 概述:　从图中可以看到,从顶级接口Channel开始,在接口中定义了一套方法当作规范，紧接着的是来两个抽象的接口实现类，在这个抽象类中对接口中的方法，进行了部分实现，然后开始根据不同的功能分支，分成服务端的Channel和客户端的Channel 回顾 Cha...
netty中的ChannelHandler
惜暮
01-16 1万+
本文主要介绍以下几个相关类： • ChannelPipeline • ChannelHandlerContext • ChannelHandler • Inbound vs outbound(入站和出站)接受客户端的连接和创建连接只是应用程序中的一步，更加重要的还是处理传入传出的数据。netty提供了强大的事件处理机制，允许用户自定义ChannelHandler的实现来处理数
netty学习笔记一
SAN_YUN的专栏
05-23 257
buffer channel A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind. channelHandler codec
Netty中的Channel
书唐瑞的博客
11-09 363
在JDK中就有Channel的概念了. 数据的读写都要通过Channel进行. 既然Netty是封装了JDK, 同样它也有自己的Channel. 一个是服务端Chanel(NioServerSocketChannel),另一个是客户端Channel(NioSocketChannel). NioServerSocketChannel负责监听客户端的Accpet事件,当发生此事件时.那么它什么时候?或...
Netty4详解二：开发第一个Netty应用程序
06-10
Netty基于NIO（非阻塞I/O）设计，通过EventLoop（事件循环）和Channel（通道）的概念实现了高效的网络通信。EventLoop负责处理I/O事件，而Channel则代表一个网络连接，用于读写数据。 开发Netty应用程序的第一步是...
Netty ByteBuf 详解：高性能数据缓冲区的全面介绍
微笑听雨
06-24 3299
Netty的ByteBuf是Netty的高性能数据缓冲区，是用于在网络应用中高效地处理字节的基础类。它是Java标准的java.nio.ByteBuffer的一个增强版本，具有更高的灵活性和性能。下面详细介绍ByteBuf的主要功能和使用方法。
netty系列之:netty中的Channel详解
程序那些事
08-06 1万+
Channel是连接ByteBuf和Event的桥梁，netty中的Channel提供了统一的API，通过这种统一的API，netty可以轻松的对接多种传输类型，如OIO，NIO等。今天本文将会介绍Channel的使用和Channel相关的一些概念。
netty系列之:netty中各不同种类的channel详解
程序那些事
03-16 5058
文章目录简介ServerChannel和它的类型Epoll和KqueueAbstractServerChannelServerSocketChannelServerDomainSocketChannelSctpServerChannelChannel和它的类型UnixChannelSctpChannelDatagramChannelDomainDatagramChannelDuplexChannelAbstractChannel总结 简介 channel是连接客户端和服务器端的桥梁，在netty中我们最常用
Netty网络编程（三）：Channel详解
热门推荐
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
01-13 1万+
Channel是连接ByteBuf和Event的桥梁，netty中的Channel提供了统一的API，通过这种统一的API，netty可以轻松的对接多种传输类型，如OIO，NIO等。今天本文将会介绍Channel的使用和Channel相关的一些概念。
Netty学习四:Channel
weixin_34216196的博客
12-17 402
1. Channel Channel是Netty的核心概念之一，它是Netty网络通信的主体，由它负责同对端进行网络通信、注册和数据操作等功能。 1.1 工作原理 如上图所示： 一旦用户端连接成功，将新建一个channel同该用户端进行绑定 channel从EventLoopGroup获得一个EventLoop，并注册到该EventLoop，channel生命周期内都和该EventLoop在一...
Netty Channel
最新发布
王小工小工历程
07-16 815
在Netty中，Channel是一个核心的概念，它代表了一个到远程节点的连接，可以是客户端到服务器的连接，也可以是两个节点之间的P2P（点对点）连接。在Netty中，Channel的实现类通常是与具体的网络协议和I/O操作相关的，比如NioSocketChannel和NioServerSocketChannel分别代表了基于NIO的客户端和服务器的Socket连接。Channel接口是Netty网络通信的主要抽象类，它封装了Java NIO的Channel提供的网络操作，如读、写、连接和绑定等。
Netty之Channel解读
一个菜鸡的博客
06-05 2746
思考下面的场景，4 个医生给人看病，每个病人花费 20 分钟，而且医生看病的过程中是以病人为单位的，一个病人看完了，才能看下一个病人。因此可以做如下优化，只有一开始，医生 2、3、4 分别要等待 5、10、15 分钟才能执行工作，但只要后续病人源源不断地来，他们就能够满负荷工作，并且处理病人的能力提高到了。connect 方法是异步的，意味着不等连接建立，方法执行就返回了。1 处返回的是 ChannelFuture 对象，它的作用是利用 channel() 方法来获取 Channel 对象。
Netty(预置的ChannelHandler和编解码器)
吃四碗饭的嘤嘤怪的博客
11-15 5290
通过SSL/TLS保护Netty应用程序     为了支持SSL/TLS，Java提供了javax.net.ssl包，它的SSLContext和SSLEngine类使得实现解密和加密相当简单直接。Netty通过一个名为SslHandler的ChannelHandler实现利用了这个API，其中SslHandler在内部使用SSLEngine来完成实际的工作。 Netty的OpenSSL/SSL...
Netty框架详解：从入门到精通
Pipeline模式是Netty的核心特性之一，可以理解为Channel的过滤器链。每个Channel有一个Pipeline，其中包含多个处理器（Handler）。这些处理器分别处理不同的ChannelEvent。事件沿着Pipeline传播，分为Upstream...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值