foreword
I learned the basics of RabbitMQ before, and now I mainly record the records of learning Spring Boot to integrate RabbitMQ, calling its API, and related functions used in the middle.
Related can go to my blog/RabbitMQ
text
I test here using the topicexchange , Spring Boot 2.0.0, jdk 1.8
configure
Spring Boot version 2.0.0 introduces AMQP dependencies
in the pom.xmlfile
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>Add connection properties to the system configuration file
spring:
application:
name: RabbitMQ-Demo
rabbitmq:
host: k.wuwii.com
port: 5672
username: kronchan
password: 123456
#virtual-host: test
publisher-confirms: true # 开启确认消息是否到达交换器，需要设置 true
publisher-returns: true # 开启确认消息是否到达队列，需要设置 truebasic use
consumer
Add a new consumer class:
@Log
public class MessageReceiver implements ChannelAwareMessageListener {
@Override
public void onMessage(Message message, Channel channel) throws Exception {
try {
byte[] body = message.getBody();
log.info(">>>>>>> receive： " + new String(body));
} finally {
// 确认成功消费，否则消息会转发给其他的消费者，或者进行重试
channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
}
}
}configuration class
Added RabbitMQ configuration class, mainly for some settings of consumer queues, exchanges, and routing keys:
@Configuration
public class RabbitMQConfig {
public final static String QUEUE_NAME = "springboot.demo.test1";
public final static String ROUTING_KEY = "route-key";
public final static String EXCHANGES_NAME = "demo-exchanges";
@Bean
public Queue queue() {
// 是否持久化
boolean durable = true;
// 仅创建者可以使用的私有队列，断开后自动删除
boolean exclusive = false;
// 当所有消费客户端连接断开后，是否自动删除队列
boolean autoDelete = false;
return new Queue(QUEUE_NAME, durable, exclusive, autoDelete);
}
/**
* 设置交换器，这里我使用的是 topic exchange
*/
@Bean
public TopicExchange exchange() {
// 是否持久化
boolean durable = true;
// 当所有消费客户端连接断开后，是否自动删除队列
boolean autoDelete = false;
return new TopicExchange(EXCHANGES_NAME, durable, autoDelete);
}
/**
* 绑定路由
*/
@Bean
public Binding binding(Queue queue, TopicExchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY);
}
@Bean
public SimpleMessageListenerContainer container(ConnectionFactory connectionFactory) {
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.setQueueNames(QUEUE_NAME);
container.setMessageListener(receiver());
//container.setMaxConcurrentConsumers(1);
//container.setConcurrentConsumers(1); 默认为1
//container.setExposeListenerChannel(true);
container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // 设置为手动，默认为 AUTO，如果设置了手动应答 basicack，就要设置manual
return container;
}
@Bean
public MessageReceiver receiver() {
return new MessageReceiver();
}
}producer
@Component
public class MessageSender {
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* logger
*/
private static final Logger log = LoggerFactory.getLogger(MessageSender.class);
public void send() {
// public void convertAndSend(String exchange, String routingKey, final Object object, CorrelationData correlationData)
// exchange: 交换机名称
// routingKey: 路由关键字
// object: 发送的消息内容
// correlationData:消息ID
CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
// ConfirmListener是当消息无法发送到Exchange被触发，此时Ack为False，这时cause包含发送失败的原因，例如exchange不存在时
// 需要在系统配置文件中设置 publisher-confirms: true
if (!rabbitTemplate.isConfirmListener()) {
rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
if (ack) {
log.info(">>>>>>> 消息id:{} 发送成功", correlationData.getId());
} else {
log.info(">>>>>>> 消息id:{} 发送失败", correlationData.getId());
}
});
}
// ReturnCallback 是在交换器无法将路由键路由到任何一个队列中，会触发这个方法。
// 需要在系统配置文件中设置 publisher-returns: true
rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
log.info("消息id：{} 发送失败", message.getMessageProperties().getCorrelationId());
});
rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGES_NAME, RabbitMQConfig.ROUTING_KEY, ">>>>> Hello World", correlationId);
log.info("Already sent message.");
}
}test send message
First start the system startup class, the consumer starts to subscribe, and the test class starts to send messages.
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRabbitmqApplicationTests {
@Autowired
private MessageSender sender;
@Test
public void testReceiver() {
sender.send();
}
}The information can be received at the consumer, and the sender will log a record of successfully sending the message, or you can test the two methods: Publisher Confirms and Returns机制mainly test ConfirmCallbackand ReturnCallbackthese two methods.
* ConfirmCallback, to confirm whether the message arrives at the exchange, for example, we send a message to an exchange that you have not created to see the situation,
* ReturnCallback, to confirm whether the message arrives in the queue, we can test like this, define a routing key, not It is subscribed to by any queue, and you can finally view the results.
How to use annotations
Introduce dependencies and connection parameters
The configuration is the same as the first step of the article.
consumer
@Component
@Log
public class MessageReceiver {
/**
* 无返回消息的
*
* @param message
*/
@RabbitListener(bindings = @QueueBinding(value = @Queue(value = Constant.QUEUE_NAME, durable = "true", exclusive = "false", autoDelete = "false"),
exchange = @Exchange(value = Constant.EXCHANGES_NAME, ignoreDeclarationExceptions = "true", type = ExchangeTypes.TOPIC, autoDelete = "false"),
key = Constant.ROUTING_KEY))
public void receive(byte[] message) {
log.info(">>>>>>>>>>> receive：" + new String(message));
}
/**
* 设置有返回消息的
* 需要注意的是，
* 1. 在消息的在生产者（发送消息端）一定要使用 SendAndReceive(……) 这种带有 receive 的方法，否则会抛异常，不捕获会死循环。
* 2. 该方法调用时会锁定当前线程，并且有可能会造成MQ的性能下降或者服务端/客户端出现死循环现象，请谨慎使用。
*
* @param message
* @return
*/
@RabbitListener(bindings = @QueueBinding(value = @Queue(value = Constant.QUEUE_NAME, durable = "true", exclusive = "false", autoDelete = "false"),
exchange = @Exchange(value = Constant.EXCHANGES_NAME, ignoreDeclarationExceptions = "true", type = ExchangeTypes.TOPIC, autoDelete = "false"),
key = Constant.ROUTING_REPLY_KEY))
public String receiveAndReply(byte[] message) {
log.info(">>>>>>>>>>> receive：" + new String(message));
return ">>>>>>>> I got the message";
}
}It is mainly used @RabbitListener. Although it seems that there are many parameters, if you look carefully, you will find that this is exactly the same as the basic properties in the configuration class, and there is no difference.
It should be noted that I made a message with a return value here. If this is used abnormally, the message will be retried continuously, thus blocking the thread. And when using it, you can only send messages to it receiveusing .
producer
Producers are unchanged.
@Component
public class MessageSender implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {
/**
* logger
*/
private static final Logger log = LoggerFactory.getLogger(MessageSender.class);
private RabbitTemplate rabbitTemplate;
/**
* 注入 RabbitTemplate
*/
@Autowired
public MessageSender(RabbitTemplate rabbitTemplate) {
this.rabbitTemplate = rabbitTemplate;
this.rabbitTemplate.setConfirmCallback(this);
this.rabbitTemplate.setReturnCallback(this);
}
/**
* 测试无返回消息的
*/
public void send() {
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
rabbitTemplate.convertAndSend(Constant.EXCHANGES_NAME, Constant.ROUTING_KEY, ">>>>>> Hello World".getBytes(), correlationData);
log.info(">>>>>>>>>> Already sent message");
}
/**
* 测试有返回消息的，需要注意一些问题
*/
public void sendAndReceive() {
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
Object o = rabbitTemplate.convertSendAndReceive(Constant.EXCHANGES_NAME, Constant.ROUTING_REPLY_KEY, ">>>>>>>> Hello World Second".getBytes(), correlationData);
log.info(">>>>>>>>>>> {}", Objects.toString(o));
}
/**
* Confirmation callback.
*
* @param correlationData correlation data for the callback.
* @param ack true for ack, false for nack
* @param cause An optional cause, for nack, when available, otherwise null.
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
if (ack) {
log.info(">>>>>>> 消息id:{} 发送成功", correlationData.getId());
} else {
log.info(">>>>>>> 消息id:{} 发送失败", correlationData.getId());
}
}
/**
* Returned message callback.
*
* @param message the returned message.
* @param replyCode the reply code.
* @param replyText the reply text.
* @param exchange the exchange.
* @param routingKey the routing key.
*/
@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
log.info("消息id：{} 发送失败", message.getMessageProperties().getCorrelationId());
}
}test
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootAnnotationApplicationTests {
@Autowired
private MessageSender sender;
@Test
public void send() {
sender.send();
}
@Test
public void sendAndReceive() {
sender.sendAndReceive();
}
}