likes
comments
collection
share

WebSocket使用介绍,看这篇就够了

作者站长头像
站长
· 阅读数 18

一、WebSocket连接的建立、消息的接收和回复

  1. 当涉及到WebSocket框架的深度使用时,一个流行的选择是使用Java的Spring框架来实现。下面是一个基本的示例,演示了如何使用Spring WebSocket框架进行深度使用:

首先,确保你的项目中包含了Spring WebSocket的相关依赖。在pom.xml文件中添加以下依赖:

<dependencies>
    <!-- Spring WebSocket -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
</dependencies>

接下来,创建一个WebSocket配置类,用于配置和管理WebSocket连接:

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;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/websocket").setAllowedOrigins("*");
    }
}

在上面的示例中,MyWebSocketHandler是自定义的WebSocket处理程序,它将处理来自客户端的WebSocket连接和消息。

接下来,创建一个WebSocket处理程序类来处理WebSocket连接和消息的逻辑:

import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

public class MyWebSocketHandler extends TextWebSocketHandler {

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        // 当WebSocket连接建立成功时调用
        System.out.println("WebSocket连接已建立");
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        // 处理接收到的WebSocket消息
        String payload = message.getPayload();
        System.out.println("接收到消息:" + payload);
        
        // 发送回复消息给客户端
        String replyMessage = "收到消息:" + payload;
        session.sendMessage(new TextMessage(replyMessage));
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        // 当WebSocket连接关闭时调用
        System.out.println("WebSocket连接已关闭");
    }
}

在上面的示例中,我们覆盖了afterConnectionEstablishedhandleTextMessageafterConnectionClosed等方法,以处理WebSocket连接的建立、接收消息和连接关闭等事件。

最后,你可以在你的应用程序中使用WebSocket连接,例如在控制器中处理WebSocket请求:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class WebSocketController {

    @MessageMapping("/send")
    @SendTo("/topic/messages")
    public String sendMessage(String message) {
        // 处理接收到的消息,并返回处理结果
        String replyMessage = "处理消息:" + message;
        return replyMessage;
    }
}

在上面的示例中,我们使用@MessageMapping注解来指定处理客户端发送的消息的路径,然后使用@SendTo注解将处理结果发送回指定的订阅路径。

二、广播消息、用户认证

  1. 广播消息:除了在handleTextMessage方法中直接发送回复消息给单个客户端外,你还可以使用SimpMessagingTemplate来广播消息给所有订阅了特定主题的客户端。可以在WebSocketConfig中注入SimpMessagingTemplate,然后在处理程序中使用它发送消息。

    @Autowired private SimpMessagingTemplate messagingTemplate;

    @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { // 处理接收到的WebSocket消息 String payload = message.getPayload(); System.out.println("接收到消息:" + payload);

    // 广播消息给所有订阅了特定主题的客户端
    messagingTemplate.convertAndSend("/topic/messages", "收到消息:" + payload);
    

    }

  2. 用户认证和授权:如果你的应用程序需要对WebSocket连接进行认证和授权,你可以使用Spring Security框架来实现。你可以在WebSocketConfigurerregisterWebSocketHandlers方法中添加适当的拦截器来处理认证和授权逻辑。例如,使用HandshakeInterceptor进行握手阶段的认证,并使用ChannelInterceptor来拦截和处理每个消息的授权逻辑。

  3. 处理其他WebSocket事件:除了处理连接建立、消息接收和连接关闭等事件外,你还可以覆盖其他WebSocket事件的处理方法,例如handleTransportError用于处理传输错误,handleBinaryMessage用于处理二进制消息等。根据你的需求,选择合适的方法进行覆盖和处理。

  4. 集成其他功能:你可以将WebSocket与其他功能集成,例如数据库访问、消息队列、实时通知等。使用适当的组件和库,将WebSocket与你的应用程序的其他部分无缝集成,以实现更复杂的功能。

三、转换器、存储与过滤器

  1. 自定义消息转换器:Spring WebSocket框架支持使用不同的消息转换器来处理不同类型的消息。你可以自定义消息转换器,以实现自定义的消息格式和处理逻辑。通过实现WebSocketMessageConverter接口,你可以定义自己的消息转换器,并在WebSocketConfig中进行配置。

    @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/websocket")
                .setAllowedOrigins("*")
                .addInterceptors(new HttpSessionHandshakeInterceptor())
                .withSockJS();
    }
    
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
    
    @Override
    public boolean configureMessageConverters(List<MessageConverter> messageConverters) {
        // 添加自定义的消息转换器
        messageConverters.add(new MyMessageConverter());
        return true;
    }
    

    }

  2. 广播消息给特定用户:除了广播消息给所有订阅了特定主题的客户端,你还可以使用SimpMessagingTemplate将消息发送给特定用户。通过将用户标识符作为消息的目的地,你可以确保消息仅发送给特定用户。

    @Autowired private SimpMessagingTemplate messagingTemplate;

    public void sendMessageToUser(String userId, String message) { messagingTemplate.convertAndSendToUser(userId, "/queue/messages", message); }

  3. 会话管理和状态存储:WebSocket连接可以建立长时间的会话,你可能需要管理会话状态和存储用户相关的数据。你可以使用WebSocketSession对象来管理会话,并使用适当的存储机制(例如数据库、缓存等)来存储和检索会话状态。

  4. 消息拦截器和过滤器:Spring WebSocket框架提供了拦截器和过滤器机制,允许你在处理消息之前或之后执行额外的逻辑。通过实现HandshakeInterceptorChannelInterceptor接口,你可以编写自定义的拦截器和过滤器来处理身份验证、消息转换、日志记录等操作。

四、拦截器、STOMP协议

  1. 处理连接错误:WebSocket连接可能会出现错误,例如连接断开、超时等情况。你可以在handleTransportError方法中处理这些连接错误,并采取适当的措施,例如记录日志、重新连接等。

    @Override public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception { // 处理连接错误 System.out.println("连接错误:" + exception.getMessage());

    // 可以根据具体情况采取适当的措施,例如关闭连接、重新连接等
    

    }

  2. 使用WebSocket拦截器:WebSocket拦截器允许你在建立连接之前和之后执行额外的逻辑。你可以实现HandshakeInterceptor接口,并在WebSocketConfig中注册拦截器来处理握手阶段的逻辑。

    @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/websocket")
                .setAllowedOrigins("*")
                .addInterceptors(new MyHandshakeInterceptor())
                .withSockJS();
    }
    
    // ...
    

    }

  3. 使用自定义注解:你可以定义自己的注解,以便在WebSocket处理方法中进行更细粒度的控制。通过创建自定义注解并使用@Target(ElementType.METHOD)将其应用于处理方法,你可以在运行时执行特定的逻辑。

    @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface CustomWebSocketHandler { // 添加自定义属性 }

    @CustomWebSocketHandler public void handleWebSocketMessage(WebSocketSession session, TextMessage message) { // 执行自定义逻辑 }

  4. 使用STOMP协议:STOMP(Simple Text Oriented Messaging Protocol)是一种简单的文本导向消息协议,用于在WebSocket之上进行消息传递。你可以使用Spring的STOMP支持来实现更高级的消息传递功能,例如订阅和发布、消息头、错误处理等。

五、广播管理、定时任务

  1. 消息广播和群组管理:除了向特定用户发送消息,你可能还需要实现消息的广播和群组管理功能。Spring WebSocket框架提供了SimpMessagingTemplateSimpUserRegistry等工具类来实现这些功能。你可以使用SimpMessagingTemplate发送消息给特定主题或群组,而SimpUserRegistry则用于管理连接的用户和会话。

    @Autowired private SimpMessagingTemplate messagingTemplate;

    @Autowired private SimpUserRegistry userRegistry;

    public void broadcastMessage(String topic, String message) { messagingTemplate.convertAndSend(topic, message); }

    public Set getConnectedUsers() { return userRegistry.getUsers().stream() .map(SimpUser::getName) .collect(Collectors.toSet()); }

  2. 定时任务和调度:在WebSocket应用中,你可能需要执行定时任务和调度任务,例如定时发送消息、定时清理会话等。你可以使用Spring框架提供的定时任务调度功能,结合WebSocket框架来实现这些任务。

    @Component public class WebSocketScheduler {

    @Autowired
    private SimpMessagingTemplate messagingTemplate;
    
    @Scheduled(fixedDelay = 5000) // 每5秒执行一次
    public void sendScheduledMessage() {
        String message = "Scheduled message";
        messagingTemplate.convertAndSend("/topic/messages", message);
    }
    

    }

  3. 跨域访问控制:如果你的WebSocket应用需要跨域访问控制,你可以配置相应的跨域策略。Spring WebSocket框架提供了setAllowedOrigins方法来设置允许的跨域来源。

    @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(new MyWebSocketHandler(), "/websocket") .setAllowedOrigins("example.com") .addInterceptors(new HttpSessionHandshakeInterceptor()) .withSockJS(); }

  4. 安全认证和授权:如果你的WebSocket应用需要安全认证和授权,你可以结合Spring Security框架来实现。通过配置适当的安全规则和认证机制,你可以确保只有经过授权的用户才能建立WebSocket连接和发送消息。

    @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new MyWebSocketHandler(), "/websocket")
                .setAllowedOrigins("*")
                .addInterceptors(new HttpSessionHandshakeInterceptor())
                .withSockJS();
    }
    
    // ...
    

    } @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/websocket").authenticated()
                .anyRequest().permitAll()
                .and()
            .formLogin()
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }
    

    }

六、存储、多频道管理与部署

  1. 消息存储和持久化:如果你的应用需要存储和持久化消息,可以结合使用WebSocket和消息队列或数据库来实现。当接收到消息时,你可以将消息存储到数据库或消息队列中,并在需要的时候进行读取和处理。

    @Autowired private MessageRepository messageRepository;

    public void handleMessage(WebSocketSession session, TextMessage message) { // 存储消息到数据库或消息队列 messageRepository.save(message.getPayload()); }

    public List getMessages() { // 从数据库或消息队列中读取消息 return messageRepository.findAll(); }

  2. 多频道管理:如果你的应用需要管理多个频道或主题,可以考虑使用WebSocket的订阅和发布模式。你可以创建多个频道或主题,并在客户端订阅感兴趣的频道,以便接收相应的消息。

    @Autowired private SimpMessagingTemplate messagingTemplate;

    public void sendMessage(String channel, String message) { messagingTemplate.convertAndSend("/topic/" + channel, message); }

    public void subscribeChannel(String channel, WebSocketSession session) { messagingTemplate.subscribe("/topic/" + channel, session.getId()); }

    public void unsubscribeChannel(String channel, WebSocketSession session) { messagingTemplate.unsubscribe("/topic/" + channel, session.getId()); }

  3. 跨服务器部署:如果你的应用需要在多个服务器上部署,可以考虑使用分布式消息代理来实现跨服务器的消息传递。一种常见的方案是使用RabbitMQ或Apache Kafka等消息队列作为消息代理,以确保消息在不同服务器之间的可靠传递。

  4. 错误处理和异常处理:在处理WebSocket连接和消息时,可能会出现错误和异常。你可以实现WebSocketHandler接口的handleTransportErrorhandleMessageException方法来处理连接错误和消息异常,并进行相应的处理,例如记录日志、发送错误消息等。

    public class MyWebSocketHandler implements WebSocketHandler {

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        // 处理连接错误
    }
    
    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        try {
            // 处理接收到的消息
        } catch (Exception e) {
            // 处理消息异常
        }
    }
    

    }

七、会话心跳

  1. 消息编解码:在WebSocket应用中,消息的编码和解码是一个重要的环节。你可以使用Spring提供的消息编解码器来实现消息的转换和处理。例如,可以使用TextMessageEncoderTextMessageDecoder来进行文本消息的编解码。

    public class MyTextMessageEncoder implements MessageEncoder { @Override public ByteBuffer encode(String message) throws EncodeException { // 实现消息的编码逻辑 } }

    public class MyTextMessageDecoder implements MessageDecoder { @Override public String decode(ByteBuffer message) throws DecodeException { // 实现消息的解码逻辑 } }

  2. 心跳检测:为了确保WebSocket连接的稳定性,你可以实现心跳检测机制来监控连接的状态。可以使用定时任务来发送心跳消息,并在一定时间内未收到心跳响应时,断开连接或进行相应的处理。

    @Component public class HeartbeatScheduler {

    @Autowired
    private SimpMessagingTemplate messagingTemplate;
    
    @Scheduled(fixedDelay = 10000) // 每10秒发送一次心跳消息
    public void sendHeartbeatMessage() {
        messagingTemplate.convertAndSend("/topic/heartbeat", "Heartbeat");
    }
    

    }

    public class MyWebSocketHandler extends TextWebSocketHandler {

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        if ("Heartbeat".equals(message.getPayload())) {
            // 收到心跳消息,进行相应处理
            // ...
        } else {
            // 处理其他消息
            // ...
        }
    }
    

    }

  3. 自定义拦截器:你可以使用自定义拦截器来对WebSocket连接进行拦截和处理。拦截器可以用于认证、授权、日志记录等方面。通过实现HandshakeInterceptor接口,你可以在建立连接之前和之后进行相应的操作。

    public class MyHandshakeInterceptor implements HandshakeInterceptor { @Override public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception { // 在建立连接之前进行处理 // ... return true; }

    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response,
                               WebSocketHandler wsHandler, Exception exception) {
        // 在建立连接之后进行处理
        // ...
    }
    

    }

  4. 会话管理:在WebSocket应用中,你可能需要管理和跟踪每个连接的会话信息。你可以通过维护一个会话管理器来实现会话的创建、销毁和查询等操作。

    public class SessionManager {
        private Map<String, WebSocketSession> sessions = new ConcurrentHashMap<>();
    
        public void addSession(WebSocketSession session) {
            sessions.put(session.getId(), session);
        }
    
        public void removeSession(WebSocketSession session) {
            sessions.remove(session.getId());
        }
    
        public WebSocketSession getSession(String sessionId) {
            return sessions.get(sessionId);
        }
    
        public List<WebSocketSession> getAllSessions() {
            return new ArrayList<>(sessions.values());
        }
    }
    
转载自:https://juejin.cn/post/7244407068098560037
评论
请登录