SpringBoot2.x整合RabbitMQ（完整版）

本篇文章實現了 SpringBoot整合RabbitMQ，實現了 work模型，發佈訂閱模型，topic模型，confirm消息確認機制，return消息機制，TTL隊列，死信隊列等。

整合方式有很多，比如使用 RabbitAdmin進行整合，本文介紹一個最簡單的整合方式，只需要在 RabbitmqConfig.java 配置文件中進行簡單配置，便可以方便的使用。相信你會喜歡這種方式的。

基本配置信息

pom.xml

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

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

application.properties

# 應用名
spring.application.name=springboot-rabbitmq
# rabbitmq配置信息
# ip
spring.rabbitmq.host=rabbitmq服務器的ip
# 端口
spring.rabbitmq.port=5672
# 用戶名
spring.rabbitmq.username=kongming
# 密碼
spring.rabbitmq.password=mima
# 配置虛擬機
spring.rabbitmq.virtual-host=/
# 消息開啓手動確認
spring.rabbitmq.listener.direct.acknowledge-mode=manual

User.java

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final long serialVersionUID = 8142836626401616290L;
    private Integer id;
    private String name;
    private String password;
}

work模型

RabbitmqConfig.java

@SpringBootConfiguration
public class RabbitmqConfig {

    // 配置一個工作模型隊列
    @Bean
    public Queue queueWork1() {
        return new Queue("queue_work");
    }
}

RabbitmqController.java

@RestController
public class RabbitmqController {
    @Autowired
    private RabbitmqService rabbitmqService;

    @RequestMapping("/sendWork")
    public Object sendWork() {
        rabbitmqService.sendWork();
        return "發送成功...";
    }
}

RabbitmqServiceImpl.java

@Service
public class RabbitmqServiceImpl implements RabbitmqService {
    @Autowired
    private RabbitmqMapper rabbitmqMapper;

    @Override
    public void sendWork() {
        rabbitmqMapper.sendWork();
    }
}

RabbitmqMapper.java

@Component
public class RabbitmqMapper {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendWork() {
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("queue_work", "測試work模型: " + i);
        }
    }
}

WorkReceiveListener.java

// 2個消費者
@Component
public class WorkReceiveListener {
    @RabbitListener(queues = "queue_work")
    public void receiveMessage(String msg, Channel channel, Message message) {
        // 只包含發送的消息
        System.out.println("1接收到消息：" + msg);
        // channel 通道信息
        // message 附加的參數信息
    }

    @RabbitListener(queues = "queue_work")
    public void receiveMessage2(Object obj, Channel channel, Message message) {
        // 包含所有的信息
        System.out.println("2接收到消息：" + obj);
    }
}

訪問 http://127.0.0.1:8080/sendWork，輸出如下數據

發佈訂閱模型

RabbitmqConfig.java

// 發佈訂閱模式
// 聲明兩個隊列
@Bean
public Queue queueFanout1() {
    return new Queue("queue_fanout1");
}
@Bean
public Queue queueFanout2() {
    return new Queue("queue_fanout2");
}
// 準備一個交換機
@Bean
public FanoutExchange exchangeFanout() {
    return new FanoutExchange("exchange_fanout");
}
// 將交換機和隊列進行綁定
@Bean
public Binding bindingExchange1() {
    return BindingBuilder.bind(queueFanout1()).to(exchangeFanout());
}
@Bean
public Binding bindingExchange2() {
    return BindingBuilder.bind(queueFanout2()).to(exchangeFanout());
}

RabbitmqController.java

@RequestMapping("/sendPublish")
public String sendPublish() {
    rabbitmqService.sendPublish();
    return "發送成功...";
}

RabbitmqServiceImpl.java

@Override
public void sendPublish() {
    rabbitmqMapper.sendPublish();
}

RabbitmqMapper.java

// 向發佈訂閱模式裏面發送消息
public void sendPublish() {
    for (int i = 0; i < 5; i++) {
        // rabbitTemplate.convertSendAndReceive("exchange_fanout", "", "測試發佈訂閱模型：" + i);
        rabbitTemplate.convertAndSend("exchange_fanout", "", "測試發佈訂閱模型：" + i);
    }
}

PublishReceiveListener.java

@Component
public class PublishReceiveListener {

    @RabbitListener(queues = "queue_fanout1")
    public void receiveMsg1(String msg) {
        System.out.println("隊列1接收到消息：" + msg);
    }

    @RabbitListener(queues = "queue_fanout2")
    public void receiveMsg2(String msg) {
        System.out.println("隊列2接收到消息：" + msg);
    }
}

測試結果

http://localhost:8080/sendPublish

使用 convertAndSend 方法時的結果：輸出時沒有順序，不需要等待，直接運行

使用 convertSendAndReceive 方法時的結果：按照一定的順序，只有確定消費者接收到消息，纔會發送下一條信息，每條消息之間會有間隔時間

RabbitTemplate中convertSendAndReceive方法與convertAndSend方法的區別

topic模型

RabbitmqConfig.java

// topic 模型
@Bean
public Queue queueTopic1() {
    return new Queue("queue_topic1");
}
@Bean
public Queue queueTopic2() {
    return new Queue("queue_topic2");
}
@Bean
public TopicExchange exchangeTopic() {
    return new TopicExchange("exchange_topic");
}
@Bean
public Binding bindingTopic1() {
    return BindingBuilder.bind(queueTopic1()).to(exchangeTopic()).with("topic.#");
}
@Bean
public Binding bindingTopic2() {
    return BindingBuilder.bind(queueTopic2()).to(exchangeTopic()).with("topic.*");
}

RabbitmqController.java

@RequestMapping("/sendTopic")
public String sendTopic() {
    rabbitmqService.sendTopic();
    return "發送成功...";
}

RabbitmqServiceImpl.java

@Override
public void sendTopic() {
    rabbitmqMapper.sendTopic();
}

RabbitmqMapper.java

// 向topic模型發送數據
public void sendTopic() {
    for (int i = 0; i < 10; i++) {
        if (i % 2 == 0) {
            rabbitTemplate.convertSendAndReceive("exchange_topic", "topic.km.topic", "測試發佈訂閱模型：" + i);
        } else {
            rabbitTemplate.convertSendAndReceive("exchange_topic", "topic.km", "測試發佈訂閱模型：" + i);

        }
    }
}

TopicReceiveListener.java

@Component
public class TopicReceiveListener {

    @RabbitListener(queues = "queue_topic1")
    public void receiveMsg1(String msg) {
        System.out.println("消費者1接收到：" + msg);
    }

    @RabbitListener(queues = "queue_topic2")
    public void receiveMsg2(String msg) {
        System.out.println("消費者2接收到：" + msg);
    }
}

測試結果

可以看出來，消費者1 接收到了所有的數據，消費者2只接受到了一半（奇數）的數據

confirm機制

application.properties

# 開啓消息確認機制 confirm 異步
spring.rabbitmq.publisher-confirm-type=correlated
# 之前的舊版本 開啓消息確認機制的方式
# spring.rabbitmq.publisher-confirms=true
# 消息開啓手動確認
spring.rabbitmq.listener.direct.acknowledge-mode=manual

RabbitmqConfig.java

// 測試confirm 機制，專門創建了一個隊列
@Bean
public Queue queueConfirm() {
    return new Queue("queue_confirm");
}

RabbitmqController.java

@RequestMapping("/sendConfirm")
public String sendConfirm() {
    rabbitmqService.sendConfirm();
    return "發送成功...";
}

RabbitmqServiceImpl.java

@Override
public void sendConfirm() {
    rabbitmqMapper.sendConfirm();
}

RabbitmqMapper.java

// 配置 confirm 機制
private final RabbitTemplate.ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {
    /**
         * @param correlationData 消息相關的數據，一般用於獲取 唯一標識 id
         * @param b true 消息確認成功，false 失敗
         * @param s 確認失敗的原因
         */
    @Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {
        if (b) {
            System.out.println("confirm 消息確認成功..." + correlationData.getId());
        } else {
            System.out.println("confirm 消息確認失敗..." + correlationData.getId() + " cause: " + s);
        }
    }
};
// 測試 confirm機制
public void sendConfirm() {
    rabbitTemplate.convertAndSend("queue_confirm", new User(1, "km", "km123"), new CorrelationData("" + System.currentTimeMillis()));
    rabbitTemplate.setConfirmCallback(confirmCallback);
}

ConfirmReceiveListener.java

@Component
public class ConfirmReceiveListener {
    @RabbitListener(queues = "queue_confirm")
    public void receiveMsg(User user) {
        System.out.println("接收到的消息爲：" + user);
    }
}

測試結果

http://localhost:8080/sendConfirm

注意

使用confirm機制時，發送消息時最好把CorrelationData 加上，因爲如果出錯了，使用 CorrelationData 可以更快的定位到錯誤信息

return機制

application.properties

# 開啓return機制
spring.rabbitmq.publisher-returns=true
# 消息開啓手動確認
spring.rabbitmq.listener.direct.acknowledge-mode=manual

RabbitmqConfig.java

// 測試return機制
@Bean
public Queue queueReturn() {
    return new Queue("queue_return");
}
@Bean
public TopicExchange exchangeReturn() {
    return new TopicExchange("exchange_return");
}
@Bean
public Binding bindingReturn() {
    return BindingBuilder.bind(queueReturn()).to(exchangeReturn()).with("return.*");
}

RabbitmqController.java

@RequestMapping("/sendReturn")
public String sendReturn() {
    rabbitmqService.sendReturn();
    return "發送成功...";
}

RabbitmqServiceImpl.java

@Override
public void sendReturn() {
    rabbitmqMapper.sendReturn();
}

RabbitmqMapper.java

// 配置 return 消息機制
private final RabbitTemplate.ReturnCallback returnCallback = new RabbitTemplate.ReturnCallback() {
    /**
         *  return 的回調方法（找不到路由纔會觸發）
         * @param message 消息的相關信息
         * @param i 錯誤狀態碼
         * @param s 錯誤狀態碼對應的文本信息
         * @param s1 交換機的名字
         * @param s2 路由的key
         */
    @Override
    public void returnedMessage(Message message, int i, String s, String s1, String s2) {
        System.out.println(message);
        System.out.println(new String(message.getBody()));
        System.out.println(i);
        System.out.println(s);
        System.out.println(s1);
        System.out.println(s2);
    }
};
// 測試return機制
public void sendReturn() {
    rabbitTemplate.setReturnCallback(returnCallback);
    rabbitTemplate.convertAndSend("exchange_return", "return.km.km", "測試 return 機制");
    // rabbitTemplate.convertAndSend("exchange_return", "return.km", "測試 return 機制");
}

ReturnReceiveListener.java

@Component
public class ReturnReceiveListener {
    @RabbitListener(queues = "queue_return")
    public void receiveMsg(String msg) {
        System.out.println("接收的消息爲：" + msg);
    }
}

測試結果

使用正確的路由：return.km

錯誤的路由打印的信息：return.km.km

TTL隊列、死信隊列

TTL隊列、死信隊列和普通隊列的用法是一致的，這裏只說明其創建方式

RabbitmqConfig.java

// TTL 隊列
@Bean
public Queue queueTTL() {
    Map<String, Object> map = new HashMap<>(1);
    map.put("x-message-ttl", 10000);
    return new Queue("queue_ttl", true, false, false, map);
}

// 產生死信的隊列
@Bean
public Queue queueDLX() {
    Map<String, Object> map = new HashMap<>(2);
    // 5秒後，消息自動變爲死信
    map.put("x-message-ttl", 5000);
    map.put("x-dead-letter-exchange", "exchange_receive");
    map.put("x-dead-letter-routing-key", "receive_key");
    return new Queue("queue_dlx", true, false, false, map);
}
// 死信交換機
@Bean
public DirectExchange exchangeDLX() {
    return new DirectExchange("exchange_dlx");
}
// 給死信隊列綁定交換機
@Bean
public Binding bindingDLX() {
    return BindingBuilder.bind(queueDLX()).to(exchangeDLX()).with("receive_key");
}
// 死信接收交換機
@Bean
public DirectExchange exchangeReceive() {
    return new DirectExchange("exchange_receive");
}
// 接收死信的隊列
@Bean
public Queue queueReceive() {
    return new Queue("queue_receive");
}
// 將交換機與隊列綁定
@Bean
public Binding bindingReceive() {
    return BindingBuilder.bind(queueReceive()).to(exchangeReceive()).with("receive_key");
}

測試

啓動項目後，隊列和交換機已經初始化完畢，可前往 http://rabbitmqip:15672/ 自行驗證死信隊列以及TTL隊列

點擊 dlx 交換機

輸入 key 和要發送的值，publish

剛開始，queue_dlx 中有一條數據，5秒後，消息變成死信，自動轉移到 queue_receive 中

本文若有錯誤，還請各路大佬指正指正！