springboot-rabbitMQ-websocket java项目

一个 Spring Boot 项目，使用 RabbitMQ 和 WebSocket 技术实现实时消息推送。主要包括以下模块：

1. RabbitMQ 消息队列模块：用于接收并处理消息，并把消息发送给 WebSocket 模块

2. WebSocket 消息推送模块：用于接收 RabbitMQ 模块发送的消息，并通过 WebSocket 推送给前端页面

3. 前端页面：使用 JavaScript 技术实现消息的实时推送

该项目可以应用于实时消息推送场景，例如在线聊天室、实时监控等。如果您对该项目感兴趣，可以参考以下链接：

1. https://github.com/zhoutaoo/SpringBootWebSocketRabbitmq
2. https://www.cnblogs.com/zhoutaoo/p/11767995.html

相关问题

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 客户端。

springboot-rabbitMQ-websocket java 注解实现

下面是一个简单的 Spring Boot + RabbitMQ + WebSocket 的实现，以注解方式完成：

1. 首先，需要在 pom.xml 中添加以下依赖：

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

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

2. 在 application.properties 中添加 RabbitMQ 和 WebSocket 的配置：

# RabbitMQ配置
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

# WebSocket配置
server.port=8080

3. 创建一个 RabbitMQ 的配置类，用于定义交换机、队列、绑定等：

@Configuration
public class RabbitMQConfig {

    @Bean
    public TopicExchange exchange() {
        return new TopicExchange("websocket-exchange");
    }

    @Bean
    public Queue queue() {
        return new Queue("websocket-queue");
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(exchange()).with("websocket.*");
    }
}

4. 创建一个 RabbitMQ 消息发送者：

@Component
public class RabbitMQSender {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String message) {
        rabbitTemplate.convertAndSend("websocket-exchange", "websocket.message", message);
    }
}

5. 创建一个 WebSocket 处理器，用于接收和发送消息：

@Component
public class WebSocketHandler extends TextWebSocketHandler {

    private final List<WebSocketSession> sessions = new CopyOnWriteArrayList<>();

    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        sessions.add(session);
    }

    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        sessions.remove(session);
    }

    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        String payload = message.getPayload();
        sendMessage(payload);
    }

    public void sendMessage(String message) throws IOException {
        for (WebSocketSession session : sessions) {
            session.sendMessage(new TextMessage(message));
        }
    }
}

6. 创建一个 RabbitMQ 消息接收者，用于将消息发送给 WebSocket 处理器：

@Component
public class RabbitMQReceiver {

    @Autowired
    private WebSocketHandler webSocketHandler;

    @RabbitListener(queues = "websocket-queue")
    public void receive(String message) throws IOException {
        webSocketHandler.sendMessage(message);
    }
}

7. 最后，在控制器中定义一个 API，用于发送消息到 RabbitMQ：

@RestController
public class MessageController {

    @Autowired
    private RabbitMQSender rabbitMQSender;

    @PostMapping("/send")
    public String sendMessage(@RequestBody String message) {
        rabbitMQSender.send(message);
        return "OK";
    }
}

以上就是一个简单的 Spring Boot + RabbitMQ + WebSocket 的实现，可以通过发送 POST 请求到 /send 接口来发送消息，WebSocket 处理器会接收到消息并发送给所有连接的客户端。