02-spring增强的websocket使用示例

最新推荐文章于 2024-08-09 13:40:31 发布

cjia2023

最新推荐文章于 2024-08-09 13:40:31 发布

阅读量1.1k

点赞数 18

分类专栏： websocket 文章标签： spring websocket java

本文链接：https://blog.csdn.net/weixin_43716785/article/details/135713471

版权

websocket 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

spring增强的websocket使用示例

前言：之前一篇文章介绍了javax.websocket在spring-boot项目中的简单使用，但是spring其实对javax.websocket有了进一步的封装，因此本文主要介绍spring框架里面的websocket的用法

1 依赖部分

这里直接贴出pom.xml文件的内容

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring-websocket-use-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.7.3</version>
    </parent>
    <dependencies>
        <!--        lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--  springBoot依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--spring-web-socket依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>


    </dependencies>
</project>

2 示例代码

一共分为三部分，首先是处理消息的handler，然后是spring-websocket需要的配置，最后是拦截器，可以拦截请求，做校验，但是个人感觉没必要

2.1 自定义处理消息的handler

注释很清楚了，直接贴代码了

注：不一定必须实现WebSocketHandler（最底层的一个接口），还可以实现其他的handler（（也是基于WebSocketHandler的）），例如AbstractWebSocketHandler

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.socket.*;

import java.io.IOException;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
/**
 * websockt的数据发送
 *
 **/
@Slf4j
@Component
public class MyWebSocketHandler implements WebSocketHandler {
    private Map<String, Map<String, WebSocketSession>> sessions = new HashMap<>();

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // 当WebSocket连接建立成功时调用
        //log.info("attribute:{}", session.getAttributes());
        //ws://127.0.0.1:10030/ws?scanPoint=01&userId=123
        String scanPoint = extractParams(session, "scanPoint"); // 从session中提取扫码点位
        log.info("扫码点:{}",scanPoint);
        final String userId = extractParams(session, "userId");
        log.info("userId:{}",userId);
        if (sessions.containsKey(scanPoint)) {
            sessions.get(scanPoint).put(userId, session);// 将扫码点位和session存储到Map中
        } else {
            sessions.put(scanPoint, new HashMap<String, WebSocketSession>() {{
                put(userId, session);
            }});// 将扫码点位和session存储到Map中
        }

    }

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        // 当接收到WebSocket消息时调用
        String scanPoint = extractParams(session, "scanPoint"); // 从session中提取少嘛点位
        String payload = (String) message.getPayload();// 获取消息内容
        sendMessageToScanPoint(scanPoint, payload);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // 当WebSocket连接关闭时调用
        String scanPoint = extractParams(session, "scanPoint"); // 从session中提取扫码点位
        if (sessions.containsKey(scanPoint)) {
            sessions.get(scanPoint).remove(extractParams(session, "userId"));// 将扫码点位和session从Map中移除
        }
    }

    @Override
    public boolean supportsPartialMessages() {
        return false;
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        // 当WebSocket传输发生错误时调用
        // 可以在这里进行错误处理逻辑
    }

    private String extractParams(WebSocketSession session, String param) {
        // 从session中提取扫码点位的逻辑，根据实际情况实现
        //这里约定参数拼接在url中
        ///ws://127.0.0.1:10030/ws?scanPoint=01&userId=123
        try {
            String query = Objects.requireNonNull(session.getUri()).getQuery();
            Map<String, String> params = new HashMap<>();
            if (query != null) {
                String[] pairs = query.split("&");
                for (String pair : pairs) {
                    int idx = pair.indexOf("=");
                    String key = URLDecoder.decode(pair.substring(0, idx), "UTF-8");
                    String value = URLDecoder.decode(pair.substring(idx + 1), "UTF-8");
                    params.put(key, value);
                }
            }
            return params.get(param);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void sendMessageToScanPoint(String scanPoint, String message) throws IOException {
      // 根据扫码点位获取对应的session，并发送消息
        if (!sessions.containsKey(scanPoint)) {
            return;
        }
        if (sessions.get(scanPoint).isOpen()) {
            sessions.get(scanPoint).sendMessage(new TextMessage(message));
        }
    }

    private void sendMessageToAll(String message) throws IOException {
        // 遍历所有的session，并发送消息
        for (Map<String, WebSocketSession> session : sessions.values()) {
            if (session == null) {
                continue;
            }
            for (Map.Entry<String, WebSocketSession> stringWebSocketSessionEntry : session.entrySet()) {
                if (stringWebSocketSessionEntry.getValue().isOpen()) {
                    stringWebSocketSessionEntry.getValue().sendMessage(new TextMessage(message));
                }
            }
        }
    }
}

2.2 websocket需要的配置

注：@EnableWebSocket这个注解必须要有，可以写在启动类那里，我这里直接写在配置类这里

import org.example.service.MyWebSocketHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

/**
 * spriing-websocket配置
 *
 * @author cjia
 * */
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    private final MyWebSocketHandler webSocketHandler;

    public WebSocketConfig(MyWebSocketHandler webSocketHandler) {
        this.webSocketHandler = webSocketHandler;
    }

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(webSocketHandler, "/ws/**") //访问路径:ws://host:port/ws/
                //添加拦截器
                //.addInterceptors(new WebSocketInterceptor())
                .setAllowedOrigins("*"); // 允许跨域访问
    }
}

2.3 websocket配置拦截器（可选）

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;

import java.util.Map;

/**
 * websocket拦截器
 * @author JIA
 */
@Slf4j
public class WebSocketInterceptor implements HandshakeInterceptor {
    /**
     * 建立请求之前，可以用来做权限判断
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest request,
                                   ServerHttpResponse response, WebSocketHandler wsHandler,
                                   Map<String, Object> attributes) throws Exception {
        if (request instanceof ServletServerHttpRequest) {
            ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) request;
            //todo 模拟校验（通常利用JWT令牌解析用户信息）
            //String token = servletServerHttpRequest.getServletRequest().getParameter("token");
            //log.info("获取到的token:{}", token);
            //try {
            //    //ClientUserInfo clientUserInfo = JwtUtils.getClientUserInfo(token);
            //    // 设置当前这个session的属性，后续我们在发送消息时，可以通过 session.getAttributes().get("clientUserInfo")可以取出 clientUserInfo参数
            //    attributes.put("clientUserInfo", token+"-" +123456);
            //} catch (Exception e) {
            //    log.error("webSocket 认证失败 ", e);
            //    return false;
            //}
            return true;
        }
        return false;
    }

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

    }
}