Netty服务器与客户端通讯案例

た入场券 2024-04-06 14:14 106阅读 0赞

服务器端：

import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    
    public class NettyServer {
        
        public static void main(String[] args) throws InterruptedException {
        
            //1、创建两个线程组 bossGroup workGroup
    //bossGroup线程组负责客户端连接
            EventLoopGroup bossGroup=new NioEventLoopGroup();
    //workGroup线程组负责网络读写操作
            EventLoopGroup workGroup=new NioEventLoopGroup();
    //2、创建服务器启动助手来配置参数--创建辅助的工具类，用于服务器通道的一些列配置
            ServerBootstrap serverBootstrap=new ServerBootstrap();
    //链式编程
            serverBootstrap.group(bossGroup,workGroup)//绑定两个线程组
                    .channel(NioServerSocketChannel.class)//指定NIO模式
                    .option(ChannelOption.SO_BACKLOG,512)//设置TCP缓冲区
                    .childOption(ChannelOption.SO_KEEPALIVE,true)//保持连接
                    .childHandler(new ChannelInitializer<SocketChannel>() {
        
                        protected void initChannel(SocketChannel ch) throws Exception {
        //数据 接收方法的处理
                            ch.pipeline().addLast(new NettyServerHandler());//具体业务的处理
                        }
                    });
            System.out.println("Server : 准备就绪！！！");
    //3 绑定端口,设置非堵塞,,这里是一个异步操作
            ChannelFuture cf = serverBootstrap.bind(8765).sync();
            ChannelFuture cf2 = serverBootstrap.bind(8766).sync();//--绑定多个端口，开口变大，但是处理能力不变
            System.out.println("Server : 启动！！！");
    //4 关闭通道
            cf.channel().closeFuture().sync();//等待关闭
            cf2.channel().closeFuture().sync();//等待关闭
            System.out.println("Server--关闭通道！！！");
    //关闭线程组
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
            System.out.println("Server--关闭线程组！！！");
        }
    }

服务器业务处理类：

import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelFutureListener;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelInboundHandlerAdapter;
    import io.netty.util.CharsetUtil;
    import javax.sound.midi.Soundbank;
    
    //普通类变成业务处理类需要继承一个类或者实现一个接口
    public class NettyServerHandler extends ChannelInboundHandlerAdapter {
        
        //数据的读取事件
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws
                Exception {
        
            System.out.println("serverHandler--ctx:"+ctx);
            ByteBuf buffer= (ByteBuf) msg;
            System.out.println("来自客户端的消息："+buffer.toString(CharsetUtil.UTF_8));
        }
        //数据读取完毕事件
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception
        {
        
            ChannelFuture channelFuture =
                    ctx.writeAndFlush(Unpooled.copiedBuffer("hi,client,我收到你的消息啦！", CharsetUtil.UTF_8));
    //添加监听事件：数据发送完毕之后，直接断开客户端的连接
           // channelFuture.addListener(ChannelFutureListener.CLOSE);
        }
        //异常捕捉事件
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                throws Exception {
        
            ctx.close();
        }
    }

客户端：

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;
    
    public class NettyClient {
        
        public void run() throws InterruptedException {
        
            EventLoopGroup group=new NioEventLoopGroup();
    //创建客户端的启动助手
            Bootstrap bootstrap=new Bootstrap();
    //开始配置
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
        
                        protected void initChannel(SocketChannel ch) throws
                                Exception {
        
                            ch.pipeline().addLast(new NettyClientHandler());//具体业务处理
                        }
                    });
            System.out.println("Client: 准备就绪！！！");
    //启动客户端去连接服务器
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 8765).sync();
            ChannelFuture cf2 = bootstrap.connect("127.0.0.1", 8766).sync();
            //服务器端断开连接这边才会断开连接的，
            cf.channel().closeFuture().sync();//等待关闭
            cf2.channel().closeFuture().sync();//等待关闭
            System.out.println("Client--关闭通道！！！");
            group.shutdownGracefully();
            System.out.println("Client--关闭线程组！！！");
        }
        public static void main(String[] args) {
        
            try {
        
                new NettyClient().run();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
        }
    }

客户端业务处理类：

import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerContext;
    import io.netty.channel.ChannelInboundHandlerAdapter;
    import io.netty.util.CharsetUtil;
    
    //客户端业务处理类
    //入站操作，进入pipeline里面
    public class NettyClientHandler extends ChannelInboundHandlerAdapter{
        
        //通道就绪
        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
        
            System.out.println("Client: ctx="+ctx);
            ctx.writeAndFlush(Unpooled.copiedBuffer("hi,server,这是来自客户端的招呼！", CharsetUtil.UTF_8));
        }
        //数据的读取事件
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) throws
                Exception {
        
            ByteBuf buf = (ByteBuf) msg;
            System.out.println("服务器回复的消息：" + buf.toString(CharsetUtil.UTF_8));
        }
    }

![在这里插入图片描述][f878a8376db34465924e0d43f257a34c.png]  
![在这里插入图片描述][4d67a6ba9973464c988d8090e9f40e94.png]  
当服务器断开以后，客户端会执行断开连接的操作。  
![在这里插入图片描述][772aa22c1f994d1c84d424297cb4eb0f.png]

[f878a8376db34465924e0d43f257a34c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/941ed09f43d246f887e31b6ffc3f74a5.png
[4d67a6ba9973464c988d8090e9f40e94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/f55a3349dff9442c9512d3cd659c347e.png
[772aa22c1f994d1c84d424297cb4eb0f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/9aaee9835f144cffbe2d2460ab428602.png