springboot 整合 rabbitMQ

在开始之前，需要先在rabbitMQ中创建一个名为chat.send.msg的消息队列。

1.pom文件

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

2.application.properties文件加上rabbitMQ的地址
注意，这里默认了你已经安装了rabbitMQ，spring.rabbitmq.addresses 那里就是你自己安装的rabbitMQ的地址

#rabbitmq配置
spring.rabbitmq.addresses=rabbitmq.com
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin123
spring.rabbitmq.virtual-host=chat

# 开启ACK
spring.rabbitmq.listener.simple.acknowledge-mode=manual
# 开启发送失败退回
spring.rabbitmq.publisher-returns=true
spring.jmx.default-domain=chat

3.建立消息体RabbitMqDto

package com.example.chat.utils;

import lombok.Data;

import java.io.Serializable;

@Data
public class RabbitMqDto implements Serializable {
    private String msg;
    private Integer type;
    private String key;
}

4.创建RabbitListener 这个类会监听消息队列

package com.example.chat.utils;


import com.example.chat.websockets.ChatSocket;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.websocket.Session;
import java.io.IOException;

@Component
@org.springframework.amqp.rabbit.annotation.RabbitListener(queues = "chat.send.msg")
public class RabbitListener {

    static RabbitProducer rabbitProducer;

    @Autowired
    public void setRabbitProducer(RabbitProducer rabbitProducer) {
        RabbitListener.rabbitProducer = rabbitProducer;
    }

    @RabbitHandler
    public void recieved(String jsonStr, Channel channel, Message message) throws IOException {
        ObjectMapper objectMapper = new ObjectMapper();
        RabbitMqDto rabbitMqDto = objectMapper.readValue(jsonStr, RabbitMqDto.class);

        Session session = ChatSocket.getSessionMapByKey(rabbitMqDto.getKey());//对方的session
        if (session != null) {
            rabbitMqDto.setKey(null);
            session.getAsyncRemote().sendText(jsonStr);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        } else {
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), true, false);
            rabbitProducer.sendMessages(jsonStr);
        }
    }
}

5.建立消息发送者

package com.example.chat.utils;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class RabbitProducer {
    @Autowired
    AmqpTemplate rabbitTemplate;
    //发送信息消息队列
    static final String MSGRABBITQUERENAME="chat.send.msg";
    public void sendMessages(String str) {
        this.rabbitTemplate.convertAndSend(MSGRABBITQUERENAME,str);
    }
}

到这里，基本框架是搭建好了。运行后，进入rabbit页面，可以看到

这里的chat消息队列已经有了一个监听者了。

注解
@org.springframework.amqp.rabbit.annotation.RabbitListener(queues = “chat.send.msg”)
这个注解就表示要监听的队列名为 chat.send.msg

当两个人要一对一进行聊天时，要做的动作无非两个
1.发送人发送信息到服务器
2.服务器发送信息到接收人

这里有一个问题，如果服务器上有A,B,C三个人，A发送给B，如何确保是A发送给B，而不是发送给C呢？

这里采取的办法是每当建立一个websocket连接，就在服务器里存储一个人，表示这个人 上线 了。

然后将A发送给B的消息传递到消息队列里，同时服务器监听队列，如果队列里的消息跟存储的人一致，就将该消息通过websocket发送到具体的人。

在监听消息时，

这一段代码就表示在系统在监听消息队列，每当一个消息进来，就会检查这个消息的接收者是否在服务器上，

    Session session = ChatSocket.getSessionMapByKey(rabbitMqDto.getKey());//对方的session

    //通过key获取session
    public static Session getSessionMapByKey(String key) {
        for (Map.Entry<String, Session> themap : map.entrySet()) {
            if (themap.getKey().equals(key)) {
                return themap.getValue();
            }
        }
        return null;
    }

通过这个方法，获取到接收人的session，再将消息通过
session.getAsyncRemote().sendText(jsonStr);
通过websocket发送到接收者。

这里使用的是确认模式，因为消息有可能发生丢失现象，
这种模式是
消息队列在发送消息后，并不马上就消息丢掉，而是要等待服务器返回一个确认信息，如果确认该消息被使用，队列才丢掉消息，否则消息会进入队列最后，重新等待发送。

开启ack确认模式
在application.properties中加上

# 开启ACK
spring.rabbitmq.listener.simple.acknowledge-mode=manual

git地址

https://github.com/bobly2/springboot-websocket-rabbitMQ