Netty实战 IM即时通讯系统（六）实战： 客户端和服务端双向通信

最新推荐文章于 2023-05-16 13:32:15 发布
最新推荐文章于 2023-05-16 13:32:15 发布
阅读量1.9k 收藏 7
点赞数 1
分类专栏： Netty 文章标签： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chou_out_man/article/details/85287014
版权

##

Netty实战 IM即时通讯系统（六）实战： 客户端和服务端双向通信

零、 目录

  1. IM系统简介
  • Netty 简介
  • Netty 环境配置
  • 服务端启动流程
  • 实战： 客户端和服务端双向通信
  • 数据传输载体ByteBuf介绍
  • 客户端与服务端通信协议编解码
  • 实现客户端登录
  • 实现客户端与服务端收发消息
  • pipeline与channelHandler
  • 构建客户端与服务端pipeline
  • 拆包粘包理论与解决方案
  • channelHandler的生命周期
  • 使用channelHandler的热插拔实现客户端身份校验
  • 客户端互聊原理与实现
  • 群聊的发起与通知
  • 群聊的成员管理（加入与退出，获取成员列表）
  • 群聊消息的收发及Netty性能优化
  • 心跳与空闲检测
  • 总结
  • 扩展

###六、 实战： 客户端和服务端双向通信

  1. 本节我们要实现的功能是客户端连接成功后，向服务端写出一段数据 ， 服务端收到数据后打印 ， 并向客户端回复一段数据 。

  2. 我们先做一个代码框架 ， 然后在框架上面做修改

     public class Test_07_客户端和服务端双向通信 {
 	public static void main(String[] args) {
 		Test_07_Server.start(8000);
 		Test_07_Client.start("127.0.0.1" , 8000  ,5);
 	}
 }
 
 class Test_07_Client{
 	public static void start(String IP , int port ,int maxRetry){
 		NioEventLoopGroup workerGroup = new NioEventLoopGroup();
 		
 		Bootstrap bootstrap = new Bootstrap();
 		
 		bootstrap.group(workerGroup)
 			.channel(NioSocketChannel.class)
 			.handler(new ChannelInitializer<NioSocketChannel>() {
 
 				@Override
 				protected void initChannel(NioSocketChannel ch) throws Exception {
 
 				}
 			});
 		connect(bootstrap , IP , port , maxRetry);
 	}
 	
 	private static void connect(Bootstrap bootstrap, String IP, int port, int maxRetry , int... retryIndex) {
 		bootstrap.connect(IP , port).addListener(future ->{
 			int[] finalRetryIndex;
 			if(future.isSuccess()) {
 				System.out.println("连接成功");
 			}else if(maxRetry ==0) {
 				System.out.println("达到最大重试此时，放弃重试");
 			}else {
 				// 初始化 重试计数
 				if(retryIndex.length == 0) {
 					finalRetryIndex = new int[]{0};
 				}else {
 					finalRetryIndex = retryIndex;
 				}
 				// 计算时间间隔
 				int delay = 1 << finalRetryIndex[0];
 				// 执行重试
 				System.out.println(new Date() +" 连接失败，剩余重试次数："+ maxRetry + ","+delay+"秒后执行重试");
 				bootstrap.config().group().schedule(()->{
 					connect(bootstrap , IP, port , maxRetry -1 , finalRetryIndex[0]+1);
 				}, delay, TimeUnit.SECONDS);
 			}
 		});
 	}
 }
 
 
 
 class Test_07_Server{
 	public static void start(int port){
 		NioEventLoopGroup bossGroup = new NioEventLoopGroup();
 		NioEventLoopGroup workerGroup = new NioEventLoopGroup();
 		
 		ServerBootstrap serverBootstrap = new ServerBootstrap();
 		
 		serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
 		.childHandler(new ChannelInitializer<NioSocketChannel>() {

 			@Override
 			protected void initChannel(NioSocketChannel ch) throws Exception {
 				ch.pipeline().addLast(new Test_07_ServerHandler());
 			}
 		});
 		bind(serverBootstrap, port);
 
 	}
 	private static void bind(ServerBootstrap serverBootstrap, int port) {
 		serverBootstrap
 			.bind(port)
 			.addListener(future -> {
 				if(future.isSuccess()) {
 					System.out.println("服务端：端口【"+port+"】绑定成功！");
 				}else {
 					System.out.println("服务端：端口【"+port+"】绑定失败，尝试绑定【"+(port+1)+"】！");
 					bind(serverBootstrap, port+1);
 				}
 			});
 	}

 	
 }

  3. 客户端发送数据到服务端

    1. 在《客户端启动流程》这一小节 ， 我们提到 客户端相关的数据读写逻辑是通过BootStrap的handler()方法指定

       bootstrap.group(workerGroup).channel(NioSocketChannel.class)
 	.handler(new ChannelInitializer<NioSocketChannel>() {

 		@Override
 		protected void initChannel(NioSocketChannel ch) throws Exception {
 			
 		}
 	});

    2. 现在我们在initChannel()中给客户端添加一个逻辑处理器 ， 这个处理器的作用就是负责向服务端写数据

       bootstrap.group(workerGroup).channel(NioSocketChannel.class)
 	.handler(new ChannelInitializer<NioSocketChannel>() {

 		@Override
 		protected void initChannel(NioSocketChannel ch) throws Exception {
 			// 添加业务处理逻辑  可以添加自定义的业务处理逻辑也可以添加    Netty自带的简单通用的处理逻辑
 			ch.pipeline().addLast(new Test_07_ClientHandler());
 		}
 	});

      1. ch.pipeline()方法返回的是和这条连接相关的逻辑处理链 ， 采用了责任链处理模式 ， 这里不理解没关系 ， 后面会讲到。

      2. 然后再调用addLast()方法添加一个逻辑处理器 ， 这个逻辑处理器为的就是在客户端建立连接成功之后向服务端写数据 ， 下面是这个逻辑处理器的代码：

         class Test_07_ClientHandler extends ChannelInboundHandlerAdapter {
 
 	@Override
 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
 		System.out.println(new Date() + " 客户端写出数据...");
 		
 		// 1. 获取数据
 		ByteBuf buffer = getByteBuf(ctx);
 		// 2. 写数据
 		ctx.channel().writeAndFlush(buffer);
 	}
 	
 	private ByteBuf getByteBuf(ChannelHandlerContext ctx) {
 		// 获取二进制抽象 ByteBuffer
 		ByteBuf buf = ctx.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = "你好，奥特曼！".getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到 buf
 		buf.writeBytes(bs);
 		return buf;
 	}
 
 }
        1. 这个逻辑处理器继承自ChannelInboundHandlerAdapter ，然后覆盖了channelActive()方法 ， 这个方法会在客户端连接建立成功之后被调用
        2. 客户端连接建立成功之后 ， 调用channelActive() ， 在这个方法里面 ， 我们编写向服务端写数据的逻辑
        3. 向服务端写数据分为两步 ， 首先我们要获取一个netty对二进制数据抽象的二进制ByteBuf , 上面代码中ctx.alloc() 获取一个ByteBuf的内存管理器 ， 这个内存管理器的作用就是分配一个ByteBuf , 然后我们把字符串的二进制数据填充到ByteBuf ， 这样我们就获取到了Netty需要的一个数据格式， 最后我们调用ctx.channel().writeAndFlush()把数据写到服务端。
        4. 以上就是 向服务端写数据的逻辑 ， 和传统的socket 编程不同的是 ， Netty 里面的数据是以ByteBuf为单位的 ， 所有需要写出的数据必须塞到一个ByteBuf里 ， 需要读取的数据也是如此。

  4. 服务端读取客户端数据

    1. 服务端的数据处理逻辑 是通过ServerBootStrap 的childHandler()方法指定

       serverBootStrtap.childHandler(new ChannelInitializer<NioSocketChannel>() {

 	@Override
 	protected void initChannel(NioSocketChannel ch) throws Exception {
 		// TODO Auto-generated method stub

 	}
 })

    2. 现在 ， 我们在initChannel() 中 给服务端添加一个逻辑处理器 ， 这个处理器 的作用就是负责客户端读数据

       serverBootStrtap.childHandler(new ChannelInitializer<NioSocketChannel>() {

 	@Override
 	protected void initChannel(NioSocketChannel ch) throws Exception {
 		ch.pipeline().addLast(new Test_07_ServerHandler());
 	}
 })

      1. 这个方法里的逻辑和客户端类似 ， 获取服务端关于这条连接的逻辑处理链pipeline , 然后添加一个逻辑处理器 ， 负责读取客户端发来的数据

         class Test_07_ServerHandler extends ChannelInboundHandlerAdapter{
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf buf = (ByteBuf) msg;
 		System.out.println(new Date() + ": 服务端读到数据->"+ buf.toString(Charset.forName("UTF-8")));
 	}
 }
        1. 服务端的逻辑处理器同样是继承自ChannelInboundHandlerAdapter ， 与客户端不同的是 ， 这里覆盖的方法是 channelRead() ,这个方法在接收到数据之后会被回调
        2. 这里的msg 值的是Netty里面数据读写的载体 ， 为什么不直接是ByteBuf , 而需要我们强转一下 ， 我们后面会分析道 ， 这里我们强转之后 ， 然后调用buteBuf.toString() 就能够拿到我们客户端发过来的字符串数据。

  5. 运行测试

    1. 完整代码

       import java.nio.charset.Charset;
 import java.util.Date;
 import java.util.concurrent.TimeUnit;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 
 public class Test_07_客户端和服务端双向通信 {
 	public static void main(String[] args) throws Exception {
 		Test_07_Server.start(8000);
 		Test_07_Client.start("127.0.0.1", 8000, 5);
 	}
 }
 
 class Test_07_Client {
 	public static void start(String IP, int port, int maxRetry) {
 		NioEventLoopGroup workerGroup = new NioEventLoopGroup();
 
 		Bootstrap bootstrap = new Bootstrap();
 
 		bootstrap.group(workerGroup).channel(NioSocketChannel.class)
 				.handler(new ChannelInitializer<NioSocketChannel>() {
 
 					@Override
 					protected void initChannel(NioSocketChannel ch) throws Exception {
 						// 添加业务处理逻辑  可以添加自定义的业务处理逻辑也可以添加    Netty自带的简单通用的处理逻辑
 						ch.pipeline().addLast(new Test_07_ClientHandler());
 					}
 				});
 		connect(bootstrap, IP, port, maxRetry);
 	}
 
 	private static void connect(Bootstrap bootstrap, String IP, int port, int maxRetry, int... retryIndex) {
 		bootstrap.connect(IP, port).addListener(future -> {
 			int[] finalRetryIndex;
 			if (future.isSuccess()) {
 				System.out.println("客户端连接【"+IP+":"+port+"】成功");
 			} else if (maxRetry == 0) {
 				System.out.println("达到最大重试此时，放弃重试");
 			} else {
 				// 初始化 重试计数
 				if (retryIndex.length == 0) {
 					finalRetryIndex = new int[] { 0 };
 				} else {
 					finalRetryIndex = retryIndex;
 				}
 				// 计算时间间隔
 				int delay = 1 << finalRetryIndex[0];
 				// 执行重试
 				System.out.println(new Date() + " 连接失败，剩余重试次数：" + maxRetry + "," + delay + "秒后执行重试");
 				bootstrap.config().group().schedule(() -> {
 					connect(bootstrap, IP, port, maxRetry - 1, finalRetryIndex[0] + 1);
 				}, delay, TimeUnit.SECONDS);
 			}
 		});
 	}
 }
 
 class Test_07_Server {
 	public static void start(int port) {
 		NioEventLoopGroup bossGroup = new NioEventLoopGroup();
 		NioEventLoopGroup workerGroup = new NioEventLoopGroup();
 
 		ServerBootstrap serverBootstrap = new ServerBootstrap();
 
 		serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
 				.childHandler(new ChannelInitializer<NioSocketChannel>() {
 
 					@Override
 					protected void initChannel(NioSocketChannel ch) throws Exception {
 						ch.pipeline().addLast(new Test_07_ServerHandler());
 					}
 				});
 		bind(serverBootstrap, port);
 		
 	}
 	private static void bind(ServerBootstrap serverBootstrap, int port) {
 		serverBootstrap
 			.bind(port)
 			.addListener(future -> {
 				if(future.isSuccess()) {
 					System.out.println("服务端：端口【"+port+"】绑定成功！");
 				}else {
 					System.out.println("服务端：端口【"+port+"】绑定失败，尝试绑定【"+(port+1)+"】！");
 					bind(serverBootstrap, port+1);
 				}
 			});
 	}
 
 }
 
 class Test_07_ClientHandler extends ChannelInboundHandlerAdapter {
 
 	@Override
 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
 		
 		String content = "你好，奥特曼！";
 		System.out.println(new Date() + " 客户端写出数据:"+content);
 		
 		// 1. 获取数据
 		ByteBuf buffer = getByteBuf(ctx , content);
 		// 2. 写数据
 		ctx.channel().writeAndFlush(buffer);
 	}
 	
 	private ByteBuf getByteBuf(ChannelHandlerContext ctx , String content ) {
 		// 获取二进制抽象 ByteBuffer
 		ByteBuf buf = ctx.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = content.getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到 buf
 		buf.writeBytes(bs);
 		return buf;
 	}
 
 }
 
 class Test_07_ServerHandler extends ChannelInboundHandlerAdapter{
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf buf = (ByteBuf) msg;
 		System.out.println(new Date() + ": 服务端读到数据->"+ buf.toString(Charset.forName("UTF-8")));
 	}
 }

    2. 运行结果：

  6. 服务端回复数据给客户端

    1. 服务端向客户端写数据的逻辑与客户端向服务端写数据的逻辑一样 ， 先创建一个ByteBuf ， 然后填充二进制数据 ， 最后调用writeAndFlush()方法写出去

       class Test_07_ServerHandler extends ChannelInboundHandlerAdapter{
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf buf = (ByteBuf) msg;
 		System.out.println(new Date() + ": 服务端读到数据->"+ buf.toString(Charset.forName("UTF-8")));
 		
 		// 向客户端回复数据
 		String content = "你好，田先森！";
 		System.out.println(new Date() +":服务端写出数据-> "+content);
 		ByteBuf byteBuf = getByteBuf(ctx , content);
 		ctx.channel().writeAndFlush(byteBuf);
 	}
 
 	private static ByteBuf getByteBuf(ChannelHandlerContext cxt , String content) {
 		
 		// 获取 二进制抽象 ByteBuf
 		ByteBuf byteBuf = cxt.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = content.getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到buf中
 		byteBuf.writeBytes(bs);
 		return byteBuf;
 	}
 }

    2. 现在轮到客户端了 ， 客户端读取数据的逻辑和服务端读数据的逻辑一样 ， 同样是覆盖channelRead() 方法

       class Test_07_ClientHandler extends ChannelInboundHandlerAdapter {
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf byteBuf = (ByteBuf) msg;
 		System.out.println(new Date()+": 客户端读到数据 ->"+ byteBuf.toString(Charset.forName("UTF-8")));
 	}
 
 	@Override
 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
 		
 		String content = "你好，奥特曼！";
 		System.out.println(new Date() + " 客户端写出数据:"+content);
 		
 		// 1. 获取数据
 		ByteBuf buffer = getByteBuf(ctx , content);
 		// 2. 写数据
 		ctx.channel().writeAndFlush(buffer);
 		
 	}
 	
 	private ByteBuf getByteBuf(ChannelHandlerContext ctx , String content ) {
 		// 获取二进制抽象 ByteBuffer
 		ByteBuf buf = ctx.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = content.getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到 buf
 		buf.writeBytes(bs);
 		return buf;
 	}
 
 }

    3. 现在 客户端和服务端就实现了双向通信

      1. 完整代码：

         import java.nio.charset.Charset;
 import java.util.Date;
 import java.util.concurrent.TimeUnit;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 
 public class Test_07_客户端和服务端双向通信 {
 	public static void main(String[] args) throws Exception {
 		Test_07_Server.start(8000);
 		Test_07_Client.start("127.0.0.1", 8000, 5);
 	}
 }
 
 class Test_07_Client {
 	public static void start(String IP, int port, int maxRetry) {
 		NioEventLoopGroup workerGroup = new NioEventLoopGroup();
 
 		Bootstrap bootstrap = new Bootstrap();
 
 		bootstrap.group(workerGroup).channel(NioSocketChannel.class)
 				.handler(new ChannelInitializer<NioSocketChannel>() {
 
 					@Override
 					protected void initChannel(NioSocketChannel ch) throws Exception {
 						// 添加业务处理逻辑  可以添加自定义的业务处理逻辑也可以添加    Netty自带的简单通用的处理逻辑
 						ch.pipeline().addLast(new Test_07_ClientHandler());
 					}
 				});
 		connect(bootstrap, IP, port, maxRetry);
 	}
 
 	private static void connect(Bootstrap bootstrap, String IP, int port, int maxRetry, int... retryIndex) {
 		bootstrap.connect(IP, port).addListener(future -> {
 			int[] finalRetryIndex;
 			if (future.isSuccess()) {
 				System.out.println("客户端连接【"+IP+":"+port+"】成功");
 			} else if (maxRetry == 0) {
 				System.out.println("达到最大重试此时，放弃重试");
 			} else {
 				// 初始化 重试计数
 				if (retryIndex.length == 0) {
 					finalRetryIndex = new int[] { 0 };
 				} else {
 					finalRetryIndex = retryIndex;
 				}
 				// 计算时间间隔
 				int delay = 1 << finalRetryIndex[0];
 				// 执行重试
 				System.out.println(new Date() + " 连接失败，剩余重试次数：" + maxRetry + "," + delay + "秒后执行重试");
 				bootstrap.config().group().schedule(() -> {
 					connect(bootstrap, IP, port, maxRetry - 1, finalRetryIndex[0] + 1);
 				}, delay, TimeUnit.SECONDS);
 			}
 		});
 	}
 }
 
 class Test_07_Server {
 	public static void start(int port) {
 		NioEventLoopGroup bossGroup = new NioEventLoopGroup();
 		NioEventLoopGroup workerGroup = new NioEventLoopGroup();
 
 		ServerBootstrap serverBootstrap = new ServerBootstrap();
 
 		serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
 				.childHandler(new ChannelInitializer<NioSocketChannel>() {
 
 					@Override
 					protected void initChannel(NioSocketChannel ch) throws Exception {
 						ch.pipeline().addLast(new Test_07_ServerHandler());
 					}
 				});
 		bind(serverBootstrap, port);
 		
 	}
 	private static void bind(ServerBootstrap serverBootstrap, int port) {
 		serverBootstrap
 			.bind(port)
 			.addListener(future -> {
 				if(future.isSuccess()) {
 					System.out.println("服务端：端口【"+port+"】绑定成功！");
 				}else {
 					System.out.println("服务端：端口【"+port+"】绑定失败，尝试绑定【"+(port+1)+"】！");
 					bind(serverBootstrap, port+1);
 				}
 			});
 	}
 
 }
 
 class Test_07_ClientHandler extends ChannelInboundHandlerAdapter {
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf byteBuf = (ByteBuf) msg;
 		System.out.println(new Date()+": 客户端读到数据 ->"+ byteBuf.toString(Charset.forName("UTF-8")));
 	}
 
 	@Override
 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
 		
 		String content = "你好，奥特曼！";
 		System.out.println(new Date() + " 客户端写出数据:"+content);
 		
 		// 1. 获取数据
 		ByteBuf buffer = getByteBuf(ctx , content);
 		// 2. 写数据
 		ctx.channel().writeAndFlush(buffer);
 		
 	}
 	
 	private ByteBuf getByteBuf(ChannelHandlerContext ctx , String content ) {
 		// 获取二进制抽象 ByteBuffer
 		ByteBuf buf = ctx.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = content.getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到 buf
 		buf.writeBytes(bs);
 		return buf;
 	}
 
 }
 
 class Test_07_ServerHandler extends ChannelInboundHandlerAdapter{
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf buf = (ByteBuf) msg;
 		System.out.println(new Date() + ": 服务端读到数据->"+ buf.toString(Charset.forName("UTF-8")));
 		
 		// 向客户端回复数据
 		String content = "你好，田先森！";
 		System.out.println(new Date() +":服务端写出数据-> "+content);
 		ByteBuf byteBuf = getByteBuf(ctx , content);
 		ctx.channel().writeAndFlush(byteBuf);
 	}
 
 	private static ByteBuf getByteBuf(ChannelHandlerContext cxt , String content) {
 		
 		// 获取 二进制抽象 ByteBuf
 		ByteBuf byteBuf = cxt.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = content.getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到buf中
 		byteBuf.writeBytes(bs);
 		return byteBuf;
 	}
 	
 }

      2. 执行结果

  7. 总结

    1. 本小节中 ， 我们了解到客户端和服务端的逻辑处理均是在启动的时候 ， 通过给逻辑处理链pipeline添加逻辑处理器 ， 来编写数据的处理逻辑 ， pipeline的逻辑我们会在后面分析
    2. 接下来我们学到了 在客户端连接成功之后会回调逻辑处理器的channelActive()方法 ， 而不管是服务端还是客户端 ， 收到数据之后都会调用channelRead方法
    3. 写数据用writeAndFlush() 方法 客户端与服务端交互的二进制数据载体为ByteBuf , ByteBuf 通过连接的内存管理器创建 ， 字节数据填充到ByteBuf 之后才能写到对端 ， 接下来一小节 ， 我们就重点来分析ByteBuf

  8. 思考： 如何实现在新连接介入的时候 ， 服务端主动向客户端推送消息 ， 客户端回复服务端消息？

    1. 解答： 在服务器端的逻辑处理其中也实现 channelActive() 在有新的连接接入时 会回调此方法

       class Test_07_ServerHandler extends ChannelInboundHandlerAdapter{
 
 	@Override
 	public void channelActive(ChannelHandlerContext ctx) throws Exception {
 		String content = "是不是你连我了？";
 		System.out.println(new Date() +":服务端写出数据-> "+content);
 		ByteBuf byteBuf = getByteBuf(ctx , content);
 		ctx.channel().writeAndFlush(byteBuf);
 	}
 
 	@Override
 	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
 		ByteBuf buf = (ByteBuf) msg;
 		System.out.println(new Date() + ": 服务端读到数据->"+ buf.toString(Charset.forName("UTF-8")));
 		
 		// 向客户端回复数据
 		String content = "你好，田先森！";
 		System.out.println(new Date() +":服务端写出数据-> "+content);
 		ByteBuf byteBuf = getByteBuf(ctx , content);
 		ctx.channel().writeAndFlush(byteBuf);
 	}
 
 	private static ByteBuf getByteBuf(ChannelHandlerContext cxt , String content) {
 		
 		// 获取 二进制抽象 ByteBuf
 		ByteBuf byteBuf = cxt.alloc().buffer();
 		
 		// 准备数据
 		byte[] bs = content.getBytes(Charset.forName("UTF-8"));
 		
 		// 把数据填充到buf中
 		byteBuf.writeBytes(bs);
 		return byteBuf;
 	}
 	
 }
chou_out_man
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Netty 入门与实战：仿写微信 IM 即时通讯系统.zip
02-26
Netty 入门与实战：仿写微信 IM 即时通讯系统
【3. Netty Bootstrap客户端启动类】
W664160450的博客
03-18 685
1.前言 上一节，我们主要讲解了一个Netty入门案例，其中无论是客户端还是服务端的代码编写，都是分为 2 个核心步骤，分别是：启动类模板代码 + 自定义业务 Handler，其中 Handler 可以根据不同的业务定义多个。 本节主要介绍 Bootstrap 客户端启动类的代码含义。 2. Bootstrap流程 客户端启动类的写法都是固定模板的写法，需要掌握几个核心的流程，有助于理解模板代码，具体如下： 指定线程模型：通过.group(group)给引导类(Bootstrap)配置线程组，..
互联网架构（9）：Socket网络通信编程--Netty应用
Jason_LiuMeng的博客
06-01 635
四、Socket网络通信编程–Netty实践1、数据通信一般在项目中我们该如何去使用Netty呢？大体上对于一些参数配置都是根据服务器性能决定的。这个不是最主要的。我们需要考虑的问题是两台机器（甚至多台）使用Netty怎样进行通信，一般分为三种： 1 第一种，使用长连接通道不断开的形式进行通信，也就是服务器和客户端一直处于开启状态，如果服务器性能足够好，并且我们的客户端数量也比较少的情况下，还是可以
Netty网络开发实战：RPC原理与自定义RPC框架
大数据开发、JAVA开发、人工智能AI
02-22 361
Netty网络开发实战：RPC原理与自定义RPC框架
Netty实战（一）Nett的概念及体系结构
一起学习一起进步~
05-16 866
Netty是由JBOSS提供的一个java开源框架，它提供异步的、事件驱动的网络应用程序框架和工具。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。
netty实战（一）聊天服务
weixin_42771401的博客
01-21 523
经典例子，netty聊天服务，用来作为第一个实战来理解netty流程适合不过了。 netty出现是为了方便大家使用NIO来进行编程，特别是socket编程。而很多的socket编程都会有很多的协议，我们此次只是为了体验netty，所以不设置协议，直接裸体读写。
Netty 入门与实战：仿写微信 IM 即时通讯系统
06-26
Netty 入门与实战：仿写微信 IM 即时通讯系统
Netty 入门与实战：仿写微信 IM 即时通讯系统.pdf
06-12
Netty 入门与实战：仿写微信 IM 即时通讯系统
Netty入门与实战：仿写微信IM即时通讯系统
01-12
Netty实现IM通讯
Netty 入门与实战：仿写微信 IM 即时通讯系统.rar
07-16
Netty 入门与实战：仿写微信 IM 即时通讯系统，掘金小册子，netty教程。章节齐全无缺失，排版非常不错。 1.仿微信IM系统简介 1 2.Netty是什么? 2 3.服务端启动流程 8 4.客户端启动流程 11 5.实战:客户端与服务端双向...
Android-基于NettyTCPProtobuf实现的AndroidIM库
08-13
基于Netty TCP Protobuf实现的Android IM库，包含Protobuf序列化、TCP拆包与粘包、长连接握手认证、心跳机制、断线重连机制、消息重发机制、读写超时机制、离线消息、线程池等功能。
Netty+入门与实战：仿写微信+IM+即时通讯系统.txt
09-14
Netty+入门与实战：仿写微信+IM+即时通讯系统 Netty是互联网中间件领域使用最广泛最核心的网络通信框架,几乎所有互联网中间件或者大数据领域均离不开Netty,掌握Netty是作为初中级工程师迈向高级工程师最重要的技能之一
netty通信完整示例
08-27
netty通信完整示例，含jar包，server端，client端，编码器，解码器 本人亲测成功。
netty实战（二）
weixin_42771401的博客
01-22 160
本实战主要目的是想同时处理多种类型对象，以及对handler与channel更深入的理解，之后的部分会多 越多一些实际场景的文章，在决定做新的东西，其实感觉netty该做改用的部分，都体会了到了通过这个例子。本实战主要目的是想同时处理多种类型对象，以及对handler与channel更深入的理解，之后的部分会多 越多一些实际场景的文章，在决定做新的东西，其实感觉netty该做改用的部分，都体会了到了通过这个例子。
Netty最佳实践-数据通信
北辰
10-16 583
使用一种特殊的长连接，在指定某一时间之内，服务器与某台客户端没有任何通信，则断开连接。下次连接则是客户端向服务器发送请求的时候，再次建立连接。
精准突击！2023最新版Java面试短期突击面试题【金典版】我会出手带你拿下Offer
BASK2311的博客
12-31 2711
面试题包括了：Java面试、Spring、MyBatis、ZK、Dubbo、EL、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题。177. 一张自增表里面总共有 7 条数据，删除了最后 2 条数据，重启 MySQL 数据库，又插入了一条数据，此时 id 是几？164. kafka 同时设置了 7天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？session与cookie的区别是什么？
太顶了，使用 Netty 实现了一个 IM 即时通讯系统
芋艿V
09-24 1458
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...
Netty实战 IM即时通讯系统（一）IM系统简介
chou_out_man的博客
12-27 3216
##Netty实战 IM即时通讯系统（一）IM系统简介 零、 目录 IM系统简介 Netty 简介 Netty 环境配置 服务端启动流程 实战： 客户端和服务端双向通信 数据传输载体ByteBuf介绍 客户端与服务端通信协议编解码 实现客户端登录 实现客户端与服务端收发消息 pipeline与channelHandler 构建客户端与服务端pipeline 拆包粘包理论与解决方案 chann...
《netty入门实战:仿写微信im及时通讯系统》
最新发布
10-20
《Netty入门实战: 仿写微信IM即时通讯系统》是一本关于网络编程框架Netty的实践指南。本书以仿写微信IM即时通讯系统为例，通过实际的项目案例引导读者学习和掌握Netty的使用。 Netty是一款基于Java的网络编程框架，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值