【websocket】springboot 实现 websocket

最新推荐文章于 2024-09-23 13:42:12 发布
最新推荐文章于 2024-09-23 13:42:12 发布
阅读量986 收藏 5
点赞数 3
分类专栏： java 文章标签： websocket spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42720002/article/details/121856471
版权
本文介绍了如何在Spring Boot应用中利用原生的WebSocket注解实现服务器向客户端的消息推送。通过`@ServerEndpoint`定义WebSocket路径，`@OnOpen`、`@OnClose`、`@OnMessage`、`@OnError`处理连接建立、关闭、消息接收和错误情况。同时，文章展示了如何处理离线消息和心跳检测，以及如何向单个或所有客户端广播消息。
摘要由CSDN通过智能技术生成

websocket实现有四种方法，这里展示相对简单的一种方法

这里使用原生注解的方法实现

说明需要注意的点：
  1. 引用的包都在 **javax.websocket **下。并不是 spring 提供的，而 jdk 自带的。

下面关于使用到的几个注解的说明：

  1. @ServerEndpoint ：通过这个 spring boot 就可以知道你暴露出去的 ws 应用的路径，有点类似我们经常用的@RequestMapping。比如你的启动端口是 8080，而这个注解的值是 ws，那我们就可以通过 ws://127.0.0.1:8080/ws 来连接你的应用
  2. @OnOpen：当 websocket 建立连接成功后会触发这个注解修饰的方法，注意它有一个 Session 参数
  3. @OnClose： 当 websocket 建立的连接断开后会触发这个注解修饰的方法
  4. @OnMessage： 当客户端发送消息到服务端时，会触发这个注解修改的方法，如果需要做心跳检测可以在这里做。
  5. @OnError：：当 websocket 建立连接时出现异常会触发这个注解修饰的方法
  6. 使用 session.getBasicRemote().sendText(*) 向客户端发送消息

如下是具体实现

  1. pom.xml 引入架包
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

2.WebSocketConfig

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * 开启WebSocket
 * WebScoket配置
 * 通过这个配置 spring boot 才能去扫描后面的关于 websocket 的注解
 */
@Configuration
public class WebSocketConfig {
    
	@Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

3.WebSocketServer

package com.dw.sprboosoc.service;

import com.alibaba.fastjson.JSON;
import com.dw.sprboosoc.constant.MessageEnum;
import com.dw.sprboosoc.dto.WebSocketMessageDto;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;



// 添加Bean
@Component
@Slf4j
//访问路径
@ServerEndpoint(value = "/websocket/{sendUserId}")
public class WebSocketServer {
    //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static final AtomicInteger currentOnlineNumber = new AtomicInteger();
    //concurrent包的线程安全Set，用来存放每个客户端对应的WebSocketServer对象
    private static final ConcurrentHashMap<String, Session> sessionPool = new ConcurrentHashMap<>();
    //设置为静态的 公用一个消息map ConcurrentMap为线程安全的map  HashMap不安全
    private static final ConcurrentMap<String, Map<String, List<WebSocketMessageDto>>> messageMap = new ConcurrentHashMap<>();

    /*
     *发送消息
     * @param [session, message, userId]
     * @return void
     */
    public void sendMessage(WebSocketMessageDto webSocketMessageDto) throws IOException {
        try {
            switch (webSocketMessageDto.getMessageEnum()) {
                // 广播消息
                case ALL:
                    sessionPool.values().forEach(se -> {
                        try {
                            se
                                    .getBasicRemote()
                                    .sendText(webSocketMessageDto.toString());
                        } catch (IOException e) {
                            log.info("群发");
                        }
                    });
                    log.info("websocket: 广播消息：" + webSocketMessageDto);
                    // 离线
                    storeOfflineMessage(webSocketMessageDto);
                    break;
                // 私发
                case ONE:
                    //根据约定的字段，检测心跳
                    String message = webSocketMessageDto.getMessage();
                    if (message.equals("ping")) {
                        WebSocketMessageDto wd = new WebSocketMessageDto();
                        wd.setMessage("pong");
                        wd.setRecvUserId("");
                        wd.setMessageEnum(MessageEnum.ONE);
                        sessionPool.get(webSocketMessageDto.getSendUserId())
                                .getBasicRemote()
                                .sendText(JSON.toJSONString(wd));
                    } else {
                        if (judgeUserOnline(webSocketMessageDto.getRecvUserId())) {
                            // 在线
                        /*sessionPool.get(webSocketMessageDto.getRecvUserId())
                                .getBasicRemote()
                                .sendText(webSocketMessageDto.toString());*/


                            sessionPool.get(webSocketMessageDto.getRecvUserId())
                                    .getBasicRemote()
                                    .sendText(JSON.toJSONString(webSocketMessageDto));

                        } else {
                            // 离线
                            storeOfflineMessage(webSocketMessageDto);
                        }

                        log.info("websocket: 私发消息，" + webSocketMessageDto);
                        break;
                    }
            }
        } catch (Exception exception) {
            log.error("websocket: 发送消息发生了错误");
        }
    }

    /*
     *客户端收到消息
     * @param [message]
     * @return void
     */
    @OnMessage
    public void onMessage(String webSocketMessageDtoStr) throws IOException {
        WebSocketMessageDto webSocketMessageDto = JSON.parseObject(webSocketMessageDtoStr, WebSocketMessageDto.class);
        log.info("websocket:" + webSocketMessageDto.getRecvUserId() + "收到，来自：" + webSocketMessageDto.getSendUserId() + "，发送的消息：" + webSocketMessageDto.getMessage());
        sendMessage(webSocketMessageDto);
    }

    /*
     *判断用户是否在线
     * @param [recvUserId]
     * @return boolean
     */
    public boolean judgeUserOnline(String recvUserId) {
        boolean flag = !ObjectUtils.isEmpty(sessionPool.get(recvUserId));
        String flagStr = flag ? "在线" : "离线";
        log.info("websocket: " + recvUserId + ":" + flagStr);
        return flag;
    }

    /*
     *用户离线时把消息存储到内存
     * @param [recvUserId]
     * @return void
     */
    public void storeOfflineMessage(WebSocketMessageDto webSocketMessageDto) {
        //用户不在线时 第一次给他发消息
        if (ObjectUtils.isEmpty(messageMap.get(webSocketMessageDto.getRecvUserId()))) {
            Map<String, List<WebSocketMessageDto>> maps = new HashMap<>();
            List<WebSocketMessageDto> list = new ArrayList<>();
            list.add(webSocketMessageDto);
            maps.put(webSocketMessageDto.getRecvUserId(), list);
            messageMap.put(webSocketMessageDto.getRecvUserId(), maps);
        } else {
            //用户不在线时 再次发送消息
            Map<String, List<WebSocketMessageDto>> listObject = messageMap.get(webSocketMessageDto.getRecvUserId());
            List<WebSocketMessageDto> objects = new ArrayList<>();
            if (!ObjectUtils.isEmpty(listObject.get(webSocketMessageDto.getRecvUserId()))) {//这个用户给收消息的这个用户发过消息
                //此用户给该用户发送过离线消息（此用户给该用户发过的所有消息）
                objects = listObject.get(webSocketMessageDto.getRecvUserId());
                //加上这次发送的消息
                objects.add(webSocketMessageDto);
                //替换原来的map
                listObject.put(webSocketMessageDto.getRecvUserId(), objects);
            } else {//这个用户没给该用户发送过离线消息
                objects.add(webSocketMessageDto);
                listObject.put(webSocketMessageDto.getRecvUserId(), objects);
            }
            messageMap.put(webSocketMessageDto.getRecvUserId(), listObject);
        }
    }

    /*
     *成功建立连接后调用
     * @param [session, userId]
     * @return void
     */
    @OnOpen
    public void onOpen(Session session, @PathParam(value = "sendUserId") String sendUserId) throws IOException {
        //成功建立连接后加入
        sessionPool.put(sendUserId, session);
        //当前在线数量+1
        currentOnlineNumber.incrementAndGet();
        log.info("websocket:" + sendUserId + "加入连接,当前在线用户" + currentOnlineNumber + "未读消息数：" + getMessageCount(sendUserId));
        // 发送离线消息
        sendOffLineMessage(sendUserId);
    }

    /*
     * 用户上线时发送离线消息
     * @param []
     * @return void
     */
    @SneakyThrows
    public void sendOffLineMessage(String sendUserId) {

        if (ObjectUtils.isEmpty(messageMap.get(sendUserId))) {
            // 该用户没有离线消息
            return;
        }
        // 当前登录用户有离线消息
        //说明在用户没有登录的时候有人给用户发送消息
        //该用户所有未收的消息
        Map<String, List<WebSocketMessageDto>> lists = messageMap.get(sendUserId);
        //对象用户发送的离线消息
        List<WebSocketMessageDto> list = lists.get(sendUserId);
        if (list != null) {
            for (WebSocketMessageDto webSocketMessageDto : list) {
                onMessage(JSON.toJSONString(webSocketMessageDto));
            }
        }

        // 删除已发送的消息
        removeHasBeenSentMessage(sendUserId, lists);


    }

    /*
     *删除已发送的消息
     * @param [sendUserId, map]
     * @return void
     */
    public void removeHasBeenSentMessage(String sendUserId, Map<String, List<WebSocketMessageDto>> map) {
        // map中key（键）的迭代器对象
        //用户接收完消息后删除 避免下次继续发送
        Iterator iterator = map.keySet().iterator();
        while (iterator.hasNext()) {// 循环取键值进行判断
            String keys = (String) iterator.next();//键
            if (sendUserId.equals(keys)) {
                iterator.remove();
            }
        }
    }

    /*
     *关闭连接时调用
     * @param [userId]
     * @return void
     */
    @OnClose
    public void onClose(@PathParam(value = "sendUserId") String sendUserId) {
        sessionPool.remove(sendUserId);
        currentOnlineNumber.decrementAndGet();
        log.info("websocket:" + sendUserId + "断开连接,当前在线用户" + currentOnlineNumber);
    }

    /*
     *发生错误时调用
     * @param [session, throwable]
     * @return void
     */
    @OnError
    public void onError(Throwable throwable) {
        log.error("websocket: 发生了错误");
        throwable.printStackTrace();
    }


    /**
     * 获取该用户未读的消息数量
     */
    public int getMessageCount(String recvUserId) {
        //获取该用户所有未收的消息
        Map<String, List<WebSocketMessageDto>> listMap = messageMap.get(recvUserId);
        if (listMap != null) {
            List<WebSocketMessageDto> list = listMap.get(recvUserId);
            if (list != null) {
                return listMap.get(recvUserId).size();
            } else {
                return 0;
            }

        } else {
            return 0;
        }

    }

}

4.WebSocket 消息 DTO

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.io.Serializable;

@Getter
@Setter
@ToString
public class WebSocketMessageDto implements Serializable {
    private static final long serialVersionUID = 4153093005674764992L;
     /*发信人*/
    private String sendUserId;

    /*收信人*/
    private String recvUserId;

    /*消息内容*/
    private String message;

    /*消息类型*/
    private MessageEnum messageEnum;
}

5.MessageEnum 消息体枚举

import lombok.Getter;
@Getter
public enum MessageEnum {
    /**
     * 私发
     */
    ONE("one", "私发"),
    /**
     * 群发
     */
    ALL("all", "群发"),

    /**
     * 其他
     */
    OTHER("other", "其他");
    /**
     * 消息类型
     */
    private final String messageType;
    /**
     * 消息类型描述
     */
    private final String desc;
    
    /**
     * 消息枚举 构造器 私有化
     *
     * @param messageType 消息类型
     * @param desc        desc
     */
    MessageEnum(String messageType, String desc) {
        this.messageType = messageType;
        this.desc = desc;
    }
}

6.结果验证：建立连接方式可以在 http://www.jsons.cn/websocket/ 页面输入 ws://127.0.0.1:端口号/websocket/1234 建立连接、发送消息等

叁拾柒°伍
关注
专栏目录
springboot集成websocket实现简单聊天
03-29
springboot集成websocket实现即时通信，你发的消息将直接显示在另一台pc机的浏览器上
springboot+websocket分布式实现
11-17
综上所述，“springboot+websocket分布式实现”涉及到的主要技术包括WebSocket协议、SpringBoot的WebSocket支持、Redis消息队列以及Spring Session和Spring Cloud的分布式会话管理。通过这些技术的组合，可以构建出...
测试：编写消息通知功能
m0_71745754的博客
07-13 1217
其实做一个功能之前，还是最好规划下方案。因为对于我来说，这块能力还是了一些，所以有个大概的设计方案会有很大的帮助。Websocket由于我们服务器主动推送数据到客户端（浏览器），所以最好是服务器能主动通知，毕竟前端一直轮训接口，还是会有一定的性能损耗。如若我们在用户打开基础页面BasicLayout的时候，根据用户id获取websocket连接，并在服务端保持住。当有需要的时候则发送消息给用户。这里我们定义消息的类型: 和，广播消息类似系统通知那种，比如版本更新了什么，个人消息我目前能想到的就是测试计划执行
SpringBoot 集成WebSocket 的 3 种集成方式
最新发布
码猿技术专栏
09-23 226
由于前段时间我实现了一个库【Spring Cloud】一个配置注解实现 WebSocket 集群方案以至于我对WebSocket的各种集成方式做了一些研究，目前我所了解到的就是下面这些了（就一个破ws都有这么多花里胡哨的集成方式了？）JavaxWebMVCWebFluxJava-WebSocketSocketIONetty今天主要介绍一下前3种方式，毕竟现在的主流框架还是Spring Boot而后...
SpringBoot实现WebSocket
热门推荐
山不见我，我自见山
12-06 2万+
WebSocket是HTML5下一种新的协议（websocket协议本质上是一个基于tcp的协议） 它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的。
springboot实现websocket
大猩猩的博客
08-29 1974
springboot实现websocket，nginx配置实现转发
springboot+websocket的实现
乐昊的博客
11-09 8337
本文章利用一个小的对话demo来展示springboot+websocket的实现。 下面开始简单的实现过程： 我的项目结构： 一、首先，创建springboot项目，在pox.xml中加入（下面是我的pom.xml的dependencies里的全部依赖，因为，这个是最简单的入门例子,所以只有主要的websocket和web依赖） <dependencies> <dependency> <groupId>org.springframewor
SpringBoot 集成 WebSocket
功不唐捐，玉汝于成
04-21 6306
SpringBoot 整合 websocket、websocket 的通信应用
基于springboot实现websocket客户端和服务端
04-29
除了上述三个官方提供的类/接口之外，我们还需要实现一个WebSocket的包装类，用于为每一个WebSocket实例添加额外的信息，比如客户端的ID。在Spring内，WebSocket实例以WebSocketSession形式存在，每个session都代表...
springboot+websocket进度条实战
11-11
在本项目中，"springboot+websocket进度条实战"是一个基于Spring Boot框架和WebSocket技术的实战应用，旨在展示如何在Web应用程序中实现一个实时的进度条功能。Spring Boot简化了Java Web开发，提供了快速构建独立...
使用WebSocket+SpringBoot搭建简易的多人聊天室
04-22
使用WebSocket+SpringBoot搭建简易的多人聊天室 由浅入深，配合博客入门教程文章食用，风味独特。 使用WebSocket+SpringBoot搭建简易的多人聊天室 由浅入深，配合博客入门教程文章食用，风味独特。 使用WebSocket+...
SpringBoot+WebSocket实现消息推送及简单的聊天功能
10-18
SpringBoot+WebSocket实现消息推送，SpringBoot+WebSocket+SpringSecurity实现聊天室
websocket在springboot+vue中的使用教程
08-25
在上面的代码中，我们使用`@ServerEndpoint`注解来标识这个类是一个WebSocket实现类。`value`属性指定了WebSocket的路径，在这个例子中是`/messageSocket/{userId}`。 二、WebSocket的生命周期 WebSocket有三个...
Spring Boot实现Web Socket
明月阁
10-14 343
原文链接：https://www.dubby.cn/detail.html?id=9102 实现代码 依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-websocket&lt;/artifactId&...
Springboot对Websocket的实现
m0_62891104的博客
10-28 3189
springboot+websocket实现简易聊天室
实现Springbootwebsocket
weixin_49390750的博客
12-22 1272
websocket
Springboot整合websocket(附详细案例代码)
weixin_46425661的博客
09-09 4739
本文主要介绍WebSocket的概念，和在springboot项目中的使用。
springboot实现websocket功能
qq_35651224的博客
08-29 478
1.引入pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 2.websocket配置类 /** * websocket配置 * @Date: 2020-08-22 */ @Configuration /** *
websocket springboot
05-01
WebSocket是一种通信协议，用于在Web浏览器和服务器之间实现双向通信。它的主要目的是提供一种实时的、基于事件的机制，以便在Web应用程序中进行实时数据交换。Spring Boot是一个基于Spring Framework的开发框架，它提供了一种简单、快速、方便的方法来构建Web应用程序。 WebSocket在Web应用程序中的使用与之前的技术如AJAX有所不同。AJAX（Asynchronous JavaScript and XML）虽然能够实现异步通信，但它是基于HTTP协议的，无法提供实时双向数据交换。而WebSocket协议则是在HTTP之上的，它通过在浏览器和服务器之间保持一个持久的连接来实现实时数据交换。 Spring Boot提供了对WebSocket协议的支持，可以轻松地集成WebSocket到Web应用程序中。通过使用Spring Boot，开发者可以非常容易地创建一个WebSocket服务器，并实现各种功能，比如聊天室、推送通知、实时游戏等。 总的来说，WebSocket和Spring Boot的结合可以为Web应用程序提供强大的实时数据交换功能，使得应用程序能够更加高效地处理大量并发请求，提升用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值