netty总体架构图

原创

mob649e81583204 2024-11-06 08:31:08 ©著作权

©著作权归作者所有：来自51CTO博客作者mob649e81583204的原创作品，请联系作者获取转载授权，否则将追究法律责任

Netty 总体架构解析与示例

Netty 是一个高性能的网络通信框架，它为 Java 网络编程提供了简单、易用的 API。Netty 的设计旨在帮助开发人员更高效地构建高性能的网络应用，尤其是客户端和服务器应用。这篇文章将深入探讨 Netty 的总体架构，并提供一个基本的示例，以帮助您更好地理解它的内部工作原理。

Netty 的总体架构

Netty 的核心组件主要分为以下几部分：

Bootstrap - 用于设置服务端或客户端的引导，配置相关参数。
EventLoop - 负责处理 I/O 操作的线程，管理 Channel 的生命周期。
Channel - 表示网络连接，它是 Netty 中最主要的对象。
Pipeline - 处理传入或传出的通道数据的处理链。
Handler - 用于对 Channel 的请求和响应进行处理，业务逻辑的具体实现。
ByteBuf - Netty 提供的高效缓冲区，替代传统的 Java NIO ByteBuffer。

以下是 Netty 的总体架构图，它展示了这些组件如何协同工作：

graph TD;
    A[Bootstrap] -->|start| B(EventLoop)
    B --> C[Channel]
    C --> D(Pipeline)
    D --> E[Handler]
    B --> F[Socket]
    C --> G[ByteBuf]

代码示例

为了更好地理解 Netty 的工作机制，下面是一个简单的 Netty 服务端和客户端示例。

服务端实现

以下是一个基本的 HTTP 服务端示例，服务端监听在 8080 端口，并返回一个简单的文本响应。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.*;

public class NettyHttpServer {

    private final int port;

    public NettyHttpServer(int port) {
        this.port = port;
    }

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new HttpServerInitializer());

            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new NettyHttpServer(8080).start();
    }
}

HTTP 处理器

接下来，我们需要实现一个处理器来处理客户端的 HTTP 请求。

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpResponseEncoder;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.http.HttpVersion;
import io.netty.handler.codec.http.HttpResponseStatus;

public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new HttpServerCodec());
        pipeline.addLast(new HttpObjectAggregator(10 * 1024 * 1024));
        pipeline.addLast(new HttpRequestHandler());
    }
}

class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) {
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        response.content().writeBytes("Hello, World!".getBytes());
        ctx.writeAndFlush(response);
    }
}

客户端实现

下面是一个简单的 HTTP 客户端示例，它发送请求并打印响应。

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.DefaultFullHttpRequest;
import io.netty.handler.codec.http.HttpResponse;

public class NettyHttpClient {

    public void sendRequest(String host, int port) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                     .channel(NioSocketChannel.class)
                     .handler(new HttpClientInitializer());

            ChannelFuture future = bootstrap.connect(host, port).sync();
            FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpRequest.Method.GET, "/");
            future.channel().writeAndFlush(request);
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new NettyHttpClient().sendRequest("localhost", 8080);
    }
}

序列图

在整个请求/响应过程中的顺序如下所示：

sequenceDiagram
    participant Client
    participant Server
    Client->>Server: HTTP Request
    Server->>Client: HTTP Response

旅行图

以下是对 Netty 应用程序的一个简单旅行图，描述了高层次的工作流：

journey
    title Client-Server Communication
    section Initialization
      Client sends a request: 5: Client
    section Processing
      Server receives request: 5: Server
      Server processes request: 5: Server
      Server sends response: 5: Server
    section Completion
      Client receives response: 5: Client