springboot-rabbitMQ-websocket java 实现

实现 Spring Boot、RabbitMQ 和 WebSocket 结合的方式主要有以下几个步骤：

1. 创建 Spring Boot 项目，添加 RabbitMQ 和 WebSocket 的相关依赖。

2. 创建 RabbitMQ 队列和交换机，用于发送消息。

3. 创建 WebSocket 配置类，配置 WebSocket 的相关参数。

4. 创建 WebSocket 处理器类，处理 WebSocket 的连接、消息发送等操作。

5. 创建 RabbitMQ 消息监听器类，监听 RabbitMQ 队列中的消息，将消息发送给 WebSocket 处理器。

下面是具体的实现步骤：

1. 创建 Spring Boot 项目，添加 RabbitMQ 和 WebSocket 的相关依赖。

在 pom.xml 中添加以下依赖：

<dependencies>
    <!-- RabbitMQ 相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    
    <!-- WebSocket 相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
    </dependency>
</dependencies>

2. 创建 RabbitMQ 队列和交换机，用于发送消息。

在 RabbitMQ 中创建一个交换机和一个队列，然后将队列绑定到交换机上。这里我们使用 RabbitMQ 的默认交换机和队列。

@Configuration
public class RabbitMQConfig {
    
    @Bean
    public Queue queue() {
        return new Queue("websocket");
    }
    
    @Bean
    public DirectExchange exchange() {
        return new DirectExchange("");
    }
    
    @Bean
    public Binding binding(Queue queue, DirectExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("websocket");
    }
    
}

3. 创建 WebSocket 配置类，配置 WebSocket 的相关参数。

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
    
    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.enableSimpleBroker("/topic");
        registry.setApplicationDestinationPrefixes("/app");
    }
    
    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/websocket").setAllowedOrigins("*").withSockJS();
    }
    
}

4. 创建 WebSocket 处理器类，处理 WebSocket 的连接、消息发送等操作。

@Component
public class WebSocketHandler implements WebSocketHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(WebSocketHandler.class);
    
    private SimpMessagingTemplate messagingTemplate;

    @Autowired
    public WebSocketHandler(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }
    
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        logger.info("WebSocket connected: {}", session.getId());
    }

    @Override
    public void handleMessage(WebSocketSession session, WebSocketMessage<?> message) throws Exception {
        logger.info("WebSocket received message: {}", message.getPayload());
    }

    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        logger.error("WebSocket transport error: {}", exception.getMessage());
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) throws Exception {
        logger.info("WebSocket disconnected: {}", session.getId());
    }

    @Override
    public boolean supportsPartialMessages() {
        return false;
    }
    
    public void sendMessage(String message) {
        messagingTemplate.convertAndSend("/topic/messages", message);
    }
    
}

5. 创建 RabbitMQ 消息监听器类，监听 RabbitMQ 队列中的消息，将消息发送给 WebSocket 处理器。

@Component
public class RabbitMQListener {
    
    private static final Logger logger = LoggerFactory.getLogger(RabbitMQListener.class);
    
    private WebSocketHandler webSocketHandler;

    @Autowired
    public RabbitMQListener(WebSocketHandler webSocketHandler) {
        this.webSocketHandler = webSocketHandler;
    }
    
    @RabbitListener(queues = "websocket")
    public void handleMessage(String message) {
        logger.info("RabbitMQ received message: {}", message);
        webSocketHandler.sendMessage(message);
    }
    
}

至此，Spring Boot、RabbitMQ 和 WebSocket 结合的实现就完成了。我们可以通过 RabbitMQ 发送消息到队列，然后监听器会将消息发送给 WebSocket 处理器，处理器再将消息发送给 WebSocket 客户端。