Springboot+Netty+Websocket实现消息推送实例_springboot + netty +websocket 实现推送消息(1)

最新推荐文章于 2024-08-01 02:25:33 发布
最新推荐文章于 2024-08-01 02:25:33 发布
阅读量469 收藏 5
点赞数 4
文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84976585/article/details/138961767
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

前言

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

Netty框架的优势

 1. API使用简单，开发门槛低；
 2. 功能强大，预置了多种编解码功能，支持多种主流协议；
 3. 定制能力强，可以通过ChannelHandler对通信框架进行灵活地扩展；
 4. 性能高，通过与其他业界主流的NIO框架对比，Netty的综合性能最优；
 5. 成熟、稳定，Netty修复了已经发现的所有JDK NIO BUG，业务开发人员不需要再为NIO的BUG而烦恼

提示：以下是本篇文章正文内容，下面案例可供参考

一、引入netty依赖

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

二、使用步骤

1.引入基础配置类

package com.test.netty;

public enum Cmd {
    START("000", "连接成功"),
    WMESSAGE("001", "消息提醒"),
    ;
    private String cmd;
    private String desc;

    Cmd(String cmd, String desc) {
        this.cmd = cmd;
        this.desc = desc;
    }

    public String getCmd() {
        return cmd;
    }

    public String getDesc() {
        return desc;
    }
}

2.netty服务启动监听器

package com.test.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

/\*\*
 \* @author test
 \* <p>
 \* 服务启动监听器
 \*\*/
@Slf4j
@Component
public class NettyServer {

    @Value("${server.netty.port}")
    private int port;

    @Autowired
    private ServerChannelInitializer serverChannelInitializer;

    @Bean
    ApplicationRunner nettyRunner() {
        return args -> {
            //new 一个主线程组
            EventLoopGroup bossGroup = new NioEventLoopGroup(1);
            //new 一个工作线程组
            EventLoopGroup workGroup = new NioEventLoopGroup();
            ServerBootstrap bootstrap = new ServerBootstrap()
                    .group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(serverChannelInitializer)
                    //设置队列大小
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    // 两小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
            //绑定端口,开始接收进来的连接
            try {
                ChannelFuture future = bootstrap.bind(port).sync();
                log.info("服务器启动开始监听端口: {}", port);
                future.channel().closeFuture().sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //关闭主线程组
                bossGroup.shutdownGracefully();
                //关闭工作线程组
                workGroup.shutdownGracefully();
            }
        };
    }
}

3.netty服务端处理器

package com.test.netty;

import com.test.common.util.JsonUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.net.URLDecoder;
import java.util.\*;

/\*\*
 \* @author test
 \* <p>
 \* netty服务端处理器
 \*\*/
@Slf4j
@Component
@ChannelHandler.Sharable
public class NettyServerHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    @Autowired
    private ServerChannelCache cache;
    private static final String dataKey = "test=";

    @Data
    public static class ChannelCache {
    }


    /\*\*
 \* 客户端连接会触发
 \*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        log.info("通道连接已打开，ID->{}......", channel.id().asLongText());
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
            Channel channel = ctx.channel();
            WebSocketServerProtocolHandler.HandshakeComplete handshakeComplete = (WebSocketServerProtocolHandler.HandshakeComplete) evt;
            String requestUri = handshakeComplete.requestUri();
            requestUri = URLDecoder.decode(requestUri, "UTF-8");
            log.info("HANDSHAKE\_COMPLETE，ID->{}，URI->{}", channel.id().asLongText(), requestUri);
            String socketKey = requestUri.substring(requestUri.lastIndexOf(dataKey) + dataKey.length());
            if (socketKey.length() > 0) {
                cache.add(socketKey, channel);
                this.send(channel, Cmd.DOWN_START, null);
            } else {
                channel.disconnect();
                ctx.close();
            }
        }
        super.userEventTriggered(ctx, evt);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        log.info("通道连接已断开，ID->{}，用户ID->{}......", channel.id().asLongText(), cache.getCacheId(channel));
        cache.remove(channel);
    }

    /\*\*
 \* 发生异常触发
 \*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        Channel channel = ctx.channel();
        log.error("连接出现异常，ID->{}，用户ID->{}，异常->{}......", channel.id().asLongText(), cache.getCacheId(channel), cause.getMessage(), cause);
        cache.remove(channel);
        ctx.close();
    }

    /\*\*
 \* 客户端发消息会触发
 \*/
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        try {
            // log.info("接收到客户端发送的消息：{}", msg.text());
            ctx.channel().writeAndFlush(new TextWebSocketFrame(JsonUtil.toString(Collections.singletonMap("cmd", "100"))));
        } catch (Exception e) {
            log.error("消息处理异常：{}", e.getMessage(), e);
        }
    }

    public void send(Cmd cmd, String id, Object obj) {
        HashMap<String, Channel> channels = cache.get(id);
        if (channels == null) {
            return;
        }
        Map<String, Object> data = new LinkedHashMap<>();
        data.put("cmd", cmd.getCmd());
        data.put("data", obj);
        String msg = JsonUtil.toString(data);
        log.info("服务器下发消息: {}", msg);
        channels.values().forEach(channel -> {
            channel.writeAndFlush(new TextWebSocketFrame(msg));
        });
    }

    public void send(Channel channel, Cmd cmd, Object obj) {
        Map<String, Object> data = new LinkedHashMap<>();
        data.put("cmd", cmd.getCmd());
        data.put("data", obj);
        String msg = JsonUtil.toString(data);
        log.info("服务器下发消息: {}", msg);
        channel.writeAndFlush(new TextWebSocketFrame(msg));
    }

}

4.netty服务端缓存类

package com.test.netty;

import io.netty.channel.Channel;
import io.netty.util.AttributeKey;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;

@Component
public class ServerChannelCache {
    private static final ConcurrentHashMap<String, HashMap<String, Channel>> CACHE_MAP = new ConcurrentHashMap<>();
    private static final AttributeKey<String> CHANNEL_ATTR_KEY = AttributeKey.valueOf("test");

    public String getCacheId(Channel channel) {
        return channel.attr(CHANNEL_ATTR_KEY).get();
    }

    public void add(String cacheId, Channel channel) {
        channel.attr(CHANNEL_ATTR_KEY).set(cacheId);
        HashMap<String, Channel> hashMap = CACHE_MAP.get(cacheId);
        if (hashMap == null) {
            hashMap = new HashMap<>();
        }
        hashMap.put(channel.id().asShortText(), channel);
        CACHE_MAP.put(cacheId, hashMap);
    }

    public HashMap<String, Channel> get(String cacheId) {
        if (cacheId == null) {
            return null;
        }
        return CACHE_MAP.get(cacheId);
    }

    public void remove(Channel channel) {
        String cacheId = getCacheId(channel);
        if (cacheId == null) {
            return;
        }
        HashMap<String, Channel> hashMap = CACHE_MAP.get(cacheId);
        if (hashMap == null) {
            hashMap = new HashMap<>();
        }
        hashMap.remove(channel.id().asShortText());
        CACHE_MAP.put(cacheId, hashMap);


![img](https://img-blog.csdnimg.cn/img_convert/acc56cf1945f076bd132170adce7b61b.png)
![img](https://img-blog.csdnimg.cn/img_convert/7ed53aae13cb30177f8cfd4d90749b91.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

put(cacheId, hashMap);


[外链图片转存中...(img-aUmX6tLa-1715842680375)]
[外链图片转存中...(img-V8yNvlq0-1715842680375)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84976585
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
巧用SpringBoot+Netty+WebSocket实现消息推送
chenxuyuana的博客
07-25 899
Netty 是一个利用 Java 的高级网络的能力，隐藏底层的复杂性而提供一个易于使用/使用其服务器的 API 的客户端框架。基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro视频教程：https://doc.iocoder.cn/video
实用水文篇--SpringBoot整合Netty实现消息推送服务器
`or 1 or 不正经の泡泡
10-16 3529
由于今天是要练车的，所以的话只能写一点简单的东西了，做一个整合吧，刚好先前随便说了一下Netty是吧，那么我们就直接实战吧，我们来整合一下Netty。我的设想是使用Netty来实现客户端消息的实时推送，就是这个破玩意：当然还有咱们的聊天，用户聊天，反正都做推送了，再加一个用户聊天有何不可。都TM是一个玩意。那么既然咱们是使用SpringBoot或者是Spring的话，那么我们就刚好直接使用IOC来实例化咱们的Netty。
Spring Boot 整合 Netty + WebSocket 实时消息推送
03-14
1、基于Spring Boot 实现的WebSocket实时数据通信Demo 2、结合Netty实现多客户端之间进行网络通信 3、在Web端建立多客户端之间的通信机制
基于 SpringBoot 和 Netty 实现消息推送，中心服务器推送到不同用户群体
最新发布
服务员的博客
08-01 565
【代码】基于 SpringBoot 和 Netty 实现消息推送，中心服务器推送到不同用户群体。
SpringBoot2+Netty+WebSocket(netty实现websocket，支持URL参数)
热门推荐
★【World Of Moshow 郑锴】★
06-12 19万+
关于Netty Netty 是一个利用 Java 的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架。 MAVEN依赖 <dependencies> <!-- https://mvnrepository.com/artifact/io.netty/netty-all --> <dependency> <g...
SpringBoot整合Netty+Websocket实现消息推送
qq_54421200的博客
01-13 2869
SpringBoot整合Netty+Websocket实现消息推送，非常适合于聊天系统，并且也易于上手，扩展方便
Java实战：Spring Boot+Netty+Websocket实现后台向前端推送信息
oandy0的博客
03-08 3629
本文将详细介绍如何使用Spring Boot集成Netty和Websocket，实现后台向前端推送信息的功能。我们将深入探讨Netty和Websocket的原理，以及如何利用Spring Boot简化Netty的集成和配置。
springboot工程基于netty-socketio的 web推送消息简单代码
08-02
基于springboot工程依赖的netty-socketio实现的web页面消息推送服务实现
SpringBoot+WebSocket+Netty实现消息推送的示例代码
08-19
在本文中，我们将深入探讨如何使用SpringBoot、WebSocket和Netty来实现消息推送功能。首先，让我们了解一下这三个组件的关键概念。 SpringBoot是一个流行的Java框架，它简化了Spring应用程序的开发，提供了快速启动...
springboot+netty+websocket+redis
03-08
**SpringBoot+Netty+WebSocket+Redis：构建分布式实时聊天应用** 在当今的互联网世界中，实时通信和数据共享是许多应用程序的核心需求。Spring Boot作为一款流行的Java框架，因其简洁的配置和快速开发特性而备受...
SpringBoot+Netty+WebSocket 如何实现消息推送
资料免费分享，点击名片
07-25 288
Netty 是一个利用 Java 的高级网络的能力，隐藏底层的复杂性而提供一个易于使用/使用其服务器的 API 的客户端框架。基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro视频教程：https://doc.iocoder.cn/video
Spring+Netty+WebSocket实例
12-06
Spring+Netty+WebSocket实例，通用性还行，比较贴近生产，注释什么写的比较全
Springboot+Netty+Websocket实现消息推送实例
Java0258的博客
02-06 340
前言 WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。 Netty框架的优势 1.API使用简单，开发门槛低； 2.功能强大，预置了多种编解码功能，支持多种主流协议； 3.定制能力强，可以通过ChannelHandler对通信框架进行灵活地扩展； 4.性能高，通过与其他业界主流的NIO框架对比，Netty的综合性能最优；
Spring Boot+Netty+Websocket实现后台向前端推送信息
代码界的扛把子
10-13 155
** * 一旦连接，第一个被执行 */ @Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { log.info("有新的客户端链接：[{}]", ctx.channel().id().asLongText());// 添加到channelGroup 通道组 NettyConfig.getChannelGroup().add(ctx.channel());
SpringBoot+Netty+Websocket实现消息推送
weixin_44831330的博客
12-11 983
这样一个需求：把设备异常的状态每10秒推送到页面并且以弹窗弹出来，这个时候用Websocket最为合适。
SpringBoot + netty-socketio实现服务器端消息推送
ATwill的专栏
03-23 8479
首先：因为工作需要，需要对接socket.io框架对接，所以目前只能使用netty-socketio。websocket是不支持对接socket.io框架的。 netty-socketio顾名思义他是一个底层基于netty’实现的socket。 在springboot项目中的集成，请看下面的代码 maven依赖 <dependency> <groupId>com.coru...
Springboot+Netty+WebSocket搭建简单的消息通知
青春不散场的专栏
08-22 1084
"Netty-WebSocket服务器。"Netty-WebSocket服务器。"您的浏览器不支持WebSocket协议！"WebSocket 连接没有建立成功！可以通过前端发送消息到后端，通过日志查看。
Netty+websocket+springboot实现服务端消息推送
tony_stark的博客
08-11 2415
因为产品需求，要实现服务端推送消息至客户端，并且支持客户端对用户点对点消息发送的社交功能，目前市面上对消息推送的第三方支持很多，比如国产EasyGo和国外的一些，但基于收费，所以，以netty来实现。 废话不多说，直接上代码： 1.首先引入依赖：(netty-all包含了netty的所有封装,hutool-all封装了常用的一些依赖,如Json相关) <dependency> <groupId>io.netty</groupId> <artifactId>
springboot+netty+websocket实现局域网音视频通话
05-20
实现局域网音视频通话可以用Spring Boot作为后端框架，Netty作为网络通信框架，WebSocket作为实现双向通信的协议。以下是一个简单的实现过程： 1. 首先需要搭建一个Spring Boot项目，可以使用Spring Initializr来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值