spring-websocket基于stomp实现websocket

飘零未归人

已于 2024-09-06 09:05:03 修改

阅读量1.2k

点赞数 8

分类专栏：前端 java 文章标签： websocket 网络协议网络

于 2024-09-06 09:02:52 首次发布

本文链接：https://blog.csdn.net/qq_34484062/article/details/139323566

版权

java 同时被 2 个专栏收录

143 篇文章 3 订阅

订阅专栏

前端

22 篇文章 0 订阅

订阅专栏

概述

后端代码

拦截器

HandshakeInterceptor拦截器

ChannelInterceptor拦截器

ChannelInterceptor拦截器设置用户信息

DefaultHandshakeHandler的继承类中设置用户对象

前端代码

概述

WebSocket 协议是一种相当低级的协议。它定义了如何将字节流转换为帧。帧可以包含文本或二进制消息。由于消息本身不提供有关如何路由或处理它的任何其他信息，因此很难在不编写其他代码的情况下实现更复杂的应用程序。幸运的是，WebSocket 规范允许在更高的应用程序级别上使用子协议。

STOMP ： Simple Text Oriented Message Protocol——面向消息的简单文本协议

STOMP 提供了能够协作的报文格式，以至于 STOMP 客户端可以与任何 STOMP 消息代理（Brokers）进行通信，从而为多语言，多平台和 Brokers 集群提供简单且普遍的消息协作。STOMP 协议可以建立在WebSocket 之上，也可以建立在其他应用层协议之上。通过 Websocket建立 STOMP 连接，也就是说在 Websocket 连接的基础上再建立 STOMP 连接。

WebSocket 是底层协议，而 STOMP 是基于 WebSocket的上层协议。

后端代码

spring基于stomp协议的websocket实现主要是配置WebSocketMessageBrokerConfigurer相关信息。配置类需要加上注解@EnableWebSocketMessageBroker，表明这是一个websocket的处理broker。

WebSocketMessageBrokerConfigurer为我们提供了配置websocket端点、消息broker地址、拦截器、消息转换器的方法。

拦截器

拦截器主要是拦截客户端的握手消息的HandshakeInterceptor，以及拦截连接、订阅、消息发送、取消订阅、取消连接的ChannelInterceptor拦截器。

HandshakeInterceptor拦截器

HandshakeInterceptor是拦截客户端握手消息的拦截器，我们可以在这里对接口进行拦截过滤，如用户认证信息等。

/**
 * 
 * @description： websocket握手拦截器，可以在这里获取到请求头信息进行拦截。
 */
public class MyHandshakeInterceptor implements HandshakeInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyHandshakeInterceptor.class);

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
        LOGGER.info("------------------MyHandshakeInterceptor:beforeHandshake");
        return true;
    }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
        LOGGER.info("-----------------MyHandshakeInterceptor:afterHandshake");
    }
}

ChannelInterceptor拦截器

ChannelInterceptor是对客户端的连接、订阅、消息发送、取消订阅、取消连接等消息进行拦截的实现。

在拦截器中我们可以对数据进行自定义转换，处理、解密等操作。

/**
 * 
 * @description: WebSocket拦截器
 *  方法调用顺序：preSend -> postSend -> afterSendCompletion
 */
public class MyWebsocketChannelInterceptor implements ChannelInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyWebsocketChannelInterceptor.class);


    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
        StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);

        if (accessor.getCommand() == StompCommand.CONNECT) {
            LOGGER.info("------------收到websocket的连接消息");
        }

        if (accessor.getCommand() == StompCommand.SEND) {
            LOGGER.info("------------收到websocket的数据发送消息");
        }

        if (accessor.getCommand() == StompCommand.SUBSCRIBE) {
            LOGGER.info("------------收到websocket的订阅消息");
        }

        if (accessor.getCommand() == StompCommand.UNSUBSCRIBE) {
            LOGGER.info("------------收到websocket的取消订阅消息");
        }

        return message;
    }

    @Override
    public void postSend(Message<?> message, MessageChannel channel, boolean sent) {
        LOGGER.info("------------WebsocketChannelInterceptor-postSend");
    }

    @Override
    public void afterSendCompletion(Message<?> message, MessageChannel channel, boolean sent, @Nullable Exception ex) {
        LOGGER.info("-----------WebsocketChannelInterceptor-afterSendCompletion");
    }

    @Override
    public boolean preReceive(MessageChannel channel) {
        LOGGER.info("----------WebsocketChannelInterceptor-preReceive");
        return true;
    }

    @Override
    public Message<?> postReceive(Message<?> message, MessageChannel channel) {
        LOGGER.info("----------WebsocketChannelInterceptor-postReceive");
        return message;
    }

    @Override
    public void afterReceiveCompletion(@Nullable Message<?> message, MessageChannel channel, @Nullable Exception ex) {
        LOGGER.info("----------WebsocketChannelInterceptor-afterReceiveCompletion");
    }
}

客户端发送的消息主要类型有参考StompCommand，主要有：

CONNECT：启动与服务器的流或TCP 连接
SEND：客户端发送消息
SUBSCRIBE：客户端订阅主题
UNSUBSCRIBE：客户端取消订阅
BEGIN：启动事物
COMMIT：提交事物
ABORT：回滚事物
ACK：确认来自订阅的消息的消费
NACK：告诉服务器客户端没有消费该消息
DISCONNECT：断开连接
MESSAGE：于SEND一样。

这里需要注意的是，很多时候，前端有一些消息是没有定义在这里面的，例如心跳消HEARTBEAT，所以还有一个MessageType对象可以辅助判断。

public enum SimpMessageType {

	CONNECT,

	CONNECT_ACK,

	MESSAGE,

	SUBSCRIBE,

	UNSUBSCRIBE,

	HEARTBEAT,

	DISCONNECT,

	DISCONNECT_ACK,

	OTHER;

}

消息转换器

消息转换器是对客户端发送过来的数据进行转换的类，通过消息转换器，可以将客户端的数据直接转换成对应的对象，并且将我们返回的消息处理成指定的格式。也可以在这里对数据进行加解密。等操作

通过实现MessageConverter的两个方法。

/**
 * 
 * @description： 消息转换实体。
 */
public class CommonMessageConvert implements MessageConverter {
    /**
     * 将客户端发送过来的消息转换为指定的对象
     * @param message 客户端发送过来的消息
     * @param targetClass 目标数据类型
     * @return 转换后的对象
     */
    @Override
    public Object fromMessage(Message<?> message, Class<?> targetClass) {
        if (message.getPayload() instanceof byte[]) {
            try {
                String textPayload = new String((byte[]) message.getPayload(), StandardCharsets.UTF_8);
                return JsonUtil.convertString2Object(textPayload,targetClass);
            } catch (Exception e) {
                throw new RuntimeException("Failed to convert websocket message", e);
            }
        }
        return null;
    }

    /**
     * 将服务器
     * @param payload the Object to convert
     * @param headers optional headers for the message (may be {@code null})
     * @return broker的消息实体
     */
    @Override
    public Message<?> toMessage(Object payload, MessageHeaders headers) {
        String str = JsonUtil.toJson(payload);
        byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
        return new GenericMessage<>(bytes, headers);
    }
}

配置类

配置类WebSocketMessageBrokerConfigurer是对以上定义的各项进行配置的实现。

/**
 * @description: websocket配置类
 */

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketBrokerConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
          /**
         * 注册 Stomp的端点 可以注册多个端点
         * addEndpoint：添加STOMP协议的端点。这个HTTP URL是供WebSocket或SockJS客户端访问的地址
         * withSockJS：指定端点使用SockJS协议
         *
         */
        //定义 {context-path}/sjstmpwebsocket/* 接口为websocket接口
        registry.addEndpoint("/sjstmpwebsocket")
                .addInterceptors(new MyHandshakeInterceptor())
                //.setHandshakeHandler(webSocketHandshakeHandler)
                //允许跨域访问
                .setAllowedOrigins("*")
                .withSockJS();

        //定义 {context-path}/stmpwebsocket/* 接口为websocket接口
        registry.addEndpoint("/stmpwebsocket")
                .addInterceptors(new MyHandshakeInterceptor())
                //.setHandshakeHandler(webSocketHandshakeHandler)
                //允许跨域访问
                .setAllowedOrigins("*");
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {
        /*
         *
         */
        //config.enableStompBrokerRelay("/qeune")

        /*
         * 配置消息代理
         * 客户端订阅消息的请求前缀，topic一般用于广播推送，queue用于点对点推送
         * 决定哪些目的地应该由简单代理（如内存中的队列或主题）处理。
         * 启动简单Broker，消息的发送的地址符合配置的前缀来的消息才发送到这个broker
         */
        config.enableSimpleBroker("/topic", "/queue")
                .setHeartbeatValue(new long[] {10000, 10000})
                .setTaskScheduler(new DefaultManagedTaskScheduler());

        /*
         *   客户端名称前缀 将所有发往"/message"前缀的目的地的消息路由到应用层处理,
         *   以 /message 开头的STOMP消息被路由到 @Controller 类中的 @MessageMapping 和  @SubscribeMapping 方法。
         */
        config.setApplicationDestinationPrefixes("/message");

        //服务端通知客户端的前缀，可以不设置，默认为user
        config.setUserDestinationPrefix("/user");
    }

    /**
     * 配置客户端入站通道拦截器
     * 设置输入消息通道的线程数，默认线程为1，可以自己自定义线程数，最大线程数，线程存活时间
     *
     * @param registration
     */
    @Override
    public void configureClientInboundChannel(ChannelRegistration registration) {
        /*
         * 配置消息线程池
         * 1. corePoolSize 配置核心线程池，当线程数小于此配置时，不管线程中有无空闲的线程，都会产生新线程处理任务
         * 2. maxPoolSize 配置线程池最大数，当线程池数等于此配置时，不会产生新线程
         * 3. keepAliveSeconds 线程池维护线程所允许的空闲时间，单位秒
         */
        /*registration.taskExecutor().corePoolSize(10)
                .maxPoolSize(20)
                .keepAliveSeconds(60);*/
        // 拦截器配置
        registration.interceptors(new MyWebsocketChannelInterceptor());
    }

    /**
     * 消息转换器
     * @param messageConverters 转换器集合
     * @return 是否使用
     */
    @Override
    public boolean configureMessageConverters(List<MessageConverter> messageConverters) {
        messageConverters.add(new CommonMessageConvert());
        return true;
    }
}

消息处理

stomp的消息处理，主要是依赖注解实现，通过注解和配置类中的websocekt路径配置，决定了将客户端的websocket数据发送到哪个接口处理。

@Controller：注解消息处理类需要
@DestinationVariable：解析接口中的参数，类似于@PathParam
@MessageMapping：类似于spring的@RequestMapping注解，表明了websocket的接口路径，接口也可以使用{}定义前端传过来的路径参数。可以用于类和方法
@SubscribeMapping：订阅模式，只是在订阅的时候触发，可以理解为：访问—>返回数据。
@SendTo：广播模式，将消息广播给所有监听这个主题的客户端。
@SendToUser：用户模式，将消息发送给指定的用户。消息目的地有UserDestinationMessageHandler来处理，会将消息路由到发送者对应的目的地。默认该注解前缀为/user。如：用户订阅/user/hi ，在@SendToUser('/hi')查找目的地时，会将目的地的转化为/user/{name}/hi, 这个name就是principal的name值，该操作是认为用户登录并且授权认证，使用principal的name作为目的地标识。发给消息来源的那个用户。（就是谁请求给谁，不会发给所有用户，区分就是依照principal-name来区分的)。此外该注解还有个broadcast属性，表明是否广播。就是当有同一个用户登录多个session时，是否都能收到。取值true/false.

需要注意的是：@SendTo和@SendToUser中的路径配置必须是在配置类中broker配置的路径。参考MessageBrokerRegistry.enableSimpleBroker()

除此之外，spring还提供了另一种，基于 SimpMessagingTemplate的数据通知方式，和注解的方式相同，但是SimpMessagingTemplate可以实现点对点通信。

广播模式

广播模式，是将客户端发送的数据广播到指定的describetion地址，使得所有监听这个desctibetion的客户端都能接收到数据。实现方式主要有两种，一种是基于@SendTo注解，一种是基于SimpMessagingTemplate的convertAndSend()方法。

/**
 * @description： 处理websocket过来的数据
 */
@Controller
public class MyStompEndpoint {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyStompEndpoint.class);


    /**
     * 广播模式：
     * MessageMapping 指定要接收消息的地址，类似@RequestMapping。除了注解到方法上，也可以注解到类上
     * SendTo指定要发送到订阅地址， 如果没有写，则，默认消息将被发送到与传入消息相同的目的地
     * 消息的返回值是通过{@link org.springframework.messaging.converter.MessageConverter}进行转换
     * @param websocketMessage 请求参数
     * @return 自定义返回结果
     */
    @MessageMapping("/stomp/sendMessage")
    @SendTo("/topic/targetSubscribe")   
    public ResWebsocketMessage broadcast(WebsocketMessage websocketMessage){
        LOGGER.info("receive message = {}" , JsonUtil.toJson(websocketMessage));
        ResWebsocketMessage responseMessage = new ResWebsocketMessage();
        responseMessage.setType("BROADCAST");
        responseMessage.setMessage(websocketMessage.getMessage());
        return responseMessage;
    }
}

/**
 * @description： 处理websocket过来的数据
 */
@Controller
public class MyStompEndpoint {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyStompEndpoint.class);

    //spring提供的推送方式
    @Autowired
    private SimpMessagingTemplate messagingTemplate;


    /**
     * 广播模式
     * @param requestMsg 请求消息
     */
    @MessageMapping("/stomp/springBrocastMessage")
    public void springBrocastMessage(WebsocketMessage requestMsg) {
        //这里使用的是spring的security的认证体系，所以直接使用Principal获取用户信息即可。
        LOGGER.info("receive userMessage, message= {}" , JsonUtil.toJson(requestMsg));

        //发送到 /message/topic/targetSubscribe 的订阅客户端那里。
        messagingTemplate.convertAndSend("/topic/targetSubscribe", requestMsg.getMessage());
    }

}

用户模式

用户模式是将客户端的消息发送给指定的一个或者多个用户。实现方式主要有两种，一种是基于@SendTouser注解，一种是基于SimpMessagingTemplate的convertAndSendToUser()方法。

这里需要注意的是@SendTouser发给的自己，但是convertAndSendToUser()可以选择需要发送的用户信息，实现真正意义上的点对点通信。两种的实现原理是相同的，都是基于请求中的用户信息Principal，着将在后面介绍。

/**
 * @author ZSC
 * @date 2024/5/21 - 9:07
 * @description： 处理websocket过来的数据
 */
@Controller
public class MyStompEndpoint {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyStompEndpoint.class);

    //spring提供的推送方式
    @Autowired
    private SimpMessagingTemplate messagingTemplate;


    /**
     * 用户模式
     * @param requestMsg 请求消息
     * SendToUser 如果存在return,可以使用这种方式,路径必须是以broker指定的开始(MessageBrokerRegistry.enableSimpleBroker())
     *        只能发给数据发送的客户端  且 客户端需要监听 /user/queue/{userId}  才能收到；简单来说  自己  ---> broker   --->自己
     */
    @MessageMapping("/stomp/userMessage/{userId}")
    @SendToUser("/queue/{userId}")
    public ResWebsocketMessage userMessage(Principal principal, @DestinationVariable String userId, WebsocketMessage requestMsg) {
        //这里使用的是spring的security的认证体系，所以直接使用Principal获取用户信息即可。
        LOGGER.info("receive userMessage username: {} userId= {}, message= {}" , principal.getName(), userId, JsonUtil.toJson(requestMsg));

        ResWebsocketMessage responseMessage = new ResWebsocketMessage();
        responseMessage.setType("NOTI");
        responseMessage.setMessage(requestMsg.getMessage());

        return responseMessage;
    }
}

/**
 * @description： 处理websocket过来的数据
 */
@Controller
public class MyStompEndpoint {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyStompEndpoint.class);

    //spring提供的推送方式
    @Autowired
    private SimpMessagingTemplate messagingTemplate;

    /**
     * 用户模式-发送给指定的订阅这着
     * @param requestMsg 请求消息
     */
    @MessageMapping("/stomp/springUserMessage/{userId}")
    public void springUserMessage(@DestinationVariable String userId, WebsocketMessage requestMsg) {
        //这里使用的是spring的security的认证体系，所以直接使用Principal获取用户信息即可。
        LOGGER.info("receive springUserMessage, message:{}" , userId, JsonUtil.toJson(requestMsg));
        /*
         * convertAndSendToUser 会默认在主题前添加 /user 前缀， 所以客户端需要在订阅路径前加入/user,
         * 这里会自动发送到  指定订阅的路径 ： /user/queue/targetUser, 其中 user是在 setUserDestinationPrefix中配置的， 
         * 所以客户端需要监听/user/queue/targetUser地址才能收到消息
         */
        messagingTemplate.convertAndSendToUser(userId, "/queue/targetUser", requestMsg.getMessage());

    }
}

自定义请求头

既然是数据交互，不能避免的就是用户认证，只有通过认证的用户我们才能进行后续的数据交互。

在本章介绍的websocket实现中，支持读取请求头的方式有DefaultHandshakeHandler、HandshakeInterceptor、ChannelInterceptor。

理论上，DefaultHandshakeHandler、HandshakeInterceptor、ChannelInterceptor都能获取到客户端的传过来的请求头信息。但是这严重依赖于客户端的实现方式，如果客户端能可以设置自定义请求头，后端都能获取。

但是我尝试过几种客户端的(前端js)的websockt实现方式，包括原生的、@stomp/stompjs，都没办法在DefaultHandshakeHandler和HandshakeInterceptor拦截器中获取到自定义请求头信息。只能是从固定的请求头Sec-WebSocket-Protocol中获取。

基于stomp-client+webscoket的方式可以设置自定义的请求头，并在DefaultHandshakeHandler 和 HandshakeInterceptor拦截器中获取到。

注意：这个用法只适合用在客户端使用原生的websocket时，如果是基于stomp的，那么这个Sec-WebSocket-Protocol请求头已经有了stomp设置的值。

但是我们可以在这里获取websocket定义好请求头，如登录的用户名login和密码passcode。如果是基于这两个做验证则可以。

public class MyHandshakeInterceptor implements HandshakeInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyHandshakeInterceptor.class);

    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception {
        HttpHeaders headers = request.getHeaders();


        /*
         * 前端很多websocket实现方式不支持的自定义请求头信息只能放到 Sec-WebSocket-Protocol 这里面，
         * websocket不支持自定义请求头信息
         */
        /*List<String> list = headers.get("Sec-WebSocket-Protocol".toLowerCase());

        if(CollectionUtils.isNotEmpty(list)) {
            //做校验等等
        }*/

        LOGGER.info("------------------MyHandshakeInterceptor:beforeHandshake");
        return true;
    }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) {
        LOGGER.info("-----------------MyHandshakeInterceptor:afterHandshake");
    }
}

ChannelInterceptor能获取到@stomp/stompjs、基于stomp-client+webscoket等方式设置的请求头。只是需要通过Message对象获取。

/**
 * @description: stomp/stompjs + websocket时的拦截器  WebSocket拦截器
 *  方法调用顺序：preSend -> postSend -> afterSendCompletion
 */
public class StompJsWebsocketChannelInterceptor implements ChannelInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(StompJsWebsocketChannelInterceptor.class);


    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
       StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);

        LOGGER.info("收到websocket的消息:command:{}, ack:{}", accessor.getCommand(), accessor.getAck());

        if (accessor.getCommand() == StompCommand.CONNECT) {
            /*
             * 这里一般都需要保证 messageAccessor.getMessageType() == SimpMessageType.CONNECT
             * 但是测试时发现，这两者总是一致的，所以就不判断了。
             *
             */
            StompHeaderAccessor messageAccessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
            // 从Header中可以读取login和passcode
            Object raw = message.getHeaders().get(SimpMessageHeaderAccessor.NATIVE_HEADERS);
            if (raw instanceof Map) {
                Object userInfo = ((Map) raw).get("userId");
                if (userInfo instanceof LinkedList) {
                    // 设置当前访问器的认证用户
                    String name = ((LinkedList<?>)userInfo).get(0).toString();
                    ......
                }
            }
        }
        return message;
    }
}

用户信息

在本章的实现方法中，用户信息就是secrity的Principal对象或者实现了Principal方法的对象。

后续所有获取用户的方法所使用的也是这个对象。

实现设置Principal的方式有两种，一种是在ChannelInterceptor拦截器的实现类中进行设置，还有一种是在DefaultHandshakeHandler的继承类中实现。DefaultHandshakeHandler是握手处理器，其方法determineUser()放回的就是这个用户对象。

ChannelInterceptor拦截器设置用户信息

官网地址

ChannelInterceptor拦截器设置用户信息，实现如下：

/**
 * @description: stomp/stompjs + websocket时的拦截器  WebSocket拦截器
 *  方法调用顺序：preSend -> postSend -> afterSendCompletion
 */
public class StompJsWebsocketChannelInterceptor implements ChannelInterceptor {

    private static final Logger LOGGER = LoggerFactory.getLogger(StompJsWebsocketChannelInterceptor.class);


    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
       StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);

        LOGGER.info("收到websocket的消息:command:{}, ack:{}", accessor.getCommand(), accessor.getAck());

        if (accessor.getCommand() == StompCommand.CONNECT) {
            /*
             * 这里一般都需要保证 messageAccessor.getMessageType() == SimpMessageType.CONNECT
             * 但是测试时发现，这两者总是一致的，所以就不判断了。
             *
             */
            StompHeaderAccessor messageAccessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
            // 从Header中可以读取login和passcode
            Object raw = message.getHeaders().get(SimpMessageHeaderAccessor.NATIVE_HEADERS);
            if (raw instanceof Map) {
                Object userInfo = ((Map) raw).get("userId");
                if (userInfo instanceof LinkedList) {
                    // 设置当前访问器的认证用户
                    String name = ((LinkedList<?>)userInfo).get(0).toString();
                    /*
                     * 这里必须要设置在 MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); 得到的结果里，否则子获取用户的时候会报错
                     */
                    messageAccessor.setUser(new StompPrincipal(name));
                }
            }
        }
        
        return message;
    }
}

需要注意的是，在获取StompHeaderAccessor对象的方式有两种：

StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
StompHeaderAccessor messageAccessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);

但是用户的信息的设置必须是要设置到MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class)的对象中。否则在获取该对象的时候就会出现错误。

org.springframework.messaging.simp.annotation.support.MissingSessionUserException: No "user" header in message

DefaultHandshakeHandler的继承类中设置用户对象

DefaultHandshakeHandler的继承类中生成用户对象的实现如下：

/**
 * @description： 握手处理器，为每一个用户生成一个
 */
public class CustomHandshakeHandler extends DefaultHandshakeHandler {

    private static final Logger LOGGER = LoggerFactory.getLogger(CustomHandshakeHandler.class);
    @Override
    protected Principal determineUser(ServerHttpRequest request, WebSocketHandler wsHandler, Map<String, Object> attributes) {
        LOGGER.info("------------------CustomHandshakeHandler:determineUser");
        HttpHeaders headers = request.getHeaders();
        List<String> userIds = headers.get("userId");
        if(CollectionUtils.isNotEmpty(userIds)) {
            return new StompPrincipal(userIds.get(0));
        }
        return request.getPrincipal();
    }
}

public class StompPrincipal implements Principal {
    String name;

    public StompPrincipal(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }
}

该自定义握手处理器需要在配置项中加入。

@Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        /**
         * 注册 Stomp的端点 可以注册多个端点
         *
         */

        //定义 {context-path}/stmpwebsocket/* 接口为websocket接口
        registry.addEndpoint("/stmpwebsocket")
                .addInterceptors(new MyHandshakeInterceptor())
                //自定义握手处理器
                .setHandshakeHandler(new CustomHandshakeHandler())
                //允许跨域访问
                .setAllowedOrigins("*");
    }
}

但是正如前面所说的 DefaultHandshakeHandler是否能获取到前端自定义的请求头信息，完全依赖于前端使用何种方式来实现。

使用Principal用户对象

经过以上设置用户对象之后，在代码中我们就可以直接获取Principal对象了。

@MessageMapping("/stomp/userMessage/{userId}")
    @SendToUser("/queue/{userId}")
    public ResWebsocketMessage userMessage(Principal principal, @DestinationVariable String userId, WebsocketMessage requestMsg) {
        //这里使用的是spring的security的认证体系，所以直接使用Principal获取用户信息即可。
        LOGGER.info("receive userMessage username: {} userId= {}, message= {}" , principal.getName(), userId, JsonUtil.toJson(requestMsg));

        ResWebsocketMessage responseMessage = new ResWebsocketMessage();
        responseMessage.setType("NOTI");
        responseMessage.setMessage(requestMsg.getMessage());

        return responseMessage;
    }


/**
     * 用户模式-发送给指定的订阅这着
     * @param requestMsg 请求消息
     */
    @MessageMapping("/stomp/springUserMessage/{userId}")
    public void springUserMessage(Principal principal, @DestinationVariable String userId, WebsocketMessage requestMsg) {
        //这里使用的是spring的security的认证体系，所以直接使用Principal获取用户信息即可。
        LOGGER.info("receive springUserMessage, userName:{} userId：{}, message:{}" , principal.getName(), userId, JsonUtil.toJson(requestMsg));
        /*
         * convertAndSendToUser 会默认在主题前添加 /user 前缀， 所以客户端需要在订阅路径前加入/user,
         * 这里会自动发送到  指定订阅的路径 ： /user/queue/targetUser, 其中 user是在 setUserDestinationPrefix中配置的
         * 所以客户端需要监听/user/queue/targetUser地址才能收到消息
         */
        messagingTemplate.convertAndSendToUser(userId, "/queue/targetUser", requestMsg.getMessage());
    }