高性能NIO框架Netty

旧城等待， 2022-05-22 10:12 221阅读 0赞

# Netty简介 #

Netty是基于Java NIO的网络应用框架.  
Netty是一个NIO client-server(客户端服务器)框架，使用Netty可以快速开发网络应用，例如服务器和客户端协议。Netty提供了一种新的方式来使开发网络应用程序，这种新的方式使得它很容易使用和有很强的扩展性。Netty的内部实现时很复杂的，但是Netty提供了简单易用的api从网络处理代码中解耦业务逻辑。Netty是完全基于NIO实现的，所以整个Netty都是异步的。  
网络应用程序通常需要有较高的可扩展性，无论是Netty还是其他的基于Java NIO的框架，都会提供可扩展性的解决方案。Netty中一个关键组成部分是它的异步特性.

# Netty代码示例 #

## 下载netty包 ##

下载netty包，下载地址[http://netty.io/][http_netty.io]

## 服务端启动类 ##

package cn.itcast_03_netty.sendstring.server;
    
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.Channel;
    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.nio.NioServerSocketChannel;
    import cn.itcast_03_netty.sendobject.coder.PersonDecoder;
    
    /** * • 配置服务器功能，如线程、端口 • 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么 * * @author wilson * */
    public class EchoServer { 
    
        private final int port;
    
        public EchoServer(int port) {
            this.port = port;
        }
    
        public void start() throws Exception {
            EventLoopGroup eventLoopGroup = null;
            try {
                //server端引导类
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                //连接池处理数据
                eventLoopGroup = new NioEventLoopGroup();
                //装配bootstrap
                serverBootstrap.group(eventLoopGroup)
                .channel(NioServerSocketChannel.class)//指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
                .localAddress("localhost",port)//设置InetSocketAddress让服务器监听某个端口已等待客户端连接。
                .childHandler(new ChannelInitializer<Channel>() {
       //设置childHandler执行所有的连接请求
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        ch.pipeline().addLast(new EchoServerHandler());//注册handler
                    }
                        });
                // 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
                ChannelFuture channelFuture = serverBootstrap.bind().sync();
                System.out.println("开始监听，端口为：" + channelFuture.channel().localAddress());
                channelFuture.channel().closeFuture().sync();
            } finally {
                eventLoopGroup.shutdownGracefully().sync();
            }
        }
    
        public static void main(String[] args) throws Exception {
            new EchoServer(20000).start();
        }
    }

## 服务端回调方法 ##

package cn.itcast_03_netty.sendstring.server;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelInboundHandlerAdapter;
    
    import java.util.Date;
    
    import cn.itcast_03_netty.sendobject.bean.Person;
    
    public class EchoServerHandler extends ChannelInboundHandlerAdapter { 
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg)
                throws Exception {
            System.out.println("server 读取数据……");
            //读取数据
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("接收客户端数据:" + body);
            //向客户端写数据
            System.out.println("server向client发送数据");
            String currentTime = new Date(System.currentTimeMillis()).toString();
            ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
            ctx.write(resp);
    
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            System.out.println("server 读取数据完毕..");
            ctx.flush();//刷新后才将数据发出到SocketChannel
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            cause.printStackTrace();
            ctx.close();
        }
    
    }

## 客户端启动类 ##

package cn.itcast_03_netty.sendstring.client;
    
    import io.netty.bootstrap.Bootstrap;
    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.NioSocketChannel;
    
    import java.net.InetSocketAddress;
    
    import cn.itcast_03_netty.sendobject.coder.PersonEncoder;
    
    /** * • 连接服务器 • 写数据到服务器 • 等待接受服务器返回相同的数据 • 关闭连接 * * @author wilson * */
    public class EchoClient { 
    
        private final String host;
        private final int port;
    
        public EchoClient(String host, int port) {
            this.host = host;
            this.port = port;
        }
    
        public void start() throws Exception {
            EventLoopGroup nioEventLoopGroup = null;
            try {
                // 客户端引导类
                Bootstrap bootstrap = new Bootstrap();
                // EventLoopGroup可以理解为是一个线程池，这个线程池用来处理连接、接受数据、发送数据
                nioEventLoopGroup = new NioEventLoopGroup();
                bootstrap.group(nioEventLoopGroup)//多线程处理
                        .channel(NioSocketChannel.class)//指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
                        .remoteAddress(new InetSocketAddress(host, port))//地址
                        .handler(new ChannelInitializer<SocketChannel>() {
       //业务处理类
                                    @Override
                                    protected void initChannel(SocketChannel ch)
                                            throws Exception {
                                        ch.pipeline().addLast(new EchoClientHandler());//注册handler
                                    }
                                });
                // 链接服务器
                ChannelFuture channelFuture = bootstrap.connect().sync();
                channelFuture.channel().closeFuture().sync();
            } finally {
                nioEventLoopGroup.shutdownGracefully().sync();
            }
        }
    
        public static void main(String[] args) throws Exception {
            new EchoClient("localhost", 20000).start();
        }
    }

## 客户端回调方法 ##

package cn.itcast_03_netty.sendstring.client;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.SimpleChannelInboundHandler;
    import cn.itcast_03_netty.sendobject.bean.Person;
    
    public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
        // 客户端连接服务器后被调用
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("客户端连接服务器，开始发送数据……");
            byte[] req = "QUERY TIME ORDER".getBytes();//消息
            ByteBuf firstMessage = Unpooled.buffer(req.length);//发送类
            firstMessage.writeBytes(req);//发送
            ctx.writeAndFlush(firstMessage);//flush
        }
    
        // • 从服务器接收到数据后调用
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
                throws Exception {
            System.out.println("client 读取server数据..");
            // 服务端返回消息后
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("服务端数据为 :" + body);
        }
    
        // • 发生异常时被调用
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            System.out.println("client exceptionCaught..");
            // 释放资源
            ctx.close();
        }
    }

测试：  
![这里写图片描述][70]

![这里写图片描述][70 1]

# Netty中handler的执行顺序 #

## 简介 ##

Handler在netty中，无疑占据着非常重要的地位。Handler与Servlet中的filter很像，通过Handler可以完成通讯报文的解码编码、拦截指定的报文、统一对日志错误进行处理、统一对请求进行计数、控制Handler执行与否。一句话，没有它做不到的只有你想不到的。

Netty中的所有handler都实现自ChannelHandler接口。按照输出输出来分，分为ChannelInboundHandler、ChannelOutboundHandler两大类。ChannelInboundHandler对从客户端发往服务器的报文进行处理，一般用来执行解码、读取客户端数据、进行业务处理等；ChannelOutboundHandler对从服务器发往客户端的报文进行处理，一般用来进行编码、发送报文到客户端。

Netty中，可以注册多个handler。ChannelInboundHandler按照注册的先后顺序执行；ChannelOutboundHandler按照注册的先后顺序逆序执行，如下图所示，按照注册的先后顺序对Handler进行排序，request进入Netty后的执行顺序为：  
![这里写图片描述][70 2]

## 代码 ##

### 服务端代码 ###

package cn.itcast_03_netty.sendorder.server;
    
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.Channel;
    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.nio.NioServerSocketChannel;
    import cn.itcast_03_netty.sendobject.coder.PersonDecoder;
    
    /** * • 配置服务器功能，如线程、端口 • 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么 * * @author wilson * */
    public class EchoServer { 
    
        private final int port;
    
        public EchoServer(int port) {
            this.port = port;
        }
    
        public void start() throws Exception {
            EventLoopGroup eventLoopGroup = null;
            try {
                //server端引导类
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                //连接池处理数据
                eventLoopGroup = new NioEventLoopGroup();
                serverBootstrap.group(eventLoopGroup)
                .channel(NioServerSocketChannel.class)//指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
                .localAddress("localhost",port)//设置InetSocketAddress让服务器监听某个端口已等待客户端连接。
                .childHandler(new ChannelInitializer<Channel>() {
       //设置childHandler执行所有的连接请求
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        // 注册两个InboundHandler，执行顺序为注册顺序，所以应该是InboundHandler1 InboundHandler2
                        // 注册两个OutboundHandler，执行顺序为注册顺序的逆序，所以应该是OutboundHandler2 OutboundHandler1
                        ch.pipeline().addLast(new EchoInHandler1());
                        ch.pipeline().addLast(new EchoInHandler2());
                        ch.pipeline().addLast(new EchoOutHandler1());
                        ch.pipeline().addLast(new EchoOutHandler2()); 
    
                    }
                        });
                // 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
                ChannelFuture channelFuture = serverBootstrap.bind().sync();
                System.out.println("开始监听，端口为：" + channelFuture.channel().localAddress());
                channelFuture.channel().closeFuture().sync();
            } finally {
                eventLoopGroup.shutdownGracefully().sync();
            }
        }
    
        public static void main(String[] args) throws Exception {
            new EchoServer(20000).start();
        }
    }

package cn.itcast_03_netty.sendorder.server;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelInboundHandlerAdapter;
    
    import java.util.Date;
    
    
    public class EchoInHandler2 extends ChannelInboundHandlerAdapter { 
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg)
                throws Exception {
            System.out.println("in2");
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("接收客户端数据:" + body);
            //向客户端写数据
            System.out.println("server向client发送数据");
            String currentTime = new Date(System.currentTimeMillis()).toString();
            ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
            ctx.write(resp);
    
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            ctx.flush();//刷新后才将数据发出到SocketChannel
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            cause.printStackTrace();
            ctx.close();
        }
    
    }

package cn.itcast_03_netty.sendorder.server;
    
    import java.util.Date;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelOutboundHandlerAdapter;
    import io.netty.channel.ChannelPromise;
    
    public class EchoOutHandler1 extends ChannelOutboundHandlerAdapter { 
        @Override
        // 向client发送消息
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            System.out.println("out1");
            /*System.out.println(msg);*/
    
            String currentTime = new Date(System.currentTimeMillis()).toString();
            ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
            ctx.write(resp);
            ctx.flush();
           }
    }

package cn.itcast_03_netty.sendorder.server;
    
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelOutboundHandlerAdapter;
    import io.netty.channel.ChannelPromise;
    
    public class EchoOutHandler2 extends ChannelOutboundHandlerAdapter { 
    
         @Override
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                System.out.println("out2");
                // 执行下一个OutboundHandler
                /*System.out.println("at first..msg = "+msg); msg = "hi newed in out2";*/
                super.write(ctx, msg, promise);
            }
    
    }

### 客户端代码 ###

package cn.itcast_03_netty.sendorder.client;
    
    import io.netty.bootstrap.Bootstrap;
    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.NioSocketChannel;
    
    import java.net.InetSocketAddress;
    
    
    /** * • 连接服务器 • 写数据到服务器 • 等待接受服务器返回相同的数据 • 关闭连接 * * @author wilson * */
    public class EchoClient { 
    
        private final String host;
        private final int port;
    
        public EchoClient(String host, int port) {
            this.host = host;
            this.port = port;
        }
    
        public void start() throws Exception {
            EventLoopGroup nioEventLoopGroup = null;
            try {
                // 客户端引导类
                Bootstrap bootstrap = new Bootstrap();
                // EventLoopGroup可以理解为是一个线程池，这个线程池用来处理连接、接受数据、发送数据
                nioEventLoopGroup = new NioEventLoopGroup();
                bootstrap.group(nioEventLoopGroup)//多线程处理
                        .channel(NioSocketChannel.class)//指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
                        .remoteAddress(new InetSocketAddress(host, port))//地址
                        .handler(new ChannelInitializer<SocketChannel>() {
       //业务处理类
                                    @Override
                                    protected void initChannel(SocketChannel ch)
                                            throws Exception {
                                        ch.pipeline().addLast(new EchoClientHandler());//注册handler
                                    }
                                });
                // 链接服务器
                ChannelFuture channelFuture = bootstrap.connect().sync();
                channelFuture.channel().closeFuture().sync();
            } finally {
                nioEventLoopGroup.shutdownGracefully().sync();
            }
        }
    
        public static void main(String[] args) throws Exception {
            new EchoClient("localhost", 20000).start();
        }
    }

package cn.itcast_03_netty.sendorder.client;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.SimpleChannelInboundHandler;
    
    public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
        // 客户端连接服务器后被调用
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            System.out.println("客户端连接服务器，开始发送数据……");
            byte[] req = "QUERY TIME ORDER".getBytes();//消息
            ByteBuf firstMessage = Unpooled.buffer(req.length);//发送类
            firstMessage.writeBytes(req);//发送
            ctx.writeAndFlush(firstMessage);//flush
        }
    
        // • 从服务器接收到数据后调用
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
                throws Exception {
            System.out.println("client 读取server数据..");
            // 服务端返回消息后
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("服务端数据为 :" + body);
        }
    
        // • 发生异常时被调用
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            System.out.println("client exceptionCaught..");
            // 释放资源
            ctx.close();
        }
    }

测试：  
![这里写图片描述][70 3]

![这里写图片描述][70 4]

## 总结 ##

在使用Handler的过程中，需要注意：  
1、ChannelInboundHandler之间的传递，通过调用 ctx.fireChannelRead(msg) 实现；调用ctx.write(msg) 将传递到ChannelOutboundHandler。  
2、ctx.write()方法执行后，需要调用flush()方法才能令它立即执行。  
3、流水线pipeline中outhandler不能放在最后，否则不生效  
4、Handler的消费处理放在最后一个处理。

# Netty发送对象 #

## 简介 ##

Netty中，通讯的双方建立连接后，会把数据按照ByteBuf的方式进行传输，例如http协议中，就是通过HttpRequestDecoder对ByteBuf数据流进行处理，转换成http的对象。基于这个思路，我自定义一种通讯协议：Server和客户端直接传输java对象。

实现的原理是通过Encoder把java对象转换成ByteBuf流进行传输，通过Decoder把ByteBuf转换成java对象进行处理，处理逻辑如下图所示：  
![这里写图片描述][70 5]

## 代码 ##

### Person类 ###

package cn.itcast_03_netty.sendobject.bean;
    
    import java.io.Serializable;
    
    public class Person implements Serializable { 
        private static final long serialVersionUID = 1L;
        private String name;
        private String sex;
        private int age;
    
        public String toString() {
            return "name:" + name + " sex:" + sex + " age:" + age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

### 对象序列化工具类 ###

package cn.itcast_03_netty.sendobject.coder;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.handler.codec.ByteToMessageDecoder;
    
    import java.util.List;
    
    import cn.itcast_03_netty.sendobject.utils.ByteBufToBytes;
    import cn.itcast_03_netty.sendobject.utils.ByteObjConverter;
    
     /** * 反序列化 * 将Byte[]转换为Object * @author wilson * */
    public class PersonDecoder extends ByteToMessageDecoder { 
        @Override
        protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
            //工具类：将ByteBuf转换为byte[]
            ByteBufToBytes read = new ByteBufToBytes();
            byte[] bytes = read.read(in);
            //工具类：将byte[]转换为object
            Object obj = ByteObjConverter.byteToObject(bytes);
            out.add(obj);
        }
    
    }

package cn.itcast_03_netty.sendobject.coder;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.handler.codec.MessageToByteEncoder;
    import cn.itcast_03_netty.sendobject.bean.Person;
    import cn.itcast_03_netty.sendobject.utils.ByteObjConverter;
     /** * 序列化 * 将object转换成Byte[] * @author wilson * */
    public class PersonEncoder extends MessageToByteEncoder<Person> { 
    
        @Override
        protected void encode(ChannelHandlerContext ctx, Person msg, ByteBuf out) throws Exception {
            //工具类：将object转换为byte[]
            byte[] datas = ByteObjConverter.objectToByte(msg);
            out.writeBytes(datas);
            ctx.flush();
        }
    }

package cn.itcast_03_netty.sendobject.utils;
    
    import io.netty.buffer.ByteBuf;
    
    public class ByteBufToBytes { 
        /** * 将ByteBuf转换为byte[] * @param datas * @return */
        public byte[] read(ByteBuf datas) {
            byte[] bytes = new byte[datas.readableBytes()];// 创建byte[]
            datas.readBytes(bytes);// 将ByteBuf转换为byte[]
            return bytes;
        }
    }

package cn.itcast_03_netty.sendobject.utils;
    
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class ByteObjConverter { 
        /** * 使用IO的inputstream流将byte[]转换为object * @param bytes * @return */
        public static Object byteToObject(byte[] bytes) {
            Object obj = null;
            ByteArrayInputStream bi = new ByteArrayInputStream(bytes);
            ObjectInputStream oi = null;
            try {
                oi = new ObjectInputStream(bi);
                obj = oi.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    oi.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return obj;
        }
        /** * 使用IO的outputstream流将object转换为byte[] * @param bytes * @return */
        public static byte[] objectToByte(Object obj) {
            byte[] bytes = null;
            ByteArrayOutputStream bo = new ByteArrayOutputStream();
            ObjectOutputStream oo = null;
            try {
                oo = new ObjectOutputStream(bo);
                oo.writeObject(obj);
                bytes = bo.toByteArray();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    bo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    oo.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return bytes;
        }
    }

### 服务端代码 ###

package cn.itcast_03_netty.sendobject.server;
    
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.Channel;
    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.nio.NioServerSocketChannel;
    import cn.itcast_03_netty.sendobject.coder.PersonDecoder;
    
    /** * • 配置服务器功能，如线程、端口 • 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么 * * @author wilson * */
    public class EchoServer { 
    
        private final int port;
    
        public EchoServer(int port) {
            this.port = port;
        }
    
        public void start() throws Exception {
            EventLoopGroup eventLoopGroup = null;
            try {
                //创建ServerBootstrap实例来引导绑定和启动服务器
                ServerBootstrap serverBootstrap = new ServerBootstrap();
                //创建NioEventLoopGroup对象来处理事件，如接受新连接、接收数据、写数据等等
                eventLoopGroup = new NioEventLoopGroup();
                //指定通道类型为NioServerSocketChannel，一种异步模式，OIO阻塞模式为OioServerSocketChannel
                //设置InetSocketAddress让服务器监听某个端口已等待客户端连接。
                serverBootstrap.group(eventLoopGroup).channel(NioServerSocketChannel.class).localAddress("localhost",port)
                .childHandler(new ChannelInitializer<Channel>() {
                    //设置childHandler执行所有的连接请求
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        //注册解码的handler
                        ch.pipeline().addLast(new PersonDecoder());  //IN1 反序列化
                        //添加一个入站的handler到ChannelPipeline 
                        ch.pipeline().addLast(new EchoServerHandler());   //IN2
                    }
                        });
                // 最后绑定服务器等待直到绑定完成，调用sync()方法会阻塞直到服务器完成绑定,然后服务器等待通道关闭，因为使用sync()，所以关闭操作也会被阻塞。
                ChannelFuture channelFuture = serverBootstrap.bind().sync();
                System.out.println("开始监听，端口为：" + channelFuture.channel().localAddress());
                channelFuture.channel().closeFuture().sync();
            } finally {
                eventLoopGroup.shutdownGracefully().sync();
            }
        }
    
        public static void main(String[] args) throws Exception {
            new EchoServer(20000).start();
        }
    }

package cn.itcast_03_netty.sendobject.server;
    
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelInboundHandlerAdapter;
    import cn.itcast_03_netty.sendobject.bean.Person;
    
    public class EchoServerHandler extends ChannelInboundHandlerAdapter { 
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg)
                throws Exception {
            Person person = (Person) msg;
            System.out.println(person.getName());
            System.out.println(person.getAge());
            System.out.println(person.getSex());
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
            System.out.println("server 读取数据完毕..");
            ctx.flush();//刷新后才将数据发出到SocketChannel
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            cause.printStackTrace();
            ctx.close();
        }
    
    }

### 客户端代码 ###

package cn.itcast_03_netty.sendobject.client;
    
    import io.netty.bootstrap.Bootstrap;
    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.NioSocketChannel;
    
    import java.net.InetSocketAddress;
    
    import cn.itcast_03_netty.sendobject.coder.PersonEncoder;
    
    /** * • 连接服务器 • 写数据到服务器 • 等待接受服务器返回相同的数据 • 关闭连接 * * @author wilson * */
    public class EchoClient { 
    
        private final String host;
        private final int port;
    
        public EchoClient(String host, int port) {
            this.host = host;
            this.port = port;
        }
    
        public void start() throws Exception {
            EventLoopGroup nioEventLoopGroup = null;
            try {
                // 创建Bootstrap对象用来引导启动客户端
                Bootstrap bootstrap = new Bootstrap();
                // 创建EventLoopGroup对象并设置到Bootstrap中，EventLoopGroup可以理解为是一个线程池，这个线程池用来处理连接、接受数据、发送数据
                nioEventLoopGroup = new NioEventLoopGroup();
                // 创建InetSocketAddress并设置到Bootstrap中，InetSocketAddress是指定连接的服务器地址
                bootstrap.group(nioEventLoopGroup)//
                        .channel(NioSocketChannel.class)//
                        .remoteAddress(new InetSocketAddress(host, port))//
                        .handler(new ChannelInitializer<SocketChannel>() {
       //
                                    // 添加一个ChannelHandler，客户端成功连接服务器后就会被执行
                                    @Override
                                    protected void initChannel(SocketChannel ch)
                                            throws Exception {
                                        // 注册编码的handler
                                        ch.pipeline().addLast(new PersonEncoder());  //out
                                        //注册处理消息的handler
                                        ch.pipeline().addLast(new EchoClientHandler());   //in
                                    }
                                });
                // • 调用Bootstrap.connect()来连接服务器
                ChannelFuture f = bootstrap.connect().sync();
                // • 最后关闭EventLoopGroup来释放资源
                f.channel().closeFuture().sync();
            } finally {
                nioEventLoopGroup.shutdownGracefully().sync();
            }
        }
    
        public static void main(String[] args) throws Exception {
            new EchoClient("localhost", 20000).start();
        }
    }

package cn.itcast_03_netty.sendobject.client;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.SimpleChannelInboundHandler;
    import cn.itcast_03_netty.sendobject.bean.Person;
    
    public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> { 
        // 客户端连接服务器后被调用
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
             Person person = new Person();
                person.setName("angelababy");
                person.setSex("girl");
                person.setAge(18);
                ctx.write(person);
                ctx.flush();
        }
    
        // • 从服务器接收到数据后调用
        @Override
        protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg)
                throws Exception {
            System.out.println("client 读取server数据..");
            // 服务端返回消息后
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("服务端数据为 :" + body);
        }
    
        // • 发生异常时被调用
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
            System.out.println("client exceptionCaught..");
            // 释放资源
            ctx.close();
        }
    }

测试：  
![这里写图片描述][70 6]

[http_netty.io]: http://netty.io/
[70]: /images/20220522/612c451eac784345b6192b70a991b92b.png
[70 1]: /images/20220522/c54b9eaf24d040b18b3758ac73c545d8.png
[70 2]: /images/20220522/0f64d5cdf2554f96a8545f38b45d7ce3.png
[70 3]: /images/20220522/27c50b87491d46f09d65796f720a6b0b.png
[70 4]: /images/20220522/2247095df60b4a559fa71d1fd1a2acee.png
[70 5]: /images/20220522/530d4ff9f261455b89904ad31e69f32d.png
[70 6]: /images/20220522/bed3585c852c40a9881663c27f24a547.png