Netty网络编程实战之搭建Netty服务器

<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.68.Final</version>
</dependency>

package com.guor.demo.netty;

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.nio.NioServerSocketChannel;

/**
 * 主程序类
 */
public class MyNettyServerTest {
    public static void main(String[] args) throws InterruptedException {
        /**
         * EventLoopGroup：事件循环组，是一个线程池，也是一个死循环，用于不断地接收用户请求；
         * serverGroup：用户监听及建立连接，并把每一个连接抽象为一个channel，最后再将连接交给clientGroup处理；
         * clientGroup：真正的处理连接
         */
        EventLoopGroup serverGroup = new NioEventLoopGroup();
        EventLoopGroup clientGroup = new NioEventLoopGroup();
        try {
            // 服务端启动时的初始化操作
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 1、将serverGroup和clientGroup注册到服务端的Channel上；
            // 2、注册一个服务端的初始化器MyNettyServerInitializer；
            // 3、该初始化器中的initChannel()方法会在连接被注册到Channel后立刻执行；
            // 5、最后将端口号绑定到8080；
            ChannelFuture channelFuture = serverBootstrap.group(serverGroup, clientGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new MyNettyServerInitializer()).bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        }catch (Exception e){
            System.out.println(e);
        }finally {
            serverGroup.shutdownGracefully();
            clientGroup.shutdownGracefully();
        }
    }
}

package com.guor.demo.netty;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;

/**
 * 初始化器
 */
public class MyNettyServerInitializer extends ChannelInitializer<SocketChannel> {

    // 连接被注册到Channel后，立刻执行此方法
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        ChannelPipeline pipeline = socketChannel.pipeline();
        // 加入netty提供的处理器
        pipeline.addLast("HttpServerCodec",new HttpServerCodec());
        // 增加自定义处理器MyNettyServerHandler，用于实际处理请求，并给出响应
        pipeline.addLast("MyNettyServerHandler",new MyNettyServerHandler());
    }
}

package com.guor.demo.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;

/**
 * 自定义处理器
 * Inbound代表"进入"的请求
 */
public class MyNettyServerHandler extends SimpleChannelInboundHandler<HttpObject> {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, HttpObject httpObject) throws Exception {
        // 定义响应的内容
        ByteBuf byteBuf = Unpooled.copiedBuffer("Hello Netty", CharsetUtil.UTF_8);
        DefaultFullHttpResponse defaultFullHttpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, byteBuf);
        defaultFullHttpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE,"text/plain");
        byteBuf.readableBytes();
        // 等响应返回给客户端
        channelHandlerContext.writeAndFlush(defaultFullHttpResponse);
    }
}

package com.guor.demo.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;

/**
 * 自定义处理器
 * Inbound代表"进入"的请求
 */
public class MyNettyServerHandler extends SimpleChannelInboundHandler<HttpObject> {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, HttpObject httpObject) throws Exception {
        // 定义响应的内容
        ByteBuf byteBuf = Unpooled.copiedBuffer("Hello Netty", CharsetUtil.UTF_8);
        DefaultFullHttpResponse defaultFullHttpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, byteBuf);
        defaultFullHttpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE,"text/plain");
        byteBuf.readableBytes();
        // 等响应返回给客户端
        channelHandlerContext.writeAndFlush(defaultFullHttpResponse);
    }

    /**
     * 增加新处理器时，触发此方法
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception{
        System.out.println("1、handlerAdded、增加了新的处理器");
        super.handlerAdded(ctx);
    }

    /**
     * 当通道被注册到一个事件循环组EventLoop上时，触发此方法
     */
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception{
        System.out.println("2、channelRegistered、通道被注册");
        super.channelRegistered(ctx);
    }

    /**
     * 当远端处于活跃状态时（连接到了某个远端，可以收发数据），执行此方法
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception{
        System.out.println("3、channelActive、通道连接到了远端，处于活跃状态");
        super.channelActive(ctx);
    }

    /**
     * 当通道处于非活跃状态时（与远端断开了连接），执行此方法
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception{
        System.out.println("4、channelInactive、通道远端断开了连接，处于非活跃状态");
        super.channelInactive(ctx);
    }

    /**
     * 当通道被取消了注册时，执行此方法
     */
    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception{
        System.out.println("5、channelUnregistered、通道被取消了注册");
        super.channelUnregistered(ctx);
    }

    /**
     * 当程序发生异常，执行此方法
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx,Throwable e) throws Exception{
        System.out.println("6、exceptionCaught、程序发生了异常");
        e.printStackTrace();
        ctx.close();
    }
}