个人笔记 Socket网络编程(3)--netty框架

最新推荐文章于 2024-05-01 12:15:03 发布

你今天学习了吗?

最新推荐文章于 2024-05-01 12:15:03 发布

阅读量188

点赞数

本文链接：https://blog.csdn.net/qq_35459686/article/details/81511440

版权

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

记住资源一定要进行释放****

ServerHandler 必须继承

下面介绍代码

客户端: client.java
package bhz.netty.helloworld;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
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 Client {

   public static void main(String[] args) throws Exception{
       //NioEventLoopGroup 用来处理I/O操作的多线程事件循环器,
       //但在netty中使用的是EventLoopGroup 因为要实现客户端和服务端的操作所以需要
       //两个EventLoopGroup 一个用来接受进来的连接简称boss,另一个用来处理已接收的连接,简称worker,一旦boss接收到信息,就会注册到worker中
       //客户端使用一个进行数据读写就可以了
       EventLoopGroup group = new NioEventLoopGroup();
       //启动nio服务的服务启动类,可在这个服务中终结   使用channel
       Bootstrap b = new Bootstrap();
       //这一步是必须的,必须设置组客户端用.handler 服务端用.childHandler
       b.group(group)
       .channel(NioSocketChannel.class)
       .handler(new ChannelInitializer<SocketChannel>() {
           @Override
           protected void initChannel(SocketChannel sc) throws Exception {
               //接受的处理方法的逻辑
               sc.pipeline().addLast(new ClientHandler());
           }
       });
       //进行异步通道的连接
       ChannelFuture cf1 = b.connect("127.0.0.1", 8765).sync();
       //ChannelFuture cf2 = b.connect("127.0.0.1", 8764).sync();
       //发送消息
       Thread.sleep(1000);
       //发送消息
       cf1.channel().writeAndFlush(Unpooled.copiedBuffer("777".getBytes()));
       cf1.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
       //cf2.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
       Thread.sleep(2000);
       cf1.channel().writeAndFlush(Unpooled.copiedBuffer("888".getBytes()));
       //cf2.channel().writeAndFlush(Unpooled.copiedBuffer("666".getBytes()));
       //这里会一直等待，直到socket被关闭
       cf1.channel().closeFuture().sync();
       //cf2.channel().closeFuture().sync();
       group.shutdownGracefully(); //关闭释放资源
   }
}

clientHandler.java

package bhz.netty.helloworld;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.util.ReferenceCountUtil;

public class ClientHandler extends ChannelHandlerAdapter{

   //客户端处理逻辑
   //这里我们覆盖了chanelRead()事件处理方法。每当从客户端收到新的数据时，这个方法会在收到消息时被调用
   @Override
   //当通道初始化的时候进行调用
         public void channelActive(ChannelHandlerContext ctx) throws Exception {
   }

   @Override
   public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
       try {
           //使用ByteBuf 进行接收
           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 {
           //每次读取完,对数据进行释放,因ByteBuf是一个引用计数对象,
           // 处理器的职责是释放所有传递到处理器的引用计数对象
           ReferenceCountUtil.release(msg);
       }
   }

@Override
//通道读取完毕执行的逻辑
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

   }
//异常必须触发的事件
   @Override
   public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
           throws Exception {
       ctx.close();
   }

}

service 端 service.java

package bhz.netty.helloworld;

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 Server {

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

       //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 进行绑定 (使用ChannelFuture代表每次创建一条线程,代表了该程序是异步的)
       ChannelFuture cf1 = b.bind(8765).sync();
       //ChannelFuture cf2 = b.bind(8764).sync();
       //5 等待关闭
       cf1.channel().closeFuture().sync();
       //cf2.channel().closeFuture().sync();
       pGroup.shutdownGracefully();
       cGroup.shutdownGracefully();
   }
}

ServiceHandler.java (客户端处理类)

package bhz.netty.helloworld;

public class Server {

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

       //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 进行绑定
       ChannelFuture cf1 = b.bind(8765).sync();
       //ChannelFuture cf2 = b.bind(8764).sync();
       //5 等待关闭
       cf1.channel().closeFuture().sync();
       //cf2.channel().closeFuture().sync();
       pGroup.shutdownGracefully();
       cGroup.shutdownGracefully();
   }
}