Spring Boot整合RabbitMQ案例(附源碼)

Spring Boot整合RabbitMQ案例

主要實現消息的生產發送、消息的消費並實現了消息的延時發送，像微信一樣實現第1-3次每5秒嘗試發送一次，第 4-5次每10秒嘗試一次等自定義消息延時時間。

1、創建Spring Boot項目

通過start.spring.io直接創建項目rabbit-mq-demo
選擇spring-boot-starter-amqp即可
以下爲pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.8.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>yangqisheng</groupId>
	<artifactId>rabbit-mq-demo</artifactId>
	<version>1.0.0</version>
	<name>rabbit-mq-demo</name>
	<description>消息重試機制案例</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-amqp</artifactId>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.45</version>
		</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>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

2、RabbitMQ自動創建交換機和隊列

我們爲了讓項目啓動時自動在RabbitMQ中創建交換機和隊列，我們新建RabbitConfig配置類來創建。

package yangqisheng.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author yangqisheng
 * @date 2019-09-29 上午 9:33
 */
@Configuration
public class RabbitConfig {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Value("${demo.rabbitmq.exchange}")
    private String demoExchange;
    @Value("${demo.rabbitmq.queue}")
    private String demoQueue;
    @Value("${demo.rabbitmq.routing-key}")
    private String demoRoutingKey;

    /**
     * 生成交換機
     *
     * @return 交換機對象
     */
    @Bean("demoExchange")
    public Exchange demoExchange() {
        return ExchangeBuilder.directExchange(demoExchange).durable(true).build();
    }

    /**
     * 生成隊列
     *
     * @return 隊列
     */
    @Bean("demoQueue")
    public Queue demoQueue() {
        return QueueBuilder.durable(demoQueue).build();
    }

    /**
     * 交換機綁定隊列和路由
     *
     * @return 綁定對象
     */
    @Bean
    public Binding demoBinding() {
        return new Binding(demoQueue, Binding.DestinationType.QUEUE, demoExchange, demoRoutingKey, null);
    }
}

以上項目包含了項目的配置application.properties，以下：

server.port=8000

spring.rabbitmq.hostname: 127.0.0.1
spring.rabbitmq.port: 5672
spring.rabbitmq.virtualhost: /
spring.rabbitmq.username: guest
spring.rabbitmq.password: guest

demo.rabbitmq.exchange=demo.exchange
demo.rabbitmq.queue=demo.queue
demo.rabbitmq.routing-key=demo.routing-key

demo.rabbitmq.delay-exchange=demo.delay-exchange
demo.rabbitmq.delay-queue=demo.delay-queue
demo.rabbitmq.delay-routing-key=demo.delay-routing-key

demo.rabbitmq.error-exchange=demo.error-exchange
demo.rabbitmq.error-queue=demo.error-queue
demo.rabbitmq.error-routing-key=demo.error-routing-key

大家肯定發現了我們配置裏多了2個交換機配置delay和error
delay就是用來做延時隊列，可以設置延時時間，然年後重新發送，
error就是實在是嘗試了很多次都不成功，就只能存檔了。
我們先來實現一個消息生產者：

package yangqisheng.producter;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import yangqisheng.domain.DemoMessage;

/**
 * @author yangqisheng
 * @date 2019-09-29 上午 9:54
 */
@Slf4j
@Component
public class DemoProducter {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Value("${demo.rabbitmq.exchange}")
    private String demoExchange;
    @Value("${demo.rabbitmq.routing-key}")
    private String demoRoutingKey;

    /**
     * 發送消息
     *
     * @param content 消息內容
     */
    public void sendMessage(DemoMessage content) {
        log.info("發送消息：{}", content);
        rabbitTemplate.convertAndSend(demoExchange, demoRoutingKey, JSONObject.toJSONString(content), message -> {
            message.getMessageProperties().setContentEncoding("utf-8");
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            message.getMessageProperties().setMessageId(content.getMessageId());
            return message;
        });
    }
}

爲了模擬消息發送，我寫了個定時器

package yangqisheng.task;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import yangqisheng.domain.DemoMessage;
import yangqisheng.producter.DemoProducter;

/**
 * @author yangqisheng
 * @date 2019-09-29 上午 10:08
 */
@Slf4j
@Component
public class DemoTask {

    @Autowired
    private DemoProducter demoProducter;
    private int count = 0;

    /**
     * 每秒產生一條消息
     */
    @Scheduled(fixedDelay = 1000)
    public void run() {
        count++;
        if (count < 20 && count % 5 == 0) {
            DemoMessage message = new DemoMessage();
            message.setMessageId(count + "");
            message.setContent("第" + count + "條");
            message.setMessageCount(0);
            demoProducter.sendMessage(message);
        }
    }
}

我們爲了模擬延時和錯誤，我們生產3條消息，每個5秒發送一次，這樣可以模擬每次重試的時間差

下面我們寫一個消費者：

package yangqisheng.consumer;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;
import yangqisheng.domain.DemoMessage;
import yangqisheng.producter.*;

import java.util.Map;

/**
 * @author yangqisheng
 * @date 2019-09-29 上午 9:59
 */
@Slf4j
@Component
public class DemoConsumer {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private DemoDelayProducter demoDelayProducter;
    @Autowired
    private DemoDelay10Producter demoDelay10Producter;
    @Autowired
    private DemoDelay20Producter demoDelay20Producter;
    @Autowired
    private DemoDelay30Producter demoDelay30Producter;
    @Autowired
    private DemoDelay60Producter demoDelay60Producter;
    @Autowired
    private DemoDelay300Producter demoDelay300Producter;
    @Autowired
    private DemoErrorProducter demoErrorProducter;

    @RabbitListener(queues = "${demo.rabbitmq.queue}")
    public void receiveMessage(@Headers Map<String, Object> headers, Message message) {
        DemoMessage content = null;
        try {
            content = JSONObject.parseObject(new String(message.getBody()), DemoMessage.class);
            log.info("接收消息：messageId={},content={},第{}次", 
                    content.getContent(), message.getMessageProperties().getMessageId(), content.getMessageCount());
            throw new Exception("消費異常");
        } catch (Exception e) {
            if (content == null) {
                demoErrorProducter.sendErrorMessage(message.getBody());
            }
            content.setMessageCount(content.getMessageCount() + 1);
            switch (content.getMessageCount()) {
                case 1:
                case 2:
                case 3:
                    demoDelayProducter.sendDelayMessage(content);
                    break;
                case 4:
                case 5:
                    demoDelay10Producter.sendDelayMessage(content);
                    break;
                case 6:
                case 7:
                    demoDelay20Producter.sendDelayMessage(content);
                    break;
                case 8:
                    demoDelay30Producter.sendDelayMessage(content);
                    break;
                case 9:
                    demoDelay60Producter.sendDelayMessage(content);
                    break;
                case 10:
                    demoDelay300Producter.sendDelayMessage(content);
                    break;
                default:
                    demoErrorProducter.sendErrorMessage(content);
            }
        }
    }
}

大家肯定看你到，我們寫了好多個消息生產者，其實就爲了生成多個隊列。
我們列出一個10秒的作爲案例，其他的僅僅是更改了名稱，大家可以下源碼查看。

package yangqisheng.producter;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import yangqisheng.domain.DemoMessage;

/**
 * @author yangqisheng
 * @date 2019_09_29 上午 10:30
 */
@Slf4j
@Component
public class DemoDelay10Producter {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Value("${demo.rabbitmq.delay-exchange}")
    private String demoDelayExchange;
    @Value("${demo.rabbitmq.delay-routing-key}")
    private String demoDelayRoutingKey;

    /**
     * 發送延時消息
     *
     * @param content 消息內容
     */
    public void sendDelayMessage(DemoMessage content) {
        log.info("再次發送消息：{}", content.getContent());
        rabbitTemplate.convertAndSend(demoDelayExchange + "_10", demoDelayRoutingKey + "_10",
                JSONObject.toJSONString(content), message -> {
                    message.getMessageProperties().setContentEncoding("utf-8");
                    message.getMessageProperties().setMessageId(content.getMessageId());
                    message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                    String expiration = "10000";
                    log.info("消息{}第{}次重新發送，延時{}ms", content.getMessageId(),
                            content.getMessageCount(), expiration);
                    //根據發送次數，計算下次發送時間
                    message.getMessageProperties().setExpiration(expiration);
                    return message;
                });
    }
}

延時隊列

package yangqisheng.producter;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import yangqisheng.domain.DemoMessage;

/**
 * @author yangqisheng
 * @date 2019_09_29 上午 10:30
 */
@Slf4j
@Component
public class DemoDelayProducter {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Value("${demo.rabbitmq.delay-exchange}")
    private String demoDelayExchange;
    @Value("${demo.rabbitmq.delay-routing-key}")
    private String demoDelayRoutingKey;

    /**
     * 發送延時消息
     *
     * @param content 消息內容
     */
    public void sendDelayMessage(DemoMessage content) {
        log.info("再次發送消息：{}", content.getContent());
        rabbitTemplate.convertAndSend(demoDelayExchange, demoDelayRoutingKey,
                JSONObject.toJSONString(content), message -> {
                    message.getMessageProperties().setContentEncoding("utf-8");
                    message.getMessageProperties().setMessageId(content.getMessageId());
                    message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                    String expiration = "5000";
                    log.info("消息{}第{}次重新發送，延時{}ms", content.getMessageId(), 
                    content.getMessageCount(), expiration);
                    //根據發送次數，計算下次發送時間
                    message.getMessageProperties().setExpiration(expiration);
                    return message;
                });
    }
}

錯誤隊列

package yangqisheng.producter;

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import yangqisheng.domain.DemoMessage;

/**
 * @author yangqisheng
 * @date 2019-09-29 上午 9:54
 */
@Slf4j
@Component
public class DemoErrorProducter {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Value("${demo.rabbitmq.error-exchange}")
    private String demoErrorExchange;
    @Value("${demo.rabbitmq.error-routing-key}")
    private String demoErrorRoutingKey;

    /**
     * 發送消息
     *
     * @param content 消息內容
     */
    public void sendErrorMessage(DemoMessage content) {
        log.info("記錄錯誤消息：{}", content.getContent());
        rabbitTemplate.convertAndSend(demoErrorExchange, demoErrorRoutingKey, 
        JSONObject.toJSONString(content), message -> {
            message.getMessageProperties().setContentEncoding("utf-8");
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            message.getMessageProperties().setMessageId(content.getMessageId());
            return message;
        });
    }

    /**
     * 發送消息
     *
     * @param content 消息內容
     */
    public void sendErrorMessage(byte[] content) {
        log.info("記錄異常消息：內容長度{}", content.length);
        rabbitTemplate.convertAndSend(demoErrorExchange, demoErrorRoutingKey, content, message -> {
            message.getMessageProperties().setContentEncoding("utf-8");
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            return message;
        });
    }
}

項目啓動入口

package yangqisheng;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class RabbitMqDemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(RabbitMqDemoApplication.class, args);
	}

}

如果還看不明白，那麼請看源碼
https://github.com/ansitech/rabbit-mq-demo

Spring Boot整合RabbitMQ案例(附源碼)

Spring Boot整合RabbitMQ案例

1、創建Spring Boot項目

2、RabbitMQ自動創建交換機和隊列

這個網絡爬蟲代碼，拿到數據之後如何存到csv文件中去？

即刻放大鏡。跟隨鼠標，屏幕任意位置放大

【面試準備】【SQL】數據庫有哪些約束？

.NET開源強大、易於使用的緩存框架 - FusionCache

面試，有時候是個運氣活

Weixin4j微信開發網頁授權獲取openid案例

手把手教您開發JAVA微信SDK-發送消息

手把手微信開發之WeixinUrlFilter完整源碼

Spring Boot整合RabbitMQ案例(附源碼)

手把手教您開發JAVA微信SDK-新手接入

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結