netty简单实现聊天功能

最新推荐文章于 2024-07-22 15:37:32 发布
最新推荐文章于 2024-07-22 15:37:32 发布
阅读量953 收藏 2
点赞数
分类专栏： 后端 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/an341221/article/details/84322357
版权

1、服务端

package mynetty_study.netty.nettytest;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 *类名：NettyServer.java
 *类的描述信息：
 *创建时间：上午11:42:00
 **/
public class NettyServer {
	
	//创建用于接收客户端连接请求
	private static final EventLoopGroup bossGroup = new NioEventLoopGroup();
	//创建用于处理Socketchannel输入输出的
	private static final EventLoopGroup handleGroup = new NioEventLoopGroup();
	private static final int port = 8888;
	
	public static void main(String[] args) {
		ServerBootstrap serverBootstrap = new ServerBootstrap();
		//设置group
		serverBootstrap.group(bossGroup, handleGroup)
		//设置要被实例化的类
		.channel(NioServerSocketChannel.class)
		//设置Channel处理器
		.childHandler(new ChannelInitializer<Channel>(){

			@Override
			protected void initChannel(Channel ch) throws Exception {
				ChannelPipeline cp = ch.pipeline();
				//添加帧限定符来防止粘包
				//粘包：
				//	只有TCP有粘包现象，UDP永远不会粘包
				//	发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会当做一个包发出去，产生粘包）
				//	接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）
				cp.addLast(new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE,0,4,0,4))
				//配置编解码
				.addLast(new StringDecoder(CharsetUtil.UTF_8))
				.addLast(new StringEncoder(CharsetUtil.UTF_8))
				//配置业务逻辑实现类
				.addLast(new TCPServerHandler());
				
			}
			
		});
		
		try {
			ChannelFuture future = serverBootstrap.bind(port).sync();
			future.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		
	}
}

package mynetty_study.netty.nettytest;

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.socket.SocketChannel;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
/**
 *类名：TCPServerHandler.java
 *类的描述信息：
 *服务相关的设置的代码写完之后，我们再来编写主要的业务代码。 使⽤用Netty编写 [业务层 ]的代码，
 *我们需要继承 ChannelInboundHandlerAdapter 或 SimpleChannelInboundHandler 类，在这
 *里里顺便便说下它们两的区别吧。 继承 SimpleChannelInboundHandler 类之后，会在接收到数据后会
 *自动 release 掉数据占⽤用的 Bytebuffer 资源。并且继承该类需要指定数据格式。 ⽽而继
 *承ChannelInboundHandlerAdapter 则不不会⾃自动释放，需要⼿手动调⽤用
 *ReferenceCountUtil.release() 等⽅方法进⾏行行释放。继承该类不不需要指定数据格式。 所以在这⾥里里，个⼈人
 *推荐服务端继承 ChannelInboundHandlerAdapter ，⼿手动进⾏行行释放，防⽌止数据未处理理完就⾃自动释放
 *了了。而且服务端可能有多个客户端进⾏行行连接，并且每⼀一个客户端请求的数据格式都不不⼀一致，这时便便可
 *以进行相应的处理理。 客户端根据情况可以继承 SimpleChannelInboundHandler 类。好处是直接指
 *定好传输的数据格式，就不不需要再进⾏行行格式的转换了了
 *创建时间：下午2:28:03
 **/
public class TCPServerHandler extends ChannelInboundHandlerAdapter {

	//连接成功时候执行的操作
	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		//System.out.println("连接成功");
	}
	//执行读写
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		//执行会话
		System.out.println("客户端："+msg);
		System.out.print("我：");
		Scanner scan = new Scanner(System.in);
		String str = scan.next();
		ctx.channel().writeAndFlush(str);
		ctx.close();
	}
	//异常处理
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		System.out.println("打印异常日志："+cause.getStackTrace());
	}
	
}

2、客户端

package mynetty_study.netty.nettytest;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

import java.util.Scanner;

import mynetty_study.netty.netty1.MyClient;

/**
 *类名：NettyClient.java
 *类的描述信息：
 *创建时间：下午7:55:30
 **/
public class NettyClient implements Runnable{

	private static final int port = 8888;
	private static final String ip = "127.0.0.1";

	
	public static void main(String[] args) {
		new Thread(new NettyClient()).start();
	}

	@Override
	public void run() {
		EventLoopGroup group = new NioEventLoopGroup();
		try {
			Bootstrap boot = new Bootstrap();
			//设置group
			boot.group(group);
			//设置要被实例化的类
			boot.channel(NioSocketChannel.class)
			//设置TCP方式的通信
			.option(ChannelOption.TCP_NODELAY, true)
			//设置SocketChannel处理器
			.handler(new ChannelInitializer<SocketChannel>(){

				@Override
				protected void initChannel(SocketChannel ch) throws Exception {
					ChannelPipeline pipeline = ch.pipeline();
					pipeline.addLast(new LengthFieldPrepender(4));
					//设置编解码
					pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
					pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
					pipeline.addLast(new TcpClient());
				}

			});



			//执行会话
			boolean check = true;
			while(check){
				ChannelFuture future = boot.connect(ip, port).sync();
				System.out.print("我：");
				Scanner sc=new Scanner(System.in);
				String str=sc.next();
				future.channel().writeAndFlush(str);
				future.channel().closeFuture().sync();
				if(str.equals("bye")){
					check=false;
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}finally{
			group.shutdownGracefully();
		}




	}

}

package mynetty_study.netty.nettytest;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class TcpClient extends ChannelInboundHandlerAdapter {

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		System.out.println("服务端："+msg);
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		System.out.println(cause.getStackTrace());
	}

}

3、效果

欣赏月光
关注
专栏目录
使用最新Netty实现一个简单的聊天程序
anxpp的博客
08-06 1万+
1、概述 Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 官网：http://netty.io/ 目前最新的是版本是4.1.4（5.x版本官网已经弃用，不推荐使用）。 Netty4.x同时也是原生支持Android的，所以后面的程序，放到android上也是可以正常运行的（亲测）。 项目如果使用Maven开发，直接添加以下依赖即可： <dependen
Netty 实现聊天功能
...
05-17 1336
http://waylau.com/netty-chat/ Netty 是一个 Java NIO 客户端服务器框架，使用它可以快速简单地开发网络应用程序，比如服务器和客户端的协议。Netty 大大简化了网络程序的开发过程比如 TCP 和 UDP 的 socket 服务的开发。更多关于 Netty 的知识，可以参阅《Netty 4.x 用户指南》（https://githu
使用Springboot + netty 打造聊天服务（一）
最新发布
Java 技术专栏，从入门到精通，熟悉企业级开发
07-22 4425
/ 处理收到的消息 System . out . println("Received message: " + msg);} }// 处理收到的消息 System . out . println("Received message: " + msg);} }// 处理收到的消息 System . out . println("Received message: " + msg);
Netty 实战：实现基本聊天功能
小牛肉的博客
12-17 1579
???? 实例：Netty 实现聊天功能 ???? 本文属于 CS-Wiki 仓库中教程的一篇文章，有些知识点在之前的文章中已经详细解释过，如果不了解的话可前来学习：⭐ CS-Wiki（Gitee 推荐项目）仓库地址 本项目基于： Java 8 IDEA 2020 Netty 4.1.42 1. 新建项目并导入依赖 新建一个 Maven 项目并导入 Netty 4 依赖： <dependencies> <dependency> <group
用netty实现聊天
leese233的博客
05-17 963
用netty实现聊天
netty实现的聊天代码
10-23
总的来说，这个 Netty 聊天应用 demo 展示了如何利用 Netty 的强大功能，用 Java 实现一个简单的聊天服务器和客户端。通过阅读和学习这个代码，你可以掌握 Netty 的基本架构，包括服务器和客户端的创建、事件驱动...
Netty实现WebSocket聊天功能
11-08
websocket是基于长连接的通讯技术,而netty是一个专门实现websocket的框架,使得搭建websocket更简单稳定.这里介绍了如何用netty框架实现websocket的聊天功能,文档中含有具体源码及详细说明
基于java GUI界面的简易netty聊天室（实现群聊和私聊）
11-18
【标题】基于Java GUI界面的简易Netty聊天室实现了群聊和私聊功能，通过集成FastJSON库处理JSON格式的数据编码与解码。这个项目旨在为用户提供一个简单易用的聊天平台，用户可以通过图形化界面进行实时通信。下面将...
springboot+netty 实现简单的一对一聊天
04-24
WebSocket是一种在单个TCP连接上进行全双工通信的协议，允许服务器和客户端进行实时、低延迟的双向通信，非常适合实现聊天应用。在Spring Boot中，我们可以使用Spring WebSocket来处理WebSocket连接。 1. **配置...
Netty实现简单的聊天消息群发功能
12-12
在实现聊天功能时，我们需要定义两个关键组件：服务器端的处理器和客户端的处理器。服务器端处理器通常继承自`ChannelInboundHandlerAdapter`，负责接收客户端发送的消息并广播给其他客户端。客户端处理器则继承自`...
netty实现简单的聊天
08-09
简单的聊天，是通过netty实现的，包括断线重新连接，初始化管道等等……
springmvc+netty实现聊天功能
04-01
springmvc+netty实现聊天功能，简单的demo,包含网页端的代码
基于netty实现简单的聊天
Alaskan_Husky的博客
11-24 1045
这些组件共同构成了Netty的核心架构，使其成为一个强大、灵活、可扩展的网络编程框架。Netty的设计理念主要围绕着事件驱动、非阻塞、可重用的组件，使得它适用于构建高性能、可靠性强的网络应用程序。创建两个EventLoopGroup，一个用于处理连接的事件，另一个用于处理已经接受的连接的事件。通过这种方式，你可以添加自己的业务逻辑处理器，实现具体的通信需求。它们是Netty的启动类，负责配置和启动Netty应用。在项目中引入Netty的相关依赖，通常通过构建工具（如Maven或Gradle）来管理。
Netty代码基本使用及调用流程
逍遥生
03-30 734
为什么要使用netty？ NIO 的类库和 API 繁杂， 使用麻烦； 开发工作量和难度都非常大，异常处理繁琐 Netty对NIO进行了良好的封装，解决了NIO中繁琐的工作。 netty使用场景 Dubbo，RocketMQ等分布式系统中，各个节点之间需要远程服务调用。 代码 服务端 public class NettyServer { public static void main(String[] args) throws Exception { // bos
使用netty实现聊天功能
ali_lili的博客
04-05 4837
前言 学习Java总是离不开网络编程的，真是觉得越学习越发现自己很菜，不会的东西还很多，该学习的东西还很多，我的学习就是靠网上各位大佬分享的博客，还有找一些免费视频，当然也会去图书馆借一些书，废话不多说，就歇一歇最近学习的netty框架吧 netty是什么 我所理解的netty，就是一个比较底层的网络编程的框架，它和tomcat的区别是什么呢？就是tomcat是一个已经封装好的容器，你可以直接使用...
Netty实现在线聊天
q438944209的博客
12-02 553
Netty作为当前最流行的网络通讯框架。从一个最简单的实例去了解...
基于Netty实现聊天功能
weixin_40727749的博客
01-26 164
服务端： public class ChatNettyServer { public static void main(String[] args) throws InterruptedException { // System.out.println(Math.max(1, SystemPropertyUtil.getInt("io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2)));
用java + netty 实现一个聊天室功能
04-01
首先，需要了解什么是Netty。Netty是一个异步事件驱动的网络应用框架，用于快速开发可维护的高性能协议服务器和客户端。 接下来，我们可以开始实现聊天室功能。一个简单的聊天室应该具备以下功能： 1. 用户连接和断开连接的处理； 2. 用户发送消息和接收消息的处理； 3. 消息广播给所有在线用户。 下面是一个简单的实现： 1. 用户连接和断开连接的处理 Netty提供了ChannelHandlerAdapter和ChannelInboundHandlerAdapter两个抽象类，我们可以继承其中一个来实现自己的Handler。这里我们使用ChannelInboundHandlerAdapter。 ```java public class ChatServerHandler extends ChannelInboundHandlerAdapter { // 用户列表，用于保存所有连接的用户 private static List<Channel> channels = new ArrayList<>(); // 新用户连接时，将连接加入用户列表 @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { channels.add(ctx.channel()); System.out.println(ctx.channel().remoteAddress() + " 上线了"); } // 用户断开连接时，将连接从用户列表中移除 @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { channels.remove(ctx.channel()); System.out.println(ctx.channel().remoteAddress() + " 下线了"); } } ``` 2. 用户发送消息和接收消息的处理 Netty的数据传输是通过ByteBuf来实现的，因此我们需要将ByteBuf转换为字符串进行处理。 ```java public class ChatServerHandler extends ChannelInboundHandlerAdapter { // 用户列表，用于保存所有连接的用户 private static List<Channel> channels = new ArrayList<>(); // 新用户连接时，将连接加入用户列表 @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { channels.add(ctx.channel()); System.out.println(ctx.channel().remoteAddress() + " 上线了"); } // 用户断开连接时，将连接从用户列表中移除 @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { channels.remove(ctx.channel()); System.out.println(ctx.channel().remoteAddress() + " 下线了"); } // 接收用户发送的消息并处理 @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf buf = (ByteBuf) msg; String received = buf.toString(CharsetUtil.UTF_8); System.out.println(ctx.channel().remoteAddress() + ": " + received); broadcast(ctx, received); } // 将消息广播给所有在线用户 private void broadcast(ChannelHandlerContext ctx, String msg) { for (Channel channel : channels) { if (channel != ctx.channel()) { channel.writeAndFlush(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8)); } } } } ``` 3. 消息广播给所有在线用户 我们可以使用broadcast方法将接收到的消息广播给所有在线用户。 ```java public class ChatServerHandler extends ChannelInboundHandlerAdapter { // 用户列表，用于保存所有连接的用户 private static List<Channel> channels = new ArrayList<>(); // 新用户连接时，将连接加入用户列表 @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { channels.add(ctx.channel()); System.out.println(ctx.channel().remoteAddress() + " 上线了"); } // 用户断开连接时，将连接从用户列表中移除 @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { channels.remove(ctx.channel()); System.out.println(ctx.channel().remoteAddress() + " 下线了"); } // 接收用户发送的消息并处理 @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { ByteBuf buf = (ByteBuf) msg; String received = buf.toString(CharsetUtil.UTF_8); System.out.println(ctx.channel().remoteAddress() + ": " + received); broadcast(ctx, received); } // 将消息广播给所有在线用户 private void broadcast(ChannelHandlerContext ctx, String msg) { for (Channel channel : channels) { if (channel != ctx.channel()) { channel.writeAndFlush(Unpooled.copiedBuffer(msg, CharsetUtil.UTF_8)); } } } } ``` 接下来我们需要编写一个启动类，用于启动聊天室服务器。 ```java public class ChatServer { public static void main(String[] args) throws Exception { // 创建EventLoopGroup EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { // 创建ServerBootstrap ServerBootstrap serverBootstrap = new ServerBootstrap(); serverBootstrap.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws Exception { ch.pipeline().addLast(new ChatServerHandler()); } }); // 启动服务器 ChannelFuture channelFuture = serverBootstrap.bind(8888).sync(); System.out.println("服务器启动成功"); // 关闭服务器 channelFuture.channel().closeFuture().sync(); } finally { bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully(); } } } ``` 现在，我们就完成了一个简单的聊天室服务器。可以通过运行ChatServer类启动服务器，然后使用telnet命令连接服务器进行聊天。 ```sh telnet localhost 8888 ``` 输入发送的消息，即可将消息广播给所有在线用户。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值