SpringBoot+Netty+WebSocket实现消息发送的示例代码

一.导入Netty依赖

<dependency>
   <groupId>io.netty</groupId>
   <artifactId>netty-all</artifactId>
   <version>4.1.25.Final</version>
  </dependency>

二.搭建websocket服务器

@Component
public class WebSocketServer {

 /**
  * 主线程池
  */
 private EventLoopGroup bossGroup;
 /**
  * 工作线程池
  */
 private EventLoopGroup workerGroup;
 /**
  * 服务器
  */
 private ServerBootstrap server;
 /**
  * 回调
  */
 private ChannelFuture future;

 public void start() {
  future = server.bind(9001);
  System.out.println("netty server - 启动成功");
 }

 public WebSocketServer() {
  bossGroup = new NioEventLoopGroup();
  workerGroup = new NioEventLoopGroup();

  server = new ServerBootstrap();
  server.group(bossGroup, workerGroup)
    .channel(NioServerSocketChannel.class)
    .childHandler(new WebsocketInitializer());
 }
}

三.初始化Websocket

public class WebsocketInitializer extends ChannelInitializer<SocketChannel> {

 @Override
 protected void initChannel(SocketChannel ch) throws Exception {
  ChannelPipeline pipeline = ch.pipeline();
  // ------------------
  // 用于支持Http协议
  // ------------------
  // websocket基于http协议,需要有http的编解码器
  pipeline.addLast(new HttpServerCodec());
  // 对写大数据流的支持
  pipeline.addLast(new ChunkedWriteHandler());
  // 添加对HTTP请求和响应的聚合器:只要使用Netty进行Http编程都需要使用
  //设置单次请求的文件的大小
  pipeline.addLast(new HttpObjectAggregator(1024 * 64));
  //webSocket 服务器处理的协议,用于指定给客户端连接访问的路由 :/ws
  pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));
  // 添加Netty空闲超时检查的支持
  // 1. 读空闲超时(超过一定的时间会发送对应的事件消息)
  // 2. 写空闲超时
  // 3. 读写空闲超时
  pipeline.addLast(new IdleStateHandler(4, 8, 12));
  //添加心跳处理
  pipeline.addLast(new HearBeatHandler());
  // 添加自定义的handler
  pipeline.addLast(new ChatHandler());

 }
}

四.创建Netty监听器

@Component
public class NettyListener implements ApplicationListener<ContextRefreshedEvent> {

 @Resource
 private WebSocketServer websocketServer;

 @Override
 public void onApplicationEvent(ContextRefreshedEvent event) {
  if(event.getApplicationContext().getParent() == null) {
   try {
    websocketServer.start();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
 }
}

五.建立消息通道

public class UserChannelMap {
 /**
  * 用户保存用户id与通道的Map对象
  */
// private static Map<String, Channel> userChannelMap;

 /* static {
  userChannelMap = new HashMap<String, Channel>();
 }*/

 /**
  * 定义一个channel组,管理所有的channel
  * GlobalEventExecutor.INSTANCE 是全局的事件执行器,是一个单例
  */
 private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

 /**
  * 存放用户与Chanel的对应信息,用于给指定用户发送消息
  */
 private static ConcurrentHashMap<String,Channel> userChannelMap = new ConcurrentHashMap<>();

 private UserChannelMap(){}
 /**
  * 添加用户id与channel的关联
  * @param userNum
  * @param channel
  */
 public static void put(String userNum, Channel channel) {
  userChannelMap.put(userNum, channel);
 }

 /**
  * 根据用户id移除用户id与channel的关联
  * @param userNum
  */
 public static void remove(String userNum) {
  userChannelMap.remove(userNum);
 }

 /**
  * 根据通道id移除用户与channel的关联
  * @param channelId 通道的id
  */
 public static void removeByChannelId(String channelId) {
  if(!StringUtils.isNotBlank(channelId)) {
   return;
  }
  for (String s : userChannelMap.keySet()) {
   Channel channel = userChannelMap.get(s);
   if(channelId.equals(channel.id().asLongText())) {
    System.out.println("客户端连接断开,取消用户" + s + "与通道" + channelId + "的关联");
    userChannelMap.remove(s);
    UserService userService = SpringUtil.getBean(UserService.class);
    userService.logout(s);
    break;
   }
  }
 }

 /**
  * 打印所有的用户与通道的关联数据
  */
 public static void print() {
  for (String s : userChannelMap.keySet()) {
   System.out.println("用户id:" + s + " 通道:" + userChannelMap.get(s).id());
  }
 }

 /**
  * 根据好友id获取对应的通道
  * @param receiverNum 接收人编号
  * @return Netty通道
  */
 public static Channel get(String receiverNum) {
  return userChannelMap.get(receiverNum);
 }

 /**
  * 获取channel组
  * @return
  */
 public static ChannelGroup getChannelGroup() {
  return channelGroup;
 }

 /**
  * 获取用户channel map
  * @return
  */
 public static ConcurrentHashMap<String,Channel> getUserChannelMap(){
  return userChannelMap;
 }
}

六.自定义消息类型

public class Message {
 /**
  * 消息类型
  */
 private Integer type;
 /**
  * 聊天消息
  */
 private String message;
 /**
  * 扩展消息字段
  */
 private Object ext;
 public Integer getType() {
  return type;
 }

 public void setType(Integer type) {
  this.type = type;
 }

 public MarketChatRecord getChatRecord() {
  return marketChatRecord;
 }
 public void setChatRecord(MarketChatRecord chatRecord) {
  this.marketChatRecord = chatRecord;
 }

 public Object getExt() {
  return ext;
 }

 public void setExt(Object ext) {
  this.ext = ext;
 }

 @Override
 public String toString() {
  return "Message{" +
    "type=" + type +
    ", marketChatRecord=" + marketChatRecord +
    ", ext=" + ext +
    '}';
 }

}

七.创建处理消息的handler

public class ChatHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
 private static final Logger log = LoggerFactory.getLogger(WebSocketServer.class);

 /**
  * 用来保存所有的客户端连接
  */
 private static ChannelGroup clients = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

 /**
  *当Channel中有新的事件消息会自动调用
  */
 @Override
 protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
  // 当接收到数据后会自动调用
  // 获取客户端发送过来的文本消息
  Gson gson = new Gson();
  log.info("服务器收到消息:{}",msg.text());
  System.out.println("接收到消息数据为:" + msg.text());
  Message message = gson.fromJson(msg.text(), Message.class);
//根据业务要求进行消息处理
  switch (message.getType()) {
   // 处理客户端连接的消息
   case 0:
    // 建立用户与通道的关联
   // 处理客户端发送好友消息
    break;
   case 1:
   // 处理客户端的签收消息
    break;
   case 2:
    // 将消息记录设置为已读
    break;
   case 3:
    // 接收心跳消息
    break;
   default:
    break;
  }

 }

 // 当有新的客户端连接服务器之后,会自动调用这个方法
 @Override
 public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
  log.info("handlerAdded 被调用"+ctx.channel().id().asLongText());
  // 添加到channelGroup 通道组
  UserChannelMap.getChannelGroup().add(ctx.channel());
//  clients.add(ctx.channel());
 }

 @Override
 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
  log.info("{异常:}"+cause.getMessage());
  // 删除通道
  UserChannelMap.getChannelGroup().remove(ctx.channel());
  UserChannelMap.removeByChannelId(ctx.channel().id().asLongText());
  ctx.channel().close();
 }

 @Override
 public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
  log.info("handlerRemoved 被调用"+ctx.channel().id().asLongText());
  //删除通道
  UserChannelMap.getChannelGroup().remove(ctx.channel());
  UserChannelMap.removeByChannelId(ctx.channel().id().asLongText());
  UserChannelMap.print();
 }

}

八.处理心跳

public class HearBeatHandler extends ChannelInboundHandlerAdapter {

 @Override
 public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
  if(evt instanceof IdleStateEvent) {
   IdleStateEvent idleStateEvent = (IdleStateEvent)evt;

   if(idleStateEvent.state() == IdleState.READER_IDLE) {
    System.out.println("读空闲事件触发...");
   }
   else if(idleStateEvent.state() == IdleState.WRITER_IDLE) {
    System.out.println("写空闲事件触发...");
   }
   else if(idleStateEvent.state() == IdleState.ALL_IDLE) {
    System.out.println("---------------");
    System.out.println("读写空闲事件触发");
    System.out.println("关闭通道资源");
    ctx.channel().close();
   }
  }
 }
}

搭建完成后调用测试

1.页面访问http://localhost:9001/ws
 2.端口号9001和访问路径ws都是我们在上边配置的,然后传入我们自定义的消息message类型。
3.大概流程:消息发送 :用户1先连接通道,然后发送消息给用户2,用户2若是在线直接可以发送给用户,若没在线可以将消息暂存在redis或者通道里,用户2链接通道的话,两者可以直接通讯。
消息推送 :用户1连接通道,根据通道id查询要推送的人是否在线,或者推送给所有人,这里我只推送给指定的人。

到此这篇关于SpringBoot+Netty+WebSocket实现消息发送的示例代码的文章就介绍到这了,更多相关SpringBoot Netty WebSocket消息发送内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot+WebSocket+Netty实现消息推送的示例代码

    上一篇文章讲了Netty的理论基础,这一篇讲一下Netty在项目中的应用场景之一:消息推送功能,可以满足给所有用户推送,也可以满足给指定某一个用户推送消息,创建的是SpringBoot项目,后台服务端使用Netty技术,前端页面使用WebSocket技术. 大概实现思路: 前端使用webSocket与服务端创建连接的时候,将用户ID传给服务端 服务端将用户ID与channel关联起来存储,同时将channel放入到channel组中 如果需要给所有用户发送消息,直接执行channel组的writ

  • SpringBoot+Netty+WebSocket实现消息发送的示例代码

    一.导入Netty依赖 <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.25.Final</version> </dependency> 二.搭建websocket服务器 @Component public class WebSocketServer { /** * 主线程池 */

  • Springboot+Netty+Websocket实现消息推送实例

    前言 WebSocket 使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据.在 WebSocket API 中,浏览器和服务器只需要完成一次握手,两者之间就直接可以创建持久性的连接,并进行双向数据传输. Netty框架的优势 1. API使用简单,开发门槛低:  2. 功能强大,预置了多种编解码功能,支持多种主流协议:  3. 定制能力强,可以通过ChannelHandler对通信框架进行灵活地扩展:  4. 性能高,通过与其他业界主流的NIO框架对比,Netty的综

  • SpringBoot+Netty实现简单聊天室的示例代码

    目录 一.实现 1.User类 2.SocketSession类 3.SessionGroup 4.WebSocketTextHandler类 5.WebSocketServer类 6.index.html 二.效果 一.实现 1.User类 import java.util.Objects; public class User {     public String id;     public String nickname;     public User(String id, Strin

  • SpringBoot+RabbitMQ方式收发消息的实现示例

    本篇会和SpringBoot做整合,采用自动配置的方式进行开发,我们只需要声明RabbitMQ地址就可以了,关于各种创建连接关闭连接的事都由Spring帮我们了~ 交给Spring帮我们管理连接可以让我们专注于业务逻辑,就像声明式事务一样易用,方便又高效. 祝有好收获,先赞后看,快乐无限. 本文代码:   https://gitee.com/he-erduo/spring-boot-learning-demo https://github.com/he-erduo/spring-boot-lea

  • SpringBoot实现邮件发送的示例代码

    工具类: package com.lhh.utils; import com.lhh.bean.EmailEntity; import javax.mail.*; import javax.mail.internet.InternetAddress; import javax.mail.internet.MimeMessage; import java.util.Properties; /** * @author liuhuanhuan * @version 1.0 * @date 2021/4

  • SpringBoot实现阿里云短信发送的示例代码

    阿里云accessID和secret请自行进入阿里云申请 sms.template.code 请进入阿里云,进行短信服务进行魔板添加 开源代码地址在文章末尾 话不多说,直接上代码: application.properties: server.port=8002 #server.servlet.context-path=/ spring.datasource.url=jdbc:mysql://localhost:3306/ssm_message?useUnicode=true&character

  • SpringBoot整合RocketMQ实现消息发送和接收的详细步骤

    我们使用主流的SpringBoot框架整合RocketMQ来讲解,使用方便快捷: 最终项目结构如下: 具体步骤如下: 第一步:新建SpringBoot项目rocketmq-test,引入rocketmq依赖,以及项目配置 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <vers

  • PHP实现RabbitMQ消息列队的示例代码

    目录 业务场景 1.首先部署好thinkphp6框架 2.安装workerman扩展 3.生产者 4.消费者 5.整体测试 业务场景 项目公司是主php做开发的,框架为thinkphp.众所周知,php本身的运行效率存在一定的缺陷,所以如果有一个很复杂很耗时的业务时,必须开发一个常驻内存的程序.首先我想到了php的workerman与swoole,但是这里应上面的标题哈,想将耗时任务交给另一个服务器,同时列队处理.所以这里我想独立部署一个rabbitMQ服务器用于处理列队任务. 当rabbitM

  • springboot整合@Retryable实现重试功能的示例代码

    目录 前言 @Retryable 简介 使用步骤 1.引入依赖 2.启用@Retryable 3.添加@Retryable注解 4.测试 注意事项 最后 结语 前言 在实际工作中,重试机制是一个很常见的场景,比如:发送消息失败,下载网络文件失败等…,因为这些错误可能是网络波动造成的,等待一些延迟就能成功处理.我们通常会使用try/catch.while循环等进行相关处理,但是这样看起来比较臃肿复杂,且不好看.于是就有了spring提供的重试模块—— @Retryable @Retryable 简

  • Python实现RabbitMQ6种消息模型的示例代码

    RabbitMQ与Redis对比 ​ RabbitMQ是一种比较流行的消息中间件,之前我一直使用redis作为消息中间件,但是生产环境比较推荐RabbitMQ来替代Redis,所以我去查询了一些RabbitMQ的资料.相比于Redis,RabbitMQ优点很多,比如: 具有消息消费确认机制 队列,消息,都可以选择是否持久化,粒度更小.更灵活. 可以实现负载均衡 RabbitMQ应用场景 异步处理:比如用户注册时的确认邮件.短信等交由rabbitMQ进行异步处理 应用解耦:比如收发消息双方可以使用

随机推荐