Netty学习总结第一篇：第一个Netty程序

应用场景

远程RPC过程调用协议，基于socket模式
长链接服务器，基于websocket模式
作为http服务器(并不遵循servlet标准)，tomcat、jetty的servlet服务器

环境准备

IntelliJ IDEA
gradle
JDK8
git地址：https://github.com/osxingzhe/netty_lecture

第一个netty程序

作为http，浏览器发送一个http请求，服务器处理，并返回一个hello world。
本次提交记录：4e0d67b42248799c9e36b840a24a141b7278e5e3
代码实例
TestServer.java 主方法入口类。

package pub.ants.netty.firstexample;

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;

/**
 * @author magw
 * @version 1.0
 * @date 2020/10/24 下午10:22
 * @description: No Description
 */
public class TestServer {

    public static void main(String[] args) throws InterruptedException {
        // 定义事件循环组,都是死循环
        // boosGroup处理连接，将连接传给workGroup
        EventLoopGroup boosGroup = new NioEventLoopGroup();
        // workGroup对连接进行处理
        EventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            // netty提供用于启动服务端类，轻松的启动服务端代码
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // netty中方法链
            serverBootstrap.group(boosGroup, workGroup)
                    // 管道，实例是用反射创建的
                    .channel(NioServerSocketChannel.class)
                    // 子处理器
                    .childHandler(new TestServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            // 优雅关机
            boosGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

TestServerInitializer.java 子处理器，可以添加netty本身处理器以及自定义的处理器。

package pub.ants.netty.firstexample;

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

/**
 * @author magw
 * @version 1.0
 * @date 2020/10/24 下午10:36
 * @description: No Description
 */
public class TestServerInitializer extends ChannelInitializer<SocketChannel> {

    /**
     * 连接被创建就初始化管道
     * @param ch
     * @throws Exception
     */
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        // 管道，不要使用单例，需要多实例
        // 添加netty、自定义的处理器
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast("httpServerCodec",new HttpServerCodec());
        pipeline.addLast("testServerHandler",new TestServerHandler());
    }
}

TestServerHandler.java 自定义处理器，接收客户端请求，并将hello返回客户端。

package pub.ants.netty.firstexample;

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;

/**
 * @author magw
 * @version 1.0
 * @date 2020/10/24 下午10:40
 * @description: No Description
 */
public class TestServerHandler extends SimpleChannelInboundHandler<HttpObject> {

    /**
     * 读取客户端发送过来的请求，并且向客户端返回响应的方法
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
        if (msg instanceof HttpRequest) {
            HttpRequest httpRequest = (HttpRequest) msg;
            System.out.println("请求方法名：" + httpRequest.method().name());
            String uri = httpRequest.uri();

            if ("/favicon.ico".equals(uri)) {
                System.out.println("请求favicon.ico");
                return;
            }

            // 构造返回对象需要使用byteBuf
            ByteBuf content = Unpooled.copiedBuffer("hello,world", CharsetUtil.UTF_8);
            // 构造响应内容
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);

            // 设置response的头信息
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");
            response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());

            // 写回客户端并刷新
            ctx.writeAndFlush(response);
        }
    }
}

验证

在游览器输入http://localhost:8899/，浏览器会显示hello,world；
用curl方式请求curl 'http://localhost:8899'，会打印hello,world。

步骤小结

netty采用两个事件循环组处理连接(bossGroup)和处理请求(workGroup)。
使用ServerBootStrap简化启动服务代码，同时采用链式流程将管道、子处理器加入(可使用netty和自定义处理器)，绑定端口，同步启动。
2.1 在添加自处理器时，也采用链式编程，将处理器加入
2.2 根据实际业务自定义处理器
优雅的关机

程序扩充

TestServerHandler继承的类中存在多个方法，我们进一步分析各个方法触发的时机，调用的基本逻辑和顺序。
示例代码
重写通道中的方法，查看调用顺序。

package pub.ants.netty.firstexample;

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;

/**
 * @author magw
 * @version 1.0
 * @date 2020/10/24 下午10:40
 * @description: No Description
 */
public class TestServerHandler extends SimpleChannelInboundHandler<HttpObject> {

    /**
     * 读取客户端发送过来的请求，并且向客户端返回响应的方法
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {

        // 打印msg类
        System.out.println(msg.getClass());
        // 打印远程的客户端地址
        System.out.println(ctx.channel().remoteAddress());

        Thread.sleep(20000);

        if (msg instanceof HttpRequest) {
            HttpRequest httpRequest = (HttpRequest) msg;
            System.out.println("请求方法名：" + httpRequest.method().name());
            String uri = httpRequest.uri();

            if ("/favicon.ico".equals(uri)) {
                System.out.println("请求favicon.ico");
                return;
            }

            // 构造返回对象需要使用byteBuf
            ByteBuf content = Unpooled.copiedBuffer("hello,world", CharsetUtil.UTF_8);
            // 构造响应内容
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);

            // 设置response的头信息
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");
            response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());

            // 写回客户端并刷新
            ctx.writeAndFlush(response);
            // 异步关闭通道
            ctx.channel().close();
        }
    }

    /**
     * 当通道活动的时候调用这个方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel channelActive");
        ctx.fireChannelActive();
    }

    /**
     * 当注册通道调用
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel channelRegistered");
        super.channelRegistered(ctx);
    }

    /**
     * 通道被添加
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel handlerAdded");
        super.handlerAdded(ctx);
    }

    /**
     * 通道处于不活动状态
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel channelInactive");
        super.channelInactive(ctx);
    }

    /**
     * 通道取消注册
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel channelUnregistered");
        super.channelUnregistered(ctx);
    }
}

小结

本篇我们基本了解使用netty怎样编写程序，用netty输出一个hello,world并不简单；我们分析channel的运行流程，基本了解各个方法在netty执行的时机。本篇是一个里程碑式的一篇，从本篇开始我们正式进入netty的学习。