一、项目需求

1）服务端监听8001端口
2）客户端能发送消息给服务器
3）服务器可以返回消息给客户端

二、代码编辑

1、服务端

public class NettyServer {
    public static void main(String[] args) throws Exception {

        /*create boss group and worker group*/
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        /*both above all are thread group*/

        try{
            /*create initial object of server side*/
            ServerBootstrap bootstrap = new ServerBootstrap();
            /*setting initial parameter*/
            bootstrap.group(bossGroup,workerGroup)
                .channel(NioServerSocketChannel.class)
                /*setting connect limit num of thread queue*/
                .option(ChannelOption.SO_BACKLOG,128)
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    /*adding handler to pipeline*/
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new NettyServerHandler());
                    }
                }); /*setting handler of EventLoop of Worker Group*/
            System.out.println("Server is ready");
            /*start up service*/
            ChannelFuture cf = bootstrap.bind(8001).sync();
            /*listen closed channel event*/
            cf.channel().closeFuture().sync();
        }finally{
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

2、自定义服务端处理器

/**
	* Custom handler must extends some HandlerAdapter of netty library
	* @author 彭友聪
	*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**Read handler
	* we can gain the pipeline and channel from ChannelHandlerContext
	* msg is the data come from client
	* */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx = " + ctx);
        /*transform the msg into byte buf*/
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("client sent: " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("Address of Client: " + ctx.channel().remoteAddress());
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        /*write data into buf and flush*/
        /*we need to encode the msg we want to send*/
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello, Client~~~", CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.channel().close();
    }
}

4、客户端

public class NettyClient {
    public static void main(String[] args) throws Exception{
        /*client only need a event loop group*/
        EventLoopGroup eventExecutors = new NioEventLoopGroup();
        try{
            /*create start up assistant*/
            Bootstrap bootstrap = new Bootstrap();
            /*setting initial parameter*/
            bootstrap.group(eventExecutors)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new NettyClientHandler());
                    }
                });
            System.out.println("Client is ready~~~");
            ChannelFuture channelFuture = 
                bootstrap.connect("127.0.0.1", 8001).sync();
            channelFuture.channel().closeFuture().sync();
        }finally{
            eventExecutors.shutdownGracefully();
        }
    }
}

5、自定义客户端处理器

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client ctx=" + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello Netty Server!!", CharsetUtil.UTF_8));
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("from server: " + buf.toString(CharsetUtil.UTF_8));
        System.out.println("Server Address: " + ctx.channel().remoteAddress());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println(cause.getMessage());
        ctx.close();
    }
}

6、输出结果

Server is ready
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x97209815, L:/127.0.0.1:8001 - R:/127.0.0.1:50900])
client sent: Hello Netty Server!!
Address of Client: /127.0.0.1:50900

Client is ready~~~
client ctx=ChannelHandlerContext(NettyClientHandler#0, [id: 0xbdbdca5e, L:/127.0.0.1:50900 - R:/127.0.0.1:8001])
from server: Hello, Client~~~
Server Address: /127.0.0.1:8001

三、分析

1）bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数，默认是CPU核心数*2，循环分配
2）Netty 抽象出两组线程池，BossGroup 专门负责接受客户的连接，WorkerGroup负责网络读写操作
3）NioEventLoop 表示一个不断循环处理任务的线程，每个都含有用于监听绑定在其上的socket channel 的 selector
4）NioEventLoop 内部采用串行化设计，从消息的读取-》解码-》处理-》编码-》发送，始终由 IO 线程的 NioEventLoop 负责

1、Netty 的异步模型（ChannelFuture）

所谓异步，就是指调用异步方法后不会立即得到结果，而是先去执行其他任务，而等到实际处理这个调用的组件完成后，通过状态、通知和回调来通知调用者；Netty 的IO操作都是异步的，包括 Bind、Write和Connect 等操作会简单的返回一个ChannelFuture。

Netty 的异步模型，是建立在 future 和 callback 之上的，future 的核心思想是：假设一个方法的处理过程非常耗时，显然一直等待方法处理显然不合适，通常都会在调用该方法时立马返回一个future，后续可以通过该future去监控对应方法的处理进度，这就是 Netty 的 Future-Listener机制。
在这里插入图片描述