Introduction to Netty

Netty is a high-performance, highly scalable asynchronous event-driven network application framework, which greatly simplifies network programming such as TCP and UDP client and server development.

Four important aspects of Netty:

1. Reactor threading model: a high-performance multi-threaded programming idea
2. Channel concept defined by Netty: enhanced channel concept
3. ChannelPipeline responsibility chain design pattern: event handling mechanism
4. Memory management: enhanced ByteBuf buffer

Netty overall structure diagram

Simple Netty example

/**
 * Echoes back any received data from a client.
 */
public final class EchoServer {
    static final int PORT = Integer.parseInt(System.getProperty("port", "8080"));

    public static void main(String[] args) throws Exception {
        // Configure the server.
        // Create EventLoopGroup accept thread group NioEventLoop
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        // Create EventLoopGroup I/O thread group
        EventLoopGroup workerGroup2 = new NioEventLoopGroup(1);
        try {
            // The server starts the boot tool class
            ServerBootstrap b = new ServerBootstrap();
            // Configure the reactor thread group processed by the server and other configurations of the server
            b.group(bossGroup, workerGroup2).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 100)
                    .handler(new LoggingHandler(LogLevel.DEBUG)).childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ChannelPipeline p = ch.pipeline();
                    p.addLast(new com.study.hc.net.netty.EchoServerHandler());
                }
            });
            // Start the service through bind
            ChannelFuture f = b.bind(PORT).sync();
            // Block the main thread, knowing that the network service is closed
            f.channel().closeFuture().sync();
        } finally {
            // Close the thread group
            bossGroup.shutdownGracefully();
            workerGroup2.shutdownGracefully();
        }
    }
}

Netty thread model

In order to make NIO processing better use of multi-threading features, Netty implements the Reactor threading model.

There are four core concepts in the Reactor model:

1. Resources (request/task)
2. Synchronous Event Demultipexer Synchronous Event Demultipexer
3. Dispatcher
4. Request Handler

EventLoopGriup initialization process

EventLoop start

EventLoop itself implements the Executor interface. When the executor method is called to submit a task, it is judged whether to start, and if it is started, the built-in executor is called to trigger the execution of the run method.

Bind binding port process

Channel concept

Channel in netty is an abstract concept, which can be understood as an enhancement and expansion of JDK NIO Channel. Many properties and methods have been added. For complete information, please refer to the code comments. Here are a few common properties and methods: