引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
连接配置
# 注意:mq事件配置不正确(包括Tab和空格格式不正确),会导致服务注册失败
rabbitmq:
host: 你的mq部署地址
port: 5672
# 账号密码
username: 你的账号
password: 你的密码
#支持发布确认
publisher-confirm-type: correlated
#支持发布返回
publisher-returns: true
#虚拟主机
virtual-host: 你的虚拟主机(例如:smz)
listener:
retry:
enabled: true
max-attempts: 3
simple:
concurrency: 10 #最小并发数
max-concurrency: 20 #最大并发数
prefetch: 100 #从mq一次获取消息的数量
default-requeue-rejected: true #如果出现异常,是否需要重新投递消息, false表示丢弃。 也有相应的Exception, true-MessageRejectedWhileStoppingException false-AmqpRejectAndDontRequeueException
acknowledge-mode: manual #ack机制:手动确认,可以具体业务中设置是否ack确认
template:
retry:
enabled: true
max-attempts: 3
设置配置文件
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.annotation.Resource;
@Configuration
@Slf4j
public class RabbitConfig {
@Resource RabbitTemplate rabbitTemplate;
// @Bean
// public RabbitMqSender rabbitMqSender() {
// return new RabbitMqSender();
// }
/**
* 定制化amqp模版 可根据需要定制多个
*
* <p>
*
* <p>此处为模版类定义 Jackson消息转换器 ConfirmCallback接口用于实现消息发送到RabbitMQ交换器后接收ack回调 即消息发送到exchange ack
* ReturnCallback接口用于实现消息发送到RabbitMQ 交换器,但无相应队列与交换器绑定时的回调 即消息发送不到任何一个队列中 ack
*
* @return the amqp template
*/
// @Primary
@Bean
public AmqpTemplate amqpTemplate() {
Logger log = LoggerFactory.getLogger(RabbitTemplate.class);
// 使用jackson 消息转换器
rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
rabbitTemplate.setEncoding("UTF-8");
// 开启returncallback yml 需要 配置 publisher-returns: true
rabbitTemplate.setMandatory(true);
rabbitTemplate.setReturnCallback(
(message, replyCode, replyText, exchange, routingKey) -> {
String correlationId = message.getMessageProperties().getCorrelationId();
log.info(
"消息:{} 发送失败, 应答码:{} 原因:{} 交换机: {} 路由键: {}",
correlationId,
replyCode,
replyText,
exchange,
routingKey);
});
// 消息确认 yml 需要配置 publisher-returns: true
rabbitTemplate.setConfirmCallback(
(correlationData, ack, cause) -> {
if (ack) {
if (correlationData != null) {
log.info("消息发送到exchange成功,id: {}", correlationData.getId());
}
} else {
log.error("消息发送到exchange失败,原因: {}", cause);
}
});
return rabbitTemplate;
}
}
发送消息配置
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.UUID;
@Component
@Slf4j
public class RabbitMqSender {
@Autowired private RabbitTemplate rabbitTemplate;
/**
* 所有发送到Topic Exchange的消息被转发到所有关心RouteKey中指定Topic的Queue上
* 发送正常消息
* @param exchange 交换机名称
* @param routeKey 路由key
* @param data 发送的数据
*/
public void sendMQ(String exchange, String routeKey, Object data) {
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
log.info(
"send: exchange={}, routeKey={}, message={}, id={}",
exchange,
routeKey,
data,
correlationData.getId());
this.rabbitTemplate.convertAndSend(exchange, routeKey, data, correlationData);
}
/**
* 发送延时信息
*
* @param exchange 交换机名称
* @param routeKey 路由key
* @param data 发送的数据
* @param delayTimes 延迟时间/秒
*/
public void sendDelayMessage(
String exchange, String routeKey, Object data, final Integer delayTimes) {
// 给延迟队列发送消息
this.rabbitTemplate.convertAndSend(
exchange,
routeKey,
data,
message -> {
// 给消息设置延迟毫秒值
message.getMessageProperties().setHeader("x-delay", delayTimes * 1000);
return message;
});
log.info("send delay message data:{}", data);
}
}
公共枚举
public interface MqConstants {
String containerFactory = "rabbitListenerContainerFactory"; // 容器工厂
String exchange = "exchange-common"; // 交换机
String queue_like = "common-like"; // 队列
String rountingKey_like = "commonLike"; // 路由key
String delayexchange = "delayexchange-common"; // 延迟交换机
String delayqueue_like = "delay_common-demo"; // 队列
String delayrountingKey_like = "delay_commonLike"; // 路由key
}
公共对象
import lombok.Data;
@Data
public class MqTestRequest {
private String msg;
private Integer seconds;
}
生产者
import com.smz.framework.config.rabbitmq.RabbitMqSender;
import com.smz.service.mq.domain.MqTestRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* @Desc 消息发送
*/
@Component
@Slf4j
public class MqProducer {
@Autowired RabbitMqSender rabbitMqSender;
/** 正常消息 */
public void demo(MqTestRequest request) {
log.info("测试mq:req={}", request);
rabbitMqSender.sendMQ(MqConstants.exchange, MqConstants.rountingKey_like, request);
}
/** 延时消息 */
public void delayeddemo(MqTestRequest request) {
log.info("测试mq:req={}", request);
rabbitMqSender.sendDelayMessage(
MqConstants.delayexchange,
MqConstants.delayrountingKey_like,
request,
request.getSeconds());
}
}
消费者
import com.fasterxml.jackson.databind.ObjectMapper;
import com.smz.service.mq.domain.MqTestRequest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
/**
* @Desc 点mq监听消费者
*/
@Service
@Slf4j
public class MqConsumer {
@Autowired private ObjectMapper objectMapper;
@RabbitListener(
containerFactory = MqConstants.containerFactory,
bindings =
@QueueBinding(
value = @Queue(value = MqConstants.queue_like, durable = "true"),
exchange = @Exchange(value = MqConstants.exchange, type = ExchangeTypes.TOPIC),
key = MqConstants.rountingKey_like))
public void demo(Message message) throws IOException {
MqTestRequest request = objectMapper.readValue(message.getBody(), MqTestRequest.class);
System.out.println("-------普通消息->>>" + request.getMsg());
}
@RabbitListener(
containerFactory = MqConstants.containerFactory,
bindings =
@QueueBinding(
value = @Queue(value = MqConstants.delayqueue_like, durable = "true"),
exchange =
@Exchange(
value = MqConstants.delayexchange,
durable = "true",
type = ExchangeTypes.TOPIC,
delayed = "true"),
key = MqConstants.delayrountingKey_like))
public void delayeddemo(Message message) throws IOException {
MqTestRequest request = objectMapper.readValue(message.getBody(), MqTestRequest.class);
System.out.println("-------------------延时消息->>>" + request.getMsg());
}
}
主要包含发发送普通消息和延迟消息两种方式。