Netty(一)核心概念

Netty介绍

Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。

Netty框架的组成

第一个Netty程序

服务器端

        /**
         * 服务端
         */
        public class Server {

            public static void main(String[] args) throws Exception {
                //1.创建两个线程组
                //用于处理服务器端接收客户端连接
                EventLoopGroup pGroup = new NioEventLoopGroup();
                //用于进行网络通信
                EventLoopGroup cGroup = new NioEventLoopGroup();

                try {
                    //2.创建辅助工具类，用于服务器通道的配置
                    ServerBootstrap b = new ServerBootstrap();
                    b.group(pGroup, cGroup) //绑定两个线程组
                        .channel(NioServerSocketChannel.class) //指定NIO模式
                        .option(ChannelOption.SO_BACKLOG, 1024) //设置tcp缓冲区
                        .option(ChannelOption.SO_SNDBUF, 32*1024) //设置发送缓冲大小
                        .option(ChannelOption.SO_RCVBUF, 32*1024) //设置接收缓冲大小
                        .option(ChannelOption.SO_KEEPALIVE, true) //保持连接
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                //3.配置接收方法的处理
                                sc.pipeline().addLast(new ServerHandler());
                            }
                        });

                    //4.进行绑定，调用sync()方法会阻塞直到服务器完成绑定
                    ChannelFuture cf = b.bind(9000).sync();
                    //5.等待关闭
                    cf.channel().closeFuture().sync();
                } finally {
                    //6.释放资源
                    pGroup.close();
                    cGroup.close();
                }
            }
        }

服务器业务逻辑

        /**
         * 服务器处理方法
         */
        public class ServerHandler extends ChannelHandlerAdapter{

            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                System.out.println("服务器通道激活...");
            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                ByteBuf buf = (ByteBuf) msg ;
                byte[] req = new byte[buf.readableBytes()];
                buf.readBytes(req);
                String body = new String(req,"utf-8");
                System.out.println("Server: " + body);
                String response = "返回给客户端的响应： " + body;
                ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
                System.out.println("读取数据完毕");
                ctx.flush();
            }

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


        }

Handler很简单，它的每个方法都可以被重写，它的所有的方法中只有channelRead方法是必须要重写的。
实现服务器步骤：
- 配置服务器功能，如线程、端口
- 实现服务器处理程序，它包含业务逻辑，决定当有一个请求连接或接收数据时该做什么

客户端

        /**
         * 客户端
         */
        public class Client {

            public static void main(String[] args) throws Exception {
                EventLoopGroup group = new NioEventLoopGroup();
                try {
                    Bootstrap b = new Bootstrap();
                    b.group(group)
                        .channel(NioSocketChannel.class)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                sc.pipeline().addLast(new ClientHandler());
                            }
                        });

                    ChannelFuture cf = b.connect("127.0.0.1",9000).sync();
                    //发送信息
                    cf.channel().writeAndFlush(Unpooled.copiedBuffer("hello server".getBytes()));

                    cf.channel().closeFuture().sync();
                } finally{
                    group.shutdownGracefully();
                }

            }
        }

客户端的业务逻辑

        /**
         * 客户端处理方法
         */
        public class ClientHandler extends ChannelHandlerAdapter{

            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {

            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                try {
                    ByteBuf buf = (ByteBuf) msg;
                    byte[] req = new byte[buf.readableBytes()];
                    buf.readBytes(req);
                    String body = new String(req,"utf-8");
                    System.out.println("Client: " + body);
                    String response = "服务器端返回信息： " + body;
                } finally {
                    ReferenceCountUtil.release(msg);
                }

            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

            }

            @Override
            public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

            }


        }

• channelActive()：客户端连接服务器后被调用
• channelRead()：从服务器接收到数据后调用
• exceptionCaught()：发生异常时被调用

Netty核心概念

• Bootstrap or ServerBootstrap
• EventLoop
• EventLoopGroup
• ChannelPipeline
• Channel
• Future or ChannelFuture
• ChannelInitializer
• ChannelHandler

ChannelInitializer

ChannelInitializer类用来配置Handlers。ChannelInitializer是通过ChannelPipeline来添加ChannelHandler的，如发送和接收消息，这些Handlers将确定发的是什么消息。ChannelInitializer自身也是一个ChannelHandler，在添加完其他的handlers之后会自动从ChannelPipeline中删除自己。

Future or ChannelFuture

Future注册一个监听，当操作成功或失败时会通知。ChannelFuture封装的是一个操作的相关信息，操作被执行时会立刻返回ChannelFuture。

Channel

EventLoop就是一个Channel执行实际工作的线程。EventLoop总是绑定一个单一的线程，在其生命周期内不会改变。当注册一个Channel后，Netty将这个Channel绑定到一个EventLoop，在Channel的生命周期内总是被绑定到一个EventLoop。

Bootstrap or ServerBootstrap

“引导”是Netty中配置程序的过程，当你需要连接客户端或服务器绑定指定端口时需要使用bootstrap。如前面所述，“引导”有两种类型，一种是用于客户端的Bootstrap(也适用于DatagramChannel)，一种是用于服务端的ServerBootstrap。
差异：
- Bootstrap用来连接远程主机，有1个EventLoopGroup
- ServerBootstrap用来绑定本地端口，有2个EventLoopGroup

第一个差异很明显，“ServerBootstrap”监听在服务器监听一个端口轮询客户端的“Bootstrap”或DatagramChannel是否连接服务器。通常需要调用“Bootstrap”类的connect()方法，但是也可以先调用bind()再调用connect()进行连接，之后使用的Channel包含在bind()返回的ChannelFuture中。
第二个差别也许是最重要的。客户端bootstraps/applications使用一个单例EventLoopGroup，而ServerBootstrap使用2个EventLoopGroup(实际上使用的是相同的实例)，它可能不是显而易见的，但是它是个好的方案。一个ServerBootstrap可以认为有2个channels组，第一组包含一个单例ServerChannel，代表持有一个绑定了本地端口的socket；第二组包含所有的Channel，代表服务器已接受了的连接。

EventLoop与EventLoopGroup

EventLoopGroup可以包含很多个EventLoop，每个Channel绑定一个EventLoop不会被改变，因为EventLoopGroup包含少量的EventLoop的Channels，很多Channel会共享同一个EventLoop。这意味着在一个Channel保持EventLoop繁忙会禁止其他Channel绑定到相同的EventLoop。我们可以理解为EventLoop是一个事件循环线程，而EventLoopGroup是一个事件循环集合。

ChannelPipeline与 ChannelHandler

ChannelPipeline的作用我们可以理解为用来管理ChannelHandler的一个容器，每个ChannelHandler处理各自的数据(例如入站数据只能由ChannelInboundHandler处理)，处理完成后将转换的数据放到ChannelPipeline中交给下一个ChannelHandler继续处理，直到最后一个ChannelHandler处理完成。
ChannelHandler是一段执行业务逻辑处理数据的代码，它们来来往往的通过ChannelPipeline。

当一个ChannelHandler添加到ChannelPipeline中时获得一个ChannelHandlerContext。通常是安全的获得这个对象的引用，但是当一个数据报协议如UDP时这是不正确的，这个对象可以在之后用来获取底层通道，因为要用它来read/write消息，因此通道会保留。
Netty中发送消息有两种方法：直接写入通道或写入ChannelHandlerContext对象。
这两种方法的主要区别如下：
- 直接写入通道导致处理消息从ChannelPipeline的尾部开始
- 写入ChannelHandlerContext对象导致处理消息从ChannelPipeline的下一个handler开始

拆包、黏包

粘包、拆包的解决方案：
1. 将消息分为消息头和消息体，在消息头中包含表示消息总长度的字段，然后进行业务逻辑处理。
2. 在包尾部添加特殊字符进行分隔，分隔符类DellmiterBasedFrameDecoder(自定义分隔符)。
3. 消息定长，如果不够，空位补空格，FixedLengthFrameDecoder(定长) 。

消息定长

服务端

        /**
         * 服务端
         */
        public class Server {

            public static void main(String[] args) throws Exception {
                //1.创建两个线程
                EventLoopGroup pGroup = new NioEventLoopGroup();
                EventLoopGroup cGroup = new NioEventLoopGroup();

                try {
                    //2.创建服务器辅助类
                    ServerBootstrap b = new ServerBootstrap();
                    b.group(pGroup, cGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG, 1024)
                        .option(ChannelOption.SO_SNDBUF, 32*1024)
                        .option(ChannelOption.SO_RCVBUF, 32*1024)
                        .option(ChannelOption.SO_KEEPALIVE, true)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                //设置定长字符串接收
                                sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
                                //设置字符串形式的解码
                                sc.pipeline().addLast(new StringDecoder());
                                sc.pipeline().addLast(new ServerHandler());
                            }
                        });

                    //绑定连接
                    ChannelFuture cf = b.bind(9002).sync();
                    //等待服务器监听端口关闭
                    cf.channel().closeFuture().sync();
                } finally {
                    pGroup.shutdownGracefully();
                    cGroup.shutdownGracefully();
                }
            }
        }

客户端

        /**
         * 客户端
         */
        public class Client {

            public static void main(String[] args) throws Exception {
                EventLoopGroup group = new NioEventLoopGroup();
                try {
                    Bootstrap b = new Bootstrap();
                    b.group(group)
                        .channel(NioSocketChannel.class)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
                                sc.pipeline().addLast(new StringDecoder());
                                sc.pipeline().addLast(new ClientHandler());
                            }
                        });
                    //绑定端口
                    ChannelFuture cf = b.connect("127.0.0.1",9002).sync();
                    cf.channel().writeAndFlush(Unpooled.wrappedBuffer("aaaaaabbbbbbb  ".getBytes()));
                    cf.channel().writeAndFlush(Unpooled.copiedBuffer("cccccc    ".getBytes()));

                    //等待客户端端口关闭
                    cf.channel().closeFuture().sync();
                } finally {
                    group.shutdownGracefully();
                }
            }
        }

服务端、客户端业务逻辑不变

尾部添加特殊字符

服务端

        /**
         * 服务端
         */
        public class Server {

            public static void main(String[] args) throws Exception {
                //1.创建两个线程
                //负责接收客户端的连接
                EventLoopGroup pGroup = new NioEventLoopGroup();
                //负责进行数据传输
                EventLoopGroup cGroup = new NioEventLoopGroup();

                try {
                    //2创建服务辅助类
                    ServerBootstrap b = new ServerBootstrap();
                    b.group(pGroup, cGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG, 1024)
                        .option(ChannelOption.SO_SNDBUF, 32*1024)
                        .option(ChannelOption.SO_RCVBUF, 32*1024)
                        .option(ChannelOption.SO_KEEPALIVE, true)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                //3.设置分隔符，解决拆包粘包问题
                                ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());
                                sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buf));
                                //设置字符串形式的解码
                                sc.pipeline().addLast(new StringDecoder());
                                sc.pipeline().addLast(new ServerHandler());
                            }
                        });

                    //4.绑定连接
                    ChannelFuture cf = b.bind(9001).sync();
                    //5.等待服务器监听端口关闭
                    cf.channel().closeFuture().sync();
                } finally {
                    //6.释放资源
                    pGroup.close();
                    cGroup.close();
                }
            }
        }

        /**
         * 服务器端处理方法
         */
        public class ServerHandler extends ChannelHandlerAdapter{

            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                System.out.println("服务器端通道激活。。。");
            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                String request = (String) msg;
                System.out.println("Server: " + msg);
                String response = "服务器响应： " + msg + "$_";
                ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

            }

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


        }

客户端

        /**
         * 客户端
         */
        public class Client {

            public static void main(String[] args) throws Exception {
                EventLoopGroup group = new NioEventLoopGroup();

                try {
                    Bootstrap b = new Bootstrap();
                    b.group(group)
                        .channel(NioSocketChannel.class)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                //处理分隔符
                                ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());
                                sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,buf));
                                sc.pipeline().addLast(new StringDecoder());
                                sc.pipeline().addLast(new ClientHandler());
                            }
                        });
                    //连接服务端
                    ChannelFuture cf = b.connect("127.0.0.1",9001).sync();
                    cf.channel().writeAndFlush(Unpooled.wrappedBuffer("aa$_".getBytes()));
                    cf.channel().writeAndFlush(Unpooled.wrappedBuffer("bb$_".getBytes()));
                    cf.channel().writeAndFlush(Unpooled.wrappedBuffer("ccc$_".getBytes()));

                    //等待客户端端口关闭
                    cf.channel().closeFuture().sync();
                } finally {
                    group.shutdownGracefully();
                }
            }
        }

        /**
         * 客户端处理方法
         */
        public class ClientHandler extends ChannelHandlerAdapter{

            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {
                System.out.println("客户端通道激活。。。");
            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                try {
                    String response = (String) msg;
                    System.out.println("Client: " + response);
                } finally {
                    ReferenceCountUtil.release(msg);
                }
            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

            }

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


        }

编解码器

解码器负责将消息从字节或其他序列形式转成指定的消息对象，编码器则相反；解码器负责处理“入站”数据，编码器负责处理“出站”数据。

压缩解压

        /**
         * 压缩解压工具类
         */
        public class GzipUtils {

            /**
             * 压缩
             * @param data
             * @return
             * @throws Exception
             */
            public static byte[] gzip(byte[] data) throws Exception{
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                byte[] ret;
                try {
                    GZIPOutputStream gzip = new GZIPOutputStream(bos);
                    gzip.write(data);
                    gzip.finish();
                    gzip.close();
                    ret = bos.toByteArray();
                } finally {
                    if (bos != null) {
                        bos.close();
                    }
                }
                return ret;
            }

            /**
             * 解压
             * @param data
             * @return
             * @throws Exception
             */
            public static byte[] unzip(byte[] data) throws Exception{
                ByteArrayInputStream bis = new ByteArrayInputStream(data);
                GZIPInputStream gzip = new GZIPInputStream(bis);
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                byte[] ret;
                try {
                    byte[] buf = new byte[1024];
                    int num = -1;
                    while ((num = gzip.read(buf, 0, buf.length)) != -1) {
                        bos.write(buf,0,num);
                    }
                    ret = bos.toByteArray();
                    bos.flush();
                } finally {
                    if (gzip != null) {
                        gzip.close();
                    }
                    if (bis != null) {
                        bis.close();
                    }
                    if (bos != null) {
                        bos.close();
                    }
                }
                return ret;
            }
        }

Marshalling

Jboss Marshalling 是一个java对象序列化包，对jdk默认的序列化框架进行了优化，但又保持跟java.io.Serializable接口兼容，同时增加了一些可调的参数和附加特性。

        /**
         * Marshalling工厂
         */
        public class MarshallingCodecFactory {

            /**
             * 创建Jboss Marshalling解码器MarshallingDecoder
             * @return
             */
            public static MarshallingDecoder buildMarshallingDecoder(){
                //通过Marshalling工具类的精通方法获取Marshalling实例对象 参数serial标识创建的是java序列化工厂对象。
                final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
                //创建了MarshallingConfiguration对象，配置了版本号为5 
                final MarshallingConfiguration configuration = new MarshallingConfiguration();
                configuration.setVersion(5);
                //根据marshallerFactory和configuration创建provider
                UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);
                //构建Netty的MarshallingDecoder对象，俩个参数分别为provider和单个消息序列化后的最大长度
                MarshallingDecoder decoder = new MarshallingDecoder(provider,1024 * 1024 * 1);
                return decoder;
            }

            /**
             * 创建Jboss MarshallingEncoder编码器
             * @return
             */
            public static MarshallingEncoder buildMarshallingEncoder(){
                final MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
                final MarshallingConfiguration configuration = new MarshallingConfiguration();
                configuration.setVersion(5);
                MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration);
                //构建Netty的MarshallingEncoder对象，MarshallingEncoder用于实现序列化接口的POJO对象序列化为二进制数组
                MarshallingEncoder encoder = new MarshallingEncoder(provider);
                return encoder;
            }
        }

JavaBean

        /**
         * 请求消息
         */
        public class ReqData implements Serializable {

            private static final long serialVersionUID = 1L;

            private String id;
            private String name;
            private String requestMessage;
            private byte[] attachment;

            public String getId() {
                return id;
            }
            public void setId(String id) {
                this.id = id;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public String getRequestMessage() {
                return requestMessage;
            }
            public void setRequestMessage(String requestMessage) {
                this.requestMessage = requestMessage;
            }
            public byte[] getAttachment() {
                return attachment;
            }
            public void setAttachment(byte[] attachment) {
                this.attachment = attachment;
            }

        }

        /**
         * 响应信息
         */
        public class RespData implements Serializable{

            private static final long serialVersionUID = 1L;

            private String id;
            private String name;
            private String responseMessage;
            public String getId() {
                return id;
            }
            public void setId(String id) {
                this.id = id;
            }
            public String getName() {
                return name;
            }
            public void setName(String name) {
                this.name = name;
            }
            public String getResponseMessage() {
                return responseMessage;
            }
            public void setResponseMessage(String responseMessage) {
                this.responseMessage = responseMessage;
            }

        }

服务端

        /**
         * 服务端
         */
        public class Server {

            public static void main(String[] args) throws Exception {
                EventLoopGroup pGroup = new NioEventLoopGroup();
                EventLoopGroup cGroup = new NioEventLoopGroup();

                try {
                    ServerBootstrap b = new ServerBootstrap();
                    b.group(pGroup,cGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG, 1024)
                        .handler(new LoggingHandler(LogLevel.INFO)) //设置日志
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingDecoder());
                                sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingEncoder());
                                sc.pipeline().addLast(new ServerHandler());
                            }
                        });

                    //绑定端口
                    ChannelFuture cf = b.bind(9003).sync();
                    cf.channel().closeFuture().sync();
                } finally {
                    pGroup.close();
                    cGroup.close();
                }

            }
        }

        /**
         * 服务端处理方法
         */
        public class ServerHandler extends ChannelHandlerAdapter{

            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {

            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                ReqData req= (ReqData) msg;
                System.out.println("Server: " + req.getId() + "," + req.getName() + "," + req.getRequestMessage());
                byte[] attachment = GzipUtils.unzip(req.getAttachment());

                String path = System.getProperty("user.dir") + File.separatorChar + "receive" + File.separatorChar + "001.jpg";
                FileOutputStream fos = new FileOutputStream(path);
                fos.write(attachment);
                fos.close();

                RespData resp = new RespData();
                resp.setId(req.getId());
                resp.setName("resp" + req.getId());
                resp.setResponseMessage("响应内容： " + req.getId());
                ctx.writeAndFlush(resp);
            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

            }

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

        }

客户端

        /**
         * 客户端
         */
        public class Client {

            public static void main(String[] args) throws Exception {
                EventLoopGroup group = new NioEventLoopGroup();
                Bootstrap b = new Bootstrap();

                try {
                    b.group(group)
                        .channel(NioSocketChannel.class)
                        .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingDecoder());
                                sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingEncoder());
                                sc.pipeline().addLast(new ClientHandler());
                            }
                        });

                    ChannelFuture cf = b.connect("127.0.0.1",9003).sync();

                    for (int i = 0; i < 6; i++) {
                        ReqData req = new ReqData();
                        req.setId(""+i);
                        req.setName("pro"+i);
                        req.setRequestMessage("数据信息" + i);
                        String path = System.getProperty("user.dir") + File.separatorChar
                                + "sources" + File.separatorChar + "001.jpg";
                        File file = new File(path);
                        FileInputStream in = new FileInputStream(file);
                        byte[] data = new byte[in.available()];
                        in.read(data);
                        in.close();
                        req.setAttachment(GzipUtils.gzip(data));
                        cf.channel().writeAndFlush(req);
                    }

                    cf.channel().closeFuture().sync();
                } finally {
                    group.shutdownGracefully();
                }
            }
        }

        /**
         * 客户端处理方法
         */
        public class ClientHandler extends ChannelHandlerAdapter{

            @Override
            public void channelActive(ChannelHandlerContext ctx) throws Exception {

            }

            @Override
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                try {
                    RespData resp = (RespData) msg;
                    System.out.println("Client:" + resp.getId() + "," + resp.getName() + "," + resp.getResponseMessage());
                } finally {
                    ReferenceCountUtil.release(msg);
                }
            }

            @Override
            public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

            }

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

        }

应用场景

断开后重新连接

服务端，加上一行设置超时时间的代码，其它内容不变。

        b.group(pGroup,cGroup)
                .channel(NioServerSocketChannel.class)
                .option(ChannelOption.SO_BACKLOG, 1024)
                .handler(new LoggingHandler(LogLevel.INFO)) //设置日志
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingDecoder());
                        sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingEncoder());
                        //设置连接超时时间
                        sc.pipeline().addLast(new ReadTimeoutHandler(3));
                        sc.pipeline().addLast(new ServerHandler());
                    }
                });

客户端

        /**
         * 客户端
         */
        public class Client {

            private static class SingletonHolder {
                static final Client instance = new Client();
            }

            public static Client getInstance(){
                return SingletonHolder.instance;
            }

            private EventLoopGroup group;
            private Bootstrap b;
            private ChannelFuture cf ;

            private Client(){
                    group = new NioEventLoopGroup();
                    b = new Bootstrap();
                    b.group(group)
                     .channel(NioSocketChannel.class)
                     .handler(new LoggingHandler(LogLevel.INFO))
                     .handler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel sc) throws Exception {
                                sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingDecoder());
                                sc.pipeline().addLast(MarshallingCodecFactory.buildMarshallingEncoder());
                                //超时handler（当服务器端与客户端在指定时间以上没有任何进行通信，则会关闭响应的通道，主要为减小服务端资源占用）
                                sc.pipeline().addLast(new ReadTimeoutHandler(3)); 
                                sc.pipeline().addLast(new ClientHandler());
                            }
                    });
            }

            public void connect(){
                try {
                    this.cf = b.connect("127.0.0.1", 9003).sync();
                    System.out.println("远程服务器已经连接, 可以进行数据交换..");                
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            public ChannelFuture getChannelFuture(){

                if(this.cf == null){
                    this.connect();
                }
                if(!this.cf.channel().isActive()){
                    this.connect();
                }

                return this.cf;
            }

            public static void main(String[] args) throws Exception{
                final Client c = Client.getInstance();
                //c.connect();

                ChannelFuture cf = c.getChannelFuture();
                for(int i = 1; i <= 3; i++ ){
                    ReqData request = new ReqData();
                    request.setId("" + i);
                    request.setName("pro" + i);
                    request.setRequestMessage("数据信息" + i);
                    cf.channel().writeAndFlush(request);
                    TimeUnit.SECONDS.sleep(4);
                }

                cf.channel().closeFuture().sync();


                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println("进入子线程...");
                            ChannelFuture cf = c.getChannelFuture();
                            System.out.println(cf.channel().isActive());
                            System.out.println(cf.channel().isOpen());

                            //再次发送数据
                            ReqData request = new ReqData();
                            request.setId("" + 4);
                            request.setName("pro" + 4);
                            request.setRequestMessage("数据信息" + 4);
                            cf.channel().writeAndFlush(request);                    
                            cf.channel().closeFuture().sync();
                            System.out.println("子线程结束.");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();

                System.out.println("断开连接,主线程结束..");

            }

        }