Spring Boot 集成 WebSocket（原生注解与Spring封装）

已于 2022-12-02 18:52:52 修改
阅读量2.9w 收藏 171
点赞数 50
分类专栏： 后端笔记 文章标签： websocket spring spring boot
于 2022-09-24 11:03:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq991658923/article/details/127022522
版权

Spring Boot 集成 WebSocket

本章节将介绍 Spring Boot 集成 WebSocket 的两种主要方式：原生注解与Spring封装。

在线WebSocket测试工具

🤖 Spring Boot 2.x 实践案例（代码仓库）

原生注解

引入依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

配置文件

@Configuration
public class WebSocketConfiguration {
    /**
     * 	注入ServerEndpointExporter，
     * 	这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

处理消息

@Component
@Slf4j
@ServerEndpoint("/websocket/{userId}")
public class WebSocket {

    /**
     * 线程安全的无序的集合
     */
    private static final CopyOnWriteArraySet<Session> SESSIONS = new CopyOnWriteArraySet<>();

    /**
     * 存储在线连接数
     */
    private static final Map<String, Session> SESSION_POOL = new HashMap<>();

    @OnOpen
    public void onOpen(Session session, @PathParam(value = "userId") String userId) {
        try {
            SESSIONS.add(session);
            SESSION_POOL.put(userId, session);
            log.info("【WebSocket消息】有新的连接，总数为：" + SESSIONS.size());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @OnClose
    public void onClose(Session session) {
        try {
            SESSIONS.remove(session);
            log.info("【WebSocket消息】连接断开，总数为：" + SESSIONS.size());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @OnMessage
    public void onMessage(String message) {
        log.info("【WebSocket消息】收到客户端消息：" + message);
    }

    /**
     * 此为广播消息
     *
     * @param message 消息
     */
    public void sendAllMessage(String message) {
        log.info("【WebSocket消息】广播消息：" + message);
        for (Session session : SESSIONS) {
            try {
                if (session.isOpen()) {
                    session.getAsyncRemote().sendText(message);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 此为单点消息
     *
     * @param userId  用户编号
     * @param message 消息
     */
    public void sendOneMessage(String userId, String message) {
        Session session = SESSION_POOL.get(userId);
        if (session != null && session.isOpen()) {
            try {
                synchronized (session) {
                    log.info("【WebSocket消息】单点消息：" + message);
                    session.getAsyncRemote().sendText(message);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 此为单点消息(多人)
     *
     * @param userIds 用户编号列表
     * @param message 消息
     */
    public void sendMoreMessage(String[] userIds, String message) {
        for (String userId : userIds) {
            Session session = SESSION_POOL.get(userId);
            if (session != null && session.isOpen()) {
                try {
                    log.info("【WebSocket消息】单点消息：" + message);
                    session.getAsyncRemote().sendText(message);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  • @ServerEndpoint：将目前的类定义成一个websocket服务器端，注解的值将被用于监听用户连接的终端访问URL地址，客户端可以通过这个URL来连接到WebSocket服务器端
  • @OnOpen：当WebSocket建立连接成功后会触发这个注解修饰的方法。
  • @OnClose：当WebSocket建立的连接断开后会触发这个注解修饰的方法。
  • @OnMessage：当客户端发送消息到服务端时，会触发这个注解修改的方法。
  • @OnError：当WebSocket建立连接时出现异常会触发这个注解修饰的方法。

Spring封装

引入依赖

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

自定义处理器

处理器作用类似于@RequestMapping注解，用于处理某一个路径的WebSocket连接，自定义处理器需要实现WebSocketHandler接口。

WebSocket操作类
public interface WebSocket {
    /**
     * 会话开始回调
     *
     * @param session 会话
     */
    void handleOpen(WebSocketSession session);

    /**
     * 会话结束回调
     *
     * @param session 会话
     */
    void handleClose(WebSocketSession session);

    /**
     * 处理消息
     *
     * @param session 会话
     * @param message 接收的消息
     */
    void handleMessage(WebSocketSession session, String message);

    /**
     * 发送消息
     *
     * @param session 当前会话
     * @param message 要发送的消息
     * @throws IOException 发送io异常
     */
    void sendMessage(WebSocketSession session, String message) throws IOException;

    /**
     * 发送消息
     *
     * @param userId  用户id
     * @param message 要发送的消息
     * @throws IOException 发送io异常
     */
    void sendMessage(String userId, TextMessage message) throws IOException;

    /**
     * 发送消息
     *
     * @param userId  用户id
     * @param message 要发送的消息
     * @throws IOException 发送io异常
     */
    void sendMessage(String userId, String message) throws IOException;

    /**
     * 发送消息
     *
     * @param session 当前会话
     * @param message 要发送的消息
     * @throws IOException 发送io异常
     */
    void sendMessage(WebSocketSession session, TextMessage message) throws IOException;

    /**
     * 广播
     *
     * @param message 字符串消息
     * @throws IOException 异常
     */
    void broadCast(String message) throws IOException;

    /**
     * 广播
     *
     * @param message 文本消息
     * @throws IOException 异常
     */
    void broadCast(TextMessage message) throws IOException;

    /**
     * 处理会话异常
     *
     * @param session 会话
     * @param error   异常
     */
    void handleError(WebSocketSession session, Throwable error);

    /**
     * 获得所有的 websocket 会话
     *
     * @return 所有 websocket 会话
     */
    Set<WebSocketSession> getSessions();

    /**
     * 得到当前连接数
     *
     * @return 连接数
     */
    int getConnectionCount();
}
WebSocket操作实现类
@Slf4j
public class WebSocketImpl implements WebSocket {
    /**
     * 在线连接数（线程安全）
     */
    private final AtomicInteger connectionCount = new AtomicInteger(0);

    /**
     * 线程安全的无序集合（存储会话）
     */
    private final CopyOnWriteArraySet<WebSocketSession> sessions = new CopyOnWriteArraySet<>();

    @Override
    public void handleOpen(WebSocketSession session) {
        sessions.add(session);
        int count = connectionCount.incrementAndGet();
        log.info("a new connection opened，current online count：{}", count);
    }

    @Override
    public void handleClose(WebSocketSession session) {
        sessions.remove(session);
        int count = connectionCount.decrementAndGet();
        log.info("a new connection closed，current online count：{}", count);
    }

    @Override
    public void handleMessage(WebSocketSession session, String message) {
        // 只处理前端传来的文本消息，并且直接丢弃了客户端传来的消息
        log.info("received a message：{}", message);
    }

    @Override
    public void sendMessage(WebSocketSession session, String message) throws IOException {
        this.sendMessage(session, new TextMessage(message));
    }

    @Override
    public void sendMessage(String userId, TextMessage message) throws IOException {
        Optional<WebSocketSession> userSession = sessions.stream().filter(session -> {
            if (!session.isOpen()) {
                return false;
            }
            Map<String, Object> attributes = session.getAttributes();
            if (!attributes.containsKey("uid") {
                return false;
            }
            String uid = (String) attributes.get("uid");
            return uid.equals(userId);
        }).findFirst();
        if (userSession.isPresent()) {
            userSession.get().sendMessage(message);
        }
    }

    @Override
    public void sendMessage(String userId, String message) throws IOException {
        this.sendMessage(userId, new TextMessage(message));
    }

    @Override
    public void sendMessage(WebSocketSession session, TextMessage message) throws IOException {
        session.sendMessage(message);
    }

    @Override
    public void broadCast(String message) throws IOException {
        for (WebSocketSession session : sessions) {
            if (!session.isOpen()) {
                continue;
            }
            this.sendMessage(session, message);
        }
    }

    @Override
    public void broadCast(TextMessage message) throws IOException {
        for (WebSocketSession session : sessions) {
            if (!session.isOpen()) {
                continue;
            }
            session.sendMessage(message);
        }
    }

    @Override
    public void handleError(WebSocketSession session, Throwable error) {
        log.error("websocket error：{}，session id：{}", error.getMessage(), session.getId());
        log.error("", error);
    }

    @Override
    public Set<WebSocketSession> getSessions() {
        return sessions;
    }

    @Override
    public int getConnectionCount() {
        return connectionCount.get();
    }
}
自定义WebSocket处理器
public class DefaultWebSocketHandler implements WebSocketHandler {

    @Autowired
    private WebSocket webSocket;

    /**
     * 建立连接
     *
     * @param session Session
     */
    @Override
    public void afterConnectionEstablished(@NonNull WebSocketSession session) {
        webSocket.handleOpen(session);
    }

    /**
     * 接收消息
     *
     * @param session Session
     * @param message 消息
     */
    @Override
    public void handleMessage(@NonNull WebSocketSession session, @NonNull WebSocketMessage<?> message) {
        if (message instanceof TextMessage) {
            TextMessage textMessage = (TextMessage) message;
            webSocket.handleMessage(session, textMessage.getPayload());
        }
    }

    /**
     * 发生错误
     *
     * @param session   Session
     * @param exception 异常
     */
    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) {
        webSocket.handleError(session, exception);
    }

    /**
     * 关闭连接
     *
     * @param session     Session
     * @param closeStatus 关闭状态
     */
    @Override
    public void afterConnectionClosed(@NonNull WebSocketSession session, @NonNull CloseStatus closeStatus) {
        webSocket.handleClose(session);
    }

    /**
     * 是否支持发送部分消息
     *
     * @return false
     */
    @Override
    public boolean supportsPartialMessages() {
        return false;
    }
}
自定义拦截器

自定义处理器需要实现HandshakeInterceptor接口

public class WebSocketInterceptor implements HandshakeInterceptor {

    @Override
    public boolean beforeHandshake(@NonNull ServerHttpRequest request, @NonNull ServerHttpResponse response, @NonNull WebSocketHandler wsHandler, @NonNull Map<String, Object> attributes) throws Exception {
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) request;
            // 模拟用户（通常利用JWT令牌解析用户信息）
            String userId = servletServerHttpRequest.getServletRequest().getParameter("uid");
            // TODO 判断用户是否存在
            attributes.put("uid", userId);
            return true;
        }
        return false;
    }

    @Override
    public void afterHandshake(@NonNull ServerHttpRequest request, @NonNull ServerHttpResponse response, @NonNull WebSocketHandler wsHandler, Exception exception) {

    }
}

WebSocket 无法使用 header 传递参数，因此这里使用 url params 携带参数。

WebSocket配置项

将自定义处理器、拦截器以及WebSocket操作类依次注入到IOC容器中。

@Configuration
@EnableWebSocket
public class WebSocketConfiguration implements WebSocketConfigurer {

    @Bean
    public DefaultWebSocketHandler defaultWebSocketHandler() {
        return new DefaultWebSocketHandler();
    }

    @Bean
    public WebSocket webSocket() {
        return new WebSocketImpl();
    }

    @Bean
    public WebSocketInterceptor webSocketInterceptor() {
        return new WebSocketInterceptor();
    }

    @Override
    public void registerWebSocketHandlers(@NonNull WebSocketHandlerRegistry registry) {
        registry.addHandler(defaultWebSocketHandler(), "ws/message")
                    .addInterceptors(webSocketInterceptor())
                    .setAllowedOrigins("*");
    }
}
  • @EnableWebSocket：开启WebSocket功能
  • addHandler：添加处理器
  • addInterceptors：添加拦截器
  • setAllowedOrigins：设置允许跨域（允许所有请求来源）

WebSocket测试

原生注解

原生注解-客户端
原生注解-服务端

Spring封装

Spring封装-客户端
Spring封装-服务端

人人都在发奋
关注
  • 50
    点赞
  • 踩
  • 171
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 24
    评论
专栏目录
SpringBoot整合Websocket
Absosba的博客
03-30 257
SpringBoot整合Websocket 整合步骤很简单，请看下文分解。???? 引入Maven依赖，如下： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> <version>2.3.3.RELEASE</version> </dep
Spring集成webSocket页面访问404问题的解决方法
08-28
Spring集成webSocket页面访问404问题的解决方法 Spring集成webSocket页面访问404问题的解决方法是指在使用Spring框架集成webSocket技术时，遇到的页面访问404错误问题的解决方案。该问题主要是由于在 ...
使用 Spring Boot 实现 WebSocket实时通信
08-28
本篇文章主要介绍了使用 Spring Boot 实现 WebSocket实时通信，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【Unity】在Unity下使用websocket的一些经验
好吃的和好看的都需要用实力来争取
05-08 3103
webSocket是什么:1、WebSocket是一种在单个TCP连接上进行全双工通信的协议2、WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据3、在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输4、需要安装第三方包：cmd中：go get -u -v（我这里使用的是WebSocketSharp库，一个很简单的dll文件）
SpringBoot整合WebSocket服务 springboot整合websocket springboot使用websocket springboot使用websocket
最新发布
半只
07-19 2629
仅使用 SpringBoot封装好的服务，并不是使用第三方Netty或者: 底层使用实现: 底层使用Netty实现(没有使用过，不知道具体)官方文档1官方文档2。
Spring Boot 集成 WebSocket（原生注解与Spring封装方式）
09-29
内容概要：帮助读者通过 Spring Boot 框架一步步完成 WebSocket 集成，快速上手WebSocket。在通过两种方式集成的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能，例如：IOC、AOP、Bean生命周期、上下文、作用域、资源处理等内容实现。 适合人群：具备一定编程基础，工作1-3年的研发人员 能学到什么：Spring Boot 快速集成 WebSocket（原生注解与Spring封装方式） 阅读建议：此资源以开发 Spring Boot 集成 WebSocket 学习其原理和内核，不仅是代码编写实现也更注重内容上的需求分析和方案设计，所以在学习的过程要结合这些内容一起来实践，并调试对应的代码。
spring boot+websocket
04-27
spring boot+websocket网页上使用的是jquery写的，网页放在resources\static目录里边，下载直接运行就可以
SpringBoot 集成 WebSocket
功不唐捐，玉汝于成
04-21 5105
SpringBoot 整合 websocket、websocket 的通信应用
springboot 集成websocket
大哥一声吼
05-29 8159
springboot 和websocket 集成
springboot集成websocket
qq_42922707的博客
02-21 6061
springboot集成websocket 记录下自己使用wensocket的踩坑过程，如有不对，请见谅 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 配置websocket
SpringBoot 集成WebSocket
m0_67907445的博客
08-29 1455
在海量并发及客户端与服务器交互负载流量大的情况下，极大的节省了网络带宽资源的消耗，有明显的性能优势，且客户端发送和接受消息是在同一个持久连接上发起，实现了“真·长链接”，实时性优势明显。* 要注意，如果项目使用外置的servlet容器，而不是直接使用springboot内置容器的话，就不要注入ServerEndpointExporter，因为它将由容器自己提供和管理。长轮询的间隔期一般很长，例如 30s、60s，并且服务端 hold 住连接不会消耗太多服务端资源。降低轮询的间隔，延迟降低，压力增加；
Spring boot整合websocket实现即时通讯
04-14
Spring boot整合websocket实现即时通讯。传统的HTTP协议，一般通过向服务器发送请求，拉取数据实现半双工通信，缺点是服务器难以直接向浏览器下发消息，因此，websocket协议应运而生，可用于向建立连接的浏览器主动...
关于Spring Boot WebSocket整合以及nginx配置详解
08-29
总结一下，整合Spring Boot与WebSocket的关键步骤包括： 1. 添加`spring-boot-starter-websocket`依赖。 2. 创建WebSocket处理类并实现`TextWebSocketHandler`。 3. 注册WebSocket处理类到Spring Boot应用配置中。 4...
Springboot超仔细整合websocket(附案例代码)
qq_55272229的博客
06-30 3065
添加依赖：确保在pom.xml中添加Spring WebSocket和WebSocket依赖。创建WebSocket处理器(端点)：编写一个处理WebSocket消息的处理器。完成对应的生命周期如果需要传递http第一次握手时候处理信息 需要添加对应的处理配置配置WebSocket：配置WebSocket相关的Bean和端点(值得注意的是每一个端点对象对一个用户线程 所以spring的单实列bean和异步处理再这里无法生效 具体会在踩坑笔记中提及)
Springboot整合WebSocket（纯后端）
从基础到源码解析的学习记录
04-26 4004
简单介绍下前端，不做代码方面内容。
Springboot整合Websocket
qq_45443475的博客
10-21 7466
Springboot整合Websocket
SpringBoot——集成WebSocket
吴声子夜歌的博客
07-29 1418
对于WebSocket的使用，可以先通过Spring创建Java配置文件。//创建服务器端点 @Bean public ServerEndpointExporter serverEndpointExporter() {} }有了这个Bean，就可以使用@ServerEndpoint定义一个端点服务类。//静态变量，用来记录当前在线连接数。应该设计为线程安全的 private static int onlineCount = 0;
spring boot集成websocket
08-30
Spring Boot可以很容易地集成WebSocket来实现后台向前端推送信息。首先，在你的项目中添加WebSocket的依赖。然后，在controller层加上相应的注解，如@SpringBootApplication和@EnableWebSocket。最后，启动项目并访问指定的URL来与WebSocket进行交互。 具体步骤如下： 1. 添加WebSocket的依赖到你的项目中，可以在pom.xml文件中添加以下代码： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 2. 在controller层，加上@SpringBootApplication和@EnableWebSocket注解，如下所示： ```java @SpringBootApplication @EnableWebSocket public class MywebsocketApplication { public static void main(String[] args) { SpringApplication.run(MywebsocketApplication.class, args); } } ``` 3. 创建一个WebSocket处理器类，可以通过继承自AbstractWebSocketHandler来实现。你可以在这个类中定义处理WebSocket连接、消息发送和接收的逻辑。 4. 在controller中，创建一个处理WebSocket请求的方法，并使用@MessageMapping注解来指定接收消息的路径。在这个方法中，你可以调用WebSocket处理器类的方法来处理消息，并使用WebSocketSession对象来发送消息给前端。 5. 启动你的项目，并访问指定的URL（例如http://localhost:8081/demo/toWebSocketDemo/{cid}），跳转到页面后，就可以与WebSocket进行交互了。 以上就是Spring Boot集成WebSocket的基本步骤。你可以根据具体的需求来进一步扩展和定制WebSocket的功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [SpringBoot 集成WebSocket详解](https://blog.csdn.net/qq_42402854/article/details/130948270)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [springboot 集成webSocket](https://blog.csdn.net/just_learing/article/details/125899260)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人人都在发奋

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值