SocketIO---Netty--HelloWorld

1. server

public class Server {

    public static void main(String[] args) throws Exception {
        System.out.println("Server is starting...");
        //1 创建线两个程组 
        EventLoopGroup bossGroup = new NioEventLoopGroup(); //一个是用于处理服务器端接收客户端连接的
        EventLoopGroup workGroup = new NioEventLoopGroup();    //一个是进行网络通信的（网络读写的）
        
        //2 创建辅助工具类，用于服务器通道的一系列配置
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workGroup)        //绑定俩个线程组
        .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>() {//服务端就是childHandler
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
                //3 在这里配置具体数据接收方法的处理 ChannelPipeline<<<添加到<<-ChannelHandler
                socketChannel.pipeline().addLast(new ServerHandler());
            }
        });
        
        //4 异步,进行绑定  服务端是bind,客户端是connect
        ChannelFuture channelFuture = b.bind(8765).sync();
        //5 等待关闭
        channelFuture.channel().closeFuture().sync(); // 阻塞用, 等价于Thread.sleep(Integer.MAX_VALUE)
        
        bossGroup.shutdownGracefully();
        workGroup.shutdownGracefully();
    }
}

1.2 ServerHandler

//服务端业务逻辑处理类
public class ServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active... ");
    }
    
    @Override //Object msg 服务端接收到的客户端请求的数据封装到object对象中
    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 = "Hi Client, I am Server! you send " + body+"to me???" ;
            //Unpooled.copiedBuffer(response.getBytes()将string-->byte[]--->ByteBuf
            ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes())); 
            //.addListener(ChannelFutureListener.CLOSE);
    }

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

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

}

2. client

public class Client {
    public static void main(String[] args) throws Exception{
        System.out.println("Client is Starting...");
        EventLoopGroup group = new NioEventLoopGroup();//客户端一个线程组,发送请求即可
        Bootstrap b = new Bootstrap(); //辅助类, 服务端为ServerBootstrap
        b.group(group)
        .channel(NioSocketChannel.class)
        .handler(new ChannelInitializer<SocketChannel>() {//服务端为childHandler(...)
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception { 
                socketChannel.pipeline().addLast(new ClientHandler());//ChannelPipeline.addLast
            }
        });
        
        ChannelFuture channelFuture = b.connect("127.0.0.1", 8765).sync();
        //发送消息
        Thread.sleep(1000);
        channelFuture.channel().writeAndFlush(Unpooled.copiedBuffer("Client: Hi Server, I am client netty!".getBytes()));
        channelFuture.channel().writeAndFlush(Unpooled.copiedBuffer("client request 666".getBytes()));
        Thread.sleep(2000);
        channelFuture.channel().writeAndFlush(Unpooled.copiedBuffer("client request 888".getBytes()));
        
        channelFuture.channel().closeFuture().sync();//阻塞
        group.shutdownGracefully();
    }
}

3. ClientHandler

//客户端业务处理类
public class ClientHandler extends ChannelHandlerAdapter{
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
    }

    @Override //Object msg 客户端接收到的服务端响应的数据封装为object对象
    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");
            String response = "Client: 收到服务器端的返回信息：" + body;
            System.out.println(response);
        } finally {
            ReferenceCountUtil.release(msg); //服务端在writeAndFlush的时候自动释放了, 客户端没调用write方法需要手动释放
        }
    }

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

    }

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

}

结果:
Client is Starting...
Client: 收到服务器端的返回信息：Hi Client, I am Server! you send Client: Hi Server, I am client netty!client request 666to me???
Client: 收到服务器端的返回信息：Hi Client, I am Server! you send client request 888to me???

-------------------------------------------------------

Server is starting...
server channel active... 
Server接收到客户端请求:Client: Hi Server, I am client netty!client request 666
读完了
Server接收到客户端请求:client request 888
读完了

4. 如果想单次连接后得到响应,就关闭客户端,必须在server端关闭.   .addListener(ChannelFutureListener.CLOSE)

//服务端业务逻辑处理类
public class ServerHandler extends ChannelHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server channel active... ");
    }
    
    @Override //Object msg 服务端接收到的客户端请求的数据封装到object对象中
    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 = "Hi Client, I am Server! you send " + body+"to me???" ;
            //Unpooled.copiedBuffer(response.getBytes()将string-->byte[]--->ByteBuf
            ctx.writeAndFlush(Unpooled.copiedBuffer(response.getBytes())) 
            .addListener(ChannelFutureListener.CLOSE);//关闭通道必须在Server端,一次连接后就关闭
    }

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

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

}

效果: 客户端只能收到服务器端一条响应

Client is Starting...
Client: 收到服务器端的返回信息：Hi Client, I am Server! you send Client: Hi Server, I am client netty!client request 666to me???