Netty（二）TCP粘包、拆包和UDP通信

Netty基本实现

Netty实现通信的步骤：
1. 创建两个NIO线程组，一个专门用于网络事件处理（接受客户端的连接），另一个则进行网络通信读写。
2. 创建一个ServerBootstrap对象，配置Netty的一系列参数，例如接受传出数据的缓存大小等。
3. 创建一个实际处理的类ChannelInitializer,进行初始化的准备工作，比如设置接受传出数据的字符集、格式、以及实际处理数据的接口。
4. 绑定端口，执行同步阻塞方法等待服务器端启动即可。

public class ServerHandler extends ChannelHandlerAdapter{

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//      ((ByteBuf) msg).release();
        //do something
        ByteBuf buf = (ByteBuf) msg;
        byte[] bytes = new byte[buf.readableBytes()];//readableBytes()可读数据
        buf.readBytes(bytes);
        String request = new String(bytes,"utf-8");
        System.out.println("Server : " + request);

        //写给客户端
        String response = "服务器端响应数据：888";
        ctx.write(Unpooled.copiedBuffer(response.getBytes())) //write方法会帮助释放消息，可以不用finally释放消息
        .addListener(ChannelFutureListener.CLOSE); //监听，把数据发送后主动断开与客户端的连接
        ctx.flush();
    }

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

}

public class Server {

    public static void main(String[] args) throws InterruptedException {
        //1.第一个线程组用于接收client端连接
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //2.第二个线程组用于实际业务处理
        EventLoopGroup workGroup = new NioEventLoopGroup();
        //3.创建一个辅助类BootStrap，就是对server进行一系列配置
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workGroup)
        .channel(NioServerSocketChannel.class)
        .childHandler(new ChannelInitializer() {

            @Override
            protected void initChannel(SocketChannel channel) throws Exception {
                channel.pipeline().addLast(new ServerHandler());
            }
        })
        .option(ChannelOption.SO_BACKLOG, 128)
        .childOption(ChannelOption.SO_KEEPALIVE, true);

        ChannelFuture future = b.bind(6666).sync();
        //阻塞
        future.channel().closeFuture().sync();
        bossGroup.shutdownGracefully();
        workGroup.shutdownGracefully();
    }
}

public class ClientHandler extends ChannelHandlerAdapter{

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    try {
            ByteBuf buf = (ByteBuf) msg;
            byte[] bytes = new byte[buf.readableBytes()];//readableBytes()可读数据
            buf.readBytes(bytes);
            String request = new String(bytes, "utf-8");
            System.out.println("Client : " + request);
        } finally {
            ReferenceCountUtil.release(msg);//释放消息
        }
    }

    @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();
        b.group(group)
        .channel(NioSocketChannel.class)
        .handler(new ChannelInitializer() {

            protected void initChannel(SocketChannel sc) throws Exception {
                sc.pipeline().addLast(new ClientHandler());
            }
        });

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

        //buf
//      cf.channel().write(Unpooled.copiedBuffer("777".getBytes()));
//      cf.channel().flush();
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("777".getBytes()));
        //阻塞
        cf.channel().closeFuture().sync();
        group.shutdownGracefully();
    }
}

TCP粘包、拆包问题

TCP是一个“流”协议，所谓流就是没有界限的遗传数据。TCP底层并不了解上层的业务数据具体的含义，它会跟进TCP缓冲区的实际情况进行包的划分，在业务上，我们一个完整的包可能会被TCP分成多个包进行发送，也可能把多个小包封装成一个大的数据包发送出去，这就是所谓的TCP粘包、拆包问题。
TCP粘包、拆包问题的产生原因：
1. 应用程序write写入的字节大小大于套接口发送缓冲区的大小
2. 进行MSS大小的TCP分段
3. 以太网帧的payload大于MTU进行IP分片

粘包、拆包主流解决方案：
1. 消息定长，例如每个报文的大小固定为200个字节，如果不够，空位补空格；
2. 在包尾部增加特殊字符进行分割，例如加回车等；
3. 将消息分为消息头和消息体，在消息头中包含表示消息总长度的字段，然后进行业务逻辑的处理

Netty解决粘包、拆包问题：
1. 分隔符类 DElimiterBasedFrameDecoder（自定义分隔符）
2. FixedLengthFrameDecoder（定长）

public class ServerHandler1 extends ChannelHandlerAdapter{

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active...");
    }

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

    }

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

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

}

public class Server1 {

    public static void main(String[] args) throws InterruptedException {
        //1.创建线程，接收客户端
        EventLoopGroup pGroup = new NioEventLoopGroup();
        //2.创建线程，用于处理数据传输
        EventLoopGroup wGroup = new NioEventLoopGroup();
        //3.创建服务器辅助类
        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, wGroup)
            .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() {
                @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 ServerHandler1());
                }
            });

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

public class ClientHandler1 extends ChannelHandlerAdapter{

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client active..");
    }

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

    }

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

    }

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

}

public class Client1 {

    public static void main(String[] args) throws InterruptedException {
        //1.创建线程组
        EventLoopGroup group = new NioEventLoopGroup(); 
        //2.创建客户端辅助类
        Bootstrap b = new Bootstrap();
        b.group(group)
         .channel(NioSocketChannel.class)
         .handler(new ChannelInitializer() {
            @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 ClientHandler1());
            }
        });

        //3.连接服务器
        ChannelFuture cf = b.connect("127.0.0.1", 6666).sync();
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("bbbb$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("ccc$_".getBytes()));

        //等待服务器监听端口关闭
        cf.channel().closeFuture().sync();
        group.shutdownGracefully();
    }
}

public class ServerHandler1 extends ChannelHandlerAdapter{

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active..");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String request = (String) msg;
        System.out.println("server : " + request);
        String response = request;
        ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes()));
    }

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

    }

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

}

public class Server1 {

    public static void main(String[] args) throws InterruptedException {
        //1.创建线程，管理连接
        EventLoopGroup pGroup = new NioEventLoopGroup();
        //2.创建线程，处理数据传输
        EventLoopGroup wGroup = new NioEventLoopGroup();
        //3.创建服务端辅助类
        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, wGroup)
            .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() {
                @Override
                protected void initChannel(SocketChannel sc) throws Exception {
                    //设置定长字符串接收
                    sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
                    //设置字符串形式编码
                    sc.pipeline().addLast(new StringDecoder());
                    sc.pipeline().addLast(new ServerHandler1());
                }
            });

        //4.绑定端口
        ChannelFuture cf = b.bind(6666).sync();

        //等待服务器监听端口关闭
        cf.channel().closeFuture().sync();
        pGroup.shutdownGracefully();
        wGroup.shutdownGracefully();
    }
}

public class ClientHandler1 extends ChannelHandlerAdapter{

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client channel active..");
    }

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

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

    }

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

}

public class Client1 {

    public static void main(String[] args) throws InterruptedException {
        //1.创建线程
        EventLoopGroup group = new NioEventLoopGroup();
        //2.创建辅助类
        Bootstrap b = new Bootstrap();
        b.group(group)
         .channel(NioSocketChannel.class)
         .handler(new ChannelInitializer() {
            @Override
            protected void initChannel(SocketChannel sc) throws Exception {
                //设置定长字符串接收
                sc.pipeline().addLast(new FixedLengthFrameDecoder(5));
                sc.pipeline().addLast(new StringDecoder());
                sc.pipeline().addLast(new ClientHandler1());
            }
        });

        //3.连接服务端
        ChannelFuture cf = b.connect("127.0.0.1", 6666).sync();
        cf.channel().writeAndFlush(Unpooled.wrappedBuffer("aaaabbbb".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("ccccccc".getBytes()));

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

Netty编解码

可以使用java进行对象序列化，netty去传输，但是java序列化的缺点多，比如java序列化没法跨语言、序列化后码流太大、序列化性能太低等等。
主流的编解码框架：
JBoss的Marshalling包
google的Protobuf
基于Protobuf的Kyro
MessagePack框架

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

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

    private final static Logger logger = Logger.getLogger(GzipUtil.class);

    public static byte[] gzip(byte[] data) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        GZIPOutputStream gzipos = null;
        byte[] result = null ;
        try {
            gzipos = new GZIPOutputStream(baos);
            gzipos.write(data);
            gzipos.finish();
            result = baos.toByteArray();
        } catch (IOException e) {
            logger.error("压缩文件失败！",e);
            throw new IOException();
        } finally {
            if (gzipos != null) {
                try {
                    gzipos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            gzipos = null;
            baos = null;
        }
        return result;
    }

    public static byte[] ungzip(byte[] data) throws IOException {
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        GZIPInputStream gzipis = null;
        ByteArrayOutputStream baos = null;
        byte[] result = null;
        try {
            gzipis = new GZIPInputStream(bais);
            byte[] buf = new byte[1024];
            int num = -1;
            baos = new ByteArrayOutputStream();
            while ((num = gzipis.read(buf, 0, buf.length)) != -1) {
                baos.write(buf, 0, num);
            }
            result = baos.toByteArray();
            baos.flush();
        } catch (IOException e) {
            logger.error("解压文件失败！",e);
            throw new IOException();
        } finally {
            if (gzipis != null) {
                try {
                    gzipis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bais != null) {
                try {
                    bais.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            gzipis = null;
            bais = null;
            baos = null;
        }
        return result;
    }

    //测试
    public static void main(String[] args) throws Exception {
        //文件路径
        String readPath = System.getProperty("user.dir") + File.separator + "sources" + File.separator + "001.jpg";
        File file = new File(readPath);
        FileInputStream fis = new FileInputStream(file);
        byte[] data = new byte[fis.available()];
        fis.read(data);
        fis.close();

        System.out.println("文件原始大小：" + data.length);
        //文件压缩
        byte[] result = GzipUtil.gzip(data);
        System.out.println("文件压缩后大小：" + result.length);

        //文件解压
        byte[] ungzipFile = GzipUtil.ungzip(result);
        System.out.println("文件解压后大小：" + ungzipFile.length);

        //写出文件
        String writePath = System.getProperty("user.dir") + File.separator + "receive" + File.separator + "001.jpg";
        FileOutputStream fos = new FileOutputStream(writePath);
        fos.write(ungzipFile);
        fos.close();
    }
}

/**
 * Marshalling工厂
 */
public final class MarshallingCodeCFactory {

    /**
     * 创建Jboss Marshalling解码器MarshallingDecoder
     * @return MarshallingDecoder
     */
    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 Marshalling编码器MarshallingEncoder
     * @return MarshallingEncoder
     */
    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;
    }
}

Netty

public class Request 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 Response 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 ServerHandlerExt extends ChannelHandlerAdapter{

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

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

        Resp resp = new Resp();
        resp.setId(req.getId());
        resp.setName("resp" + req.getId());
        resp.setResponseMessage("响应内容：" + req.getId());
        ctx.writeAndFlush(req);//.addListener(ChannelFutureListener.CLOSE)
    }

}

public class ServerExt {

    public static void main(String[] args) throws InterruptedException {
        //创建两个现场
        EventLoopGroup pGroup = new NioEventLoopGroup();
        EventLoopGroup wGroup = new NioEventLoopGroup();
        //创建辅助类
        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, wGroup)
            .channel(NioServerSocketChannel.class)
            .option(ChannelOption.SO_BACKLOG, 1024)
            //设置日志
            .handler(new LoggingHandler(LogLevel.INFO))
            .childHandler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel sc) throws Exception {
                    sc.pipeline().addLast(MarshallingFactory.buildMarshallingEncoder());
                    sc.pipeline().addLast(MarshallingFactory.buildMarshallingDecoder());
                    sc.pipeline().addLast(new ServerHandlerExt());
                }
            });


        b.bind(6666).channel().closeFuture().sync();
        //关闭连接
        pGroup.shutdownGracefully();
        wGroup.shutdownGracefully();
    }
}

public class ClientHandlerExt extends ChannelHandlerAdapter{

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

    }

}


public class ClientExt {

    public static void main(String[] args) throws Exception {
        //创建线程
        EventLoopGroup group = new NioEventLoopGroup();
        //创建工具类
        Bootstrap b = new Bootstrap();
        b.group(group)
            .channel(NioSocketChannel.class)
            .handler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel sc) throws Exception {
                    sc.pipeline().addLast(MarshallingFactory.buildMarshallingEncoder());
                    sc.pipeline().addLast(MarshallingFactory.buildMarshallingDecoder());
                    sc.pipeline().addLast(new ClientHandlerExt());
                }
            });

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

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

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

Netty的UDP协议

UDP协议全称是用户数据报协议，在网络中它与TCP协议一样用于处理数据包，是一种无连接的协议。

public class ServerHandlerExt extends SimpleChannelInboundHandler<DatagramPacket>{

     // 谚语列表
    private static final String[] DICTIONARY = { 
        "只要功夫深，铁棒磨成针。",
        "旧时王谢堂前燕，飞入寻常百姓家。", 
        "洛阳亲友如相问，一片冰心在玉壶。",
        "一寸光阴一寸金，寸金难买寸光阴。",
        "老骥伏枥，志在千里。烈士暮年，壮心不已!"
    };

    private String nextQuote(){
        int quoteId = ThreadLocalRandom.current().nextInt(DICTIONARY.length);
        return DICTIONARY[quoteId];
    }

    protected void messageReceived(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
        String req = packet.content().toString(CharsetUtil.UTF_8);
        System.out.println(req);
        if ("谚语字典查询?".equals(req)) {
            ctx.writeAndFlush(
                    new DatagramPacket(Unpooled.copiedBuffer("谚语查询结果："+ nextQuote(),
                    CharsetUtil.UTF_8),packet.sender()));
        }
    }

}
public class ServerExt {

    public void run(int port) throws InterruptedException{
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioDatagramChannel.class)
            .option(ChannelOption.SO_BROADCAST, true)
            .handler(new ServerHandlerExt());
            b.bind(port).sync().channel().closeFuture().await();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ServerExt().run(6666);
        new ServerExt().run(8888);
    }
}
public class ClientHandlerExt extends SimpleChannelInboundHandler<DatagramPacket>{

    @Override
    protected void messageReceived(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
        String response = packet.content().toString(CharsetUtil.UTF_8);
        if (response.startsWith("谚语查询结果：")) {
            System.out.println(response);
            ctx.close();
        }
    }

}
public class ClientExt {

    public void run(int port) throws InterruptedException{
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioDatagramChannel.class).option(ChannelOption.SO_BACKLOG, 1024)
                    .handler(new ClientHandlerExt());
            Channel channel = b.bind(0).sync().channel();
            // 向网段内的所有机器广播UDP消息
            channel.writeAndFlush(new DatagramPacket(Unpooled.copiedBuffer("谚语字典查询?", CharsetUtil.UTF_8),
                    new InetSocketAddress("255.255.255.255", port))).sync();
            if (!channel.closeFuture().await(15000)) {
                System.out.println("查询超时!");
            }
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ClientExt().run(6666);
    }
}

Netty的WebSocket

webSocket将网络套接字引入到客户端和服务端，WebSocke特点：
- 单一的tcp连接，双方可通信
- 对代理、防火墙和路由器透明
- 无头部信息、Cookie和身份验证
- 无安全开销
- 通过ping/pong帧保持链路激活
- 服务器可主动传递消息给客户端，不再需要客户端轮询

网络超时设置

public class Server {

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

        EventLoopGroup pGroup = new NioEventLoopGroup();
        EventLoopGroup cGroup = new NioEventLoopGroup();

        ServerBootstrap b = new ServerBootstrap();
        b.group(pGroup, cGroup)
         .channel(NioServerSocketChannel.class)
         .option(ChannelOption.SO_BACKLOG, 1024)
         //设置日志
         .handler(new LoggingHandler(LogLevel.INFO))
         .childHandler(new ChannelInitializer() {
            protected void initChannel(SocketChannel sc) throws Exception {
                sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());
                sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());
                sc.pipeline().addLast(new ReadTimeoutHandler(5)); //网络读写超时设置
                sc.pipeline().addLast(new ServerHandler());
            }
        });

        ChannelFuture cf = b.bind(8765).sync();

        cf.channel().closeFuture().sync();
        pGroup.shutdownGracefully();
        cGroup.shutdownGracefully();

    }
}

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() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingDecoder());
                        sc.pipeline().addLast(MarshallingCodeCFactory.buildMarshallingEncoder());
                        //超时handler（当服务器端与客户端在指定时间以上没有任何进行通信，则会关闭响应的通道，主要为减小服务端资源占用）
                        sc.pipeline().addLast(new ReadTimeoutHandler(5)); 
                        sc.pipeline().addLast(new ClientHandler());
                    }
            });
    }

    public void connect(){
        try {
            this.cf = b.connect("127.0.0.1", 8765).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++ ){
            Request request = new Request();
            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());

                    //再次发送数据
                    Request request = new Request();
                    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("断开连接,主线程结束..");

    }

}