如何搭建Netty服务器？

Netty服务器搭建

Netty是一个基于Java NIO的异步事件驱动的网络应用框架，旨在快速开发可维护的高性能协议服务器和客户端，本文将详细介绍如何使用Netty搭建一个基本的HTTP服务器，并解释其核心概念与实现步骤。

一、准备工作

在开始之前，需要创建一个Maven项目，并在pom.xml中添加Netty的依赖：

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.52.Final</version>
</dependency>

二、服务端启动类

1. 创建引导器（Bootstrap）

Netty中的ServerBootstrap类是服务器端的引导程序，用于配置服务器的各项参数并启动服务器。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;
public class HttpServer {
    private final int port;
    public HttpServer(int port) {
        this.port = port;
    }
    public static void main(String[] args) throws Exception {
        int port = 8088; // 默认端口号
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        }
        new HttpServer(port).start();
    }
    public void start() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // 处理连接请求的线程组
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 处理业务逻辑的线程组
        try {
            ServerBootstrap b = new ServerBootstrap(); // 创建引导器
            b.group(bossGroup, workerGroup) // 设置线程组
                .channel(NioServerSocketChannel.class) // 设置通道类型
                .childHandler(new ChannelInitializer<SocketChannel>() { // 绑定业务逻辑处理器
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast("decoder", new HttpRequestDecoder()) // 添加HTTP解码处理器
                            .addLast("encoder", new HttpResponseEncoder()) // 添加HTTP编码处理器
                            .addLast("aggregator", new HttpObjectAggregator(512 * 1024)) // 添加HTTP消息聚合处理器
                            .addLast("handler", new HttpHandler()); // 添加自定义业务逻辑处理器
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 128) // 设置TCP参数
                .childOption(ChannelOption.SO_KEEPALIVE, true); // 保持连接活跃
            // 绑定端口并启动服务器
            ChannelFuture f = b.bind(port).sync();
            System.out.println("HTTP服务器启动成功，监听端口：" + port);
            f.channel().closeFuture().sync(); // 等待服务器关闭
        } finally {
            workerGroup.shutdownGracefully(); // 优雅关闭工作线程组
            bossGroup.shutdownGracefully(); // 优雅关闭主线程组
        }
    }
}

上述代码中，我们首先创建了两个EventLoopGroup，分别用于处理连接请求和业务逻辑，然后通过ServerBootstrap配置服务器的通道类型、业务逻辑处理器以及TCP参数，绑定端口并启动服务器。

2. 配置线程模型

Netty支持三种Reactor线程模型：单线程模型、多线程模型和主从多线程模型，这里我们使用的是主从多线程模型，其中Boss线程组负责接受连接，Worker线程组负责处理业务逻辑。

EventLoopGroup bossGroup = new NioEventLoopGroup(); // 主线程组
EventLoopGroup workerGroup = new NioEventLoopGroup(); // 从线程组

3. 设置通道类型

Netty提供了多种类型的通道实现类，如NioServerSocketChannel、EpollServerSocketChannel等，这里我们使用NioServerSocketChannel作为服务器端的通道类型。

b.group(bossGroup, workerGroup) // 设置线程组
    .channel(NioServerSocketChannel.class); // 设置通道类型

4. 注册业务逻辑处理器

通过ChannelPipeline注册多个ChannelHandler，每个ChannelHandler各司其职，实现最大化的代码复用，这里我们使用了HttpRequestDecoder、HttpResponseEncoder、HttpObjectAggregator和自定义的HttpHandler。

ch.pipeline().addLast("decoder", new HttpRequestDecoder()) // HTTP请求解码器
    .addLast("encoder", new HttpResponseEncoder()) // HTTP响应编码器
    .addLast("aggregator", new HttpObjectAggregator(512 * 1024)) // HTTP消息聚合器
    .addLast("handler", new HttpHandler()); // 自定义业务逻辑处理器

5. 设置TCP参数并绑定端口

b.option(ChannelOption.SO_BACKLOG, 128) // 设置TCP参数
    .childOption(ChannelOption.SO_KEEPALIVE, true); // 保持连接活跃
// 绑定端口并启动服务器
ChannelFuture f = b.bind(port).sync();
System.out.println("HTTP服务器启动成功，监听端口：" + port);

三、自定义业务逻辑处理器

自定义的业务逻辑处理器需要继承SimpleChannelInboundHandler或实现ChannelInboundHandler接口，并重写相应的方法来处理HTTP请求和响应。

import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;
public class HttpHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest msg) throws Exception {
        // 生成响应内容
        String responseContent = "Hello, Netty!";
        byte[] bytes = responseContent.getBytes(CharsetUtil.UTF_8);
        DefaultFullHttpResponse response = new DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK);
        response.content().writeBytes(bytes);
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8");
        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes());
        // 将响应写入到ChannelPipeline中
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

上述代码中，我们创建了一个自定义的HttpHandler类，继承自SimpleChannelInboundHandler，在channelRead0方法中，我们生成一个简单的HTTP响应，并通过ctx.writeAndFlush(response)将其发送给客户端，我们在exceptionCaught方法中处理异常情况，确保在发生错误时关闭连接。

四、测试HTTP服务器

完成上述步骤后，可以通过浏览器或终端向服务器发起HTTP请求进行测试，在浏览器中访问http://localhost:8088/test，如果一切正常，应该能看到返回的“Hello, Netty!”消息。

五、常见问题解答（FAQs）

问：为什么Netty要使用引导器模式？

答：Netty使用引导器模式主要是为了简化服务器和客户端的开发过程，引导器模式通过提供一个统一的配置入口点，使得开发者能够方便地设置各种参数、绑定业务逻辑处理器以及控制服务器的行为，这种设计不仅提高了代码的可读性和可维护性，还减少了重复代码的出现，提升了开发效率，引导器模式还允许开发者根据不同的需求灵活地调整服务器的配置，从而满足各种不同的应用场景，引导器模式在Netty中得到了广泛的应用和推崇。