相关阅读

基础组件

Message

消息，消息时不具名的，由消息头和消息体组成；消息体是不透明的，消息头则是由一系列的可选属性组成，这些属性包括：routing-key（路由键）、priority（相对其它消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等；

Publisher

消息的生产者，也是一个向交换器发布消息的客户端应用程序；

Exchange

交换器，用来接收生产者发送的消息，并将这些消息路由给服务器中的队列；
Exchange分发消息时根据类型的不同，分发策略有区别，目前支持四种类型：direct、fanout、topic、headers；

direct

完全匹配，单播模式；
消息中的路由键routing-key如果和Binding中的binding-key一致，交换器就将消息发到对应的队列中；路由键与队列名完全匹配，如果一个队列绑定到交换机时路由键为demo，那么只会转发routing-key为demo的消息，不会转发demo.xxx的消息；

fanout

广播模式；
每个发到fanout交换器的消息都会分到所有绑定的队列上，它不处理路由键，只是简单地将队列绑定到交换器上，将每个到达的消息转发到绑定的所有队列上；

topic

模式匹配，支持通配符匹配；
队列绑定到一个模式上，根据消息的路由键将消息转发到匹配的模式所绑定的队列中；
通配符支持：#匹配0个或多个单词，*匹配一个单词；

headers

headers匹配AMQP消息的header，而不是路由键；
headers交换器和direct交换器完全一致，但性能差很多；

Queue

消息队列，用来保存消息直到发送给消费者；它是消息的容器，也是消息的终点；一个消息可投入一个或多个消息队列；消息一直在d消息队列中，等待消费者连接到这个消息队列将其取走；

Binding

绑定，用于消息队列和交换器之间的关联；一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表；Exchange和Binding是多对多的关系；

Connection

网络连接，比如一个TCP连接；

Channel

信道，多路复用连接中的一条独立的双向数据流通道；信道是建立在真实的TCP连接内的虚拟连接，AMQP命令都是通过信道发出去的，不管是发布消息、订阅队列，还是接收消息，都是通过信道完成；因为对于操作系统来说，建立和销毁TCP都是非常昂贵的开销，所以引入信道的概念，以复用一条TCP连接；

Consumer

消息的消费者，表示一个从消息队列中取得消息的客户端应用程序；

Virtual Host

虚拟主机，表示一批交换器、消息队列、相关对象；虚拟主机是共享相同的身份认证和加密环境的独立服务器域，每个vhost本质上就是一个mini版的RabbitMQ服务器，拥有自己的队列、交换器、绑定、权限机制；vhost是AMQP概念的基础，必须在连接时指定，RabbitMQ默认的vhost是/；

Broker

表示消息队列服务器实体；

可靠消息

消息丢失

场景一

消息方法出去，但由于网络问题没有抵达服务器；

解决方法

1. 做好容错（try-catch），发送消息可能会网络失败，失败后要有重试机制；可记录数据库，采用定期扫描重发的方式；
2. 做好日志记录，每个消息状态是否都被服务器收到都应该记录；
   做好定期重发，如果消息没有发送成功，定期去数据库扫描未成功的消息进行重发；

场景二

消息抵达broker，broker要将消息写入磁盘（持久化）才算成功；此时，broker尚未持久化完成，宕机；

解决方法

1. publisher必须加入确认回调机制，确认成功的消息，修改数据库消息状态；

场景三

自动ACK的状态下，消费者收到消息，还未来得及处理消息，宕机；

解决方法

1. 开启手动ACK，消费成功才移除，失败或者没有来得及处理就noACK，并重新入队；

消息重复

场景

1. 消息消费成功，事务已经提交，ack时，机器宕机，导致ack失败，broker将消息状态由unack变为ready，并发送给其它消费者；
2. 消息消费失败，由于重试机制，自动又将消息发送出去；

解决方法

1. 消费者的业务消费接口应该设计为幂等性的；
2. 使用防重表，发送消息每个都有一个业务的唯一标识，处理过就不用处理；
3. rabbitMQ的每一个消息都有redelivered字段，可以判断是否是被重新投递过来的；

消息积压

场景

1. 消费者宕机积压；
2. 消费者消费能力不足积压；
3. 发送者发送流量太大；

解决方法

1. 上线更多的消费者，进行正常消费；
2. 上线专门的队列消费服务，将消息先批量取出来，记录数据库，离线慢慢处理；

可靠抵达

1. 保证消息不丢失，可靠抵达，可以使用事务消息，性能下降250倍，为此引入确认机制；
2. publisher confirmCallback确认模式
3. publisher returnCallback未投递到queue退回模式
4. consumer ack机制

confirmCallback确认模式

配置项spring.rabbitmq.publisher-confirms=true开启确认模式；
在创建connectionFactory时设置publisherConfirms(true)，开启confirmCallback；
CorrelationData用于表示当前消息唯一性；
消息只要被broker接收到就会执行confirmCallback，如果是cluster模式，需要所有broker接收到才会调用confirmCallback；
被broker接收到只能表示消息到达服务器，并不能保证消息一定会被投递到目标queue里；

returnCallback

配置项spring.rabbitmq.publisher-returns=true、spring.rabbitmq.template.mandatory=true；
如果消息未能投递到目标queue将调用returnCallback，可以记录下详细投递数据，以便后续定期的巡检或自动纠错；

Demo

依赖

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

配置

配置RabbitMQ相关信息，如下：

spring:
  main:
    # 支持循环依赖
    allow-circular-references: true
  rabbitmq:
    host: 0.0.0.0
    port: 5672
    virtualHost: /
    username: admin
    password: admin
    # 开启生产者确认
    publisher-confirm-type: correlated
    # 开启生产者返回
    publisher-returns: true
    template:
      # 开启强制信息
      mandatory: true
    listener:
      simple:
        # 开启消费者手动ACK
        acknowledge-mode: manual

通过@EnableRabbit注解开启RabbitMQ功能，代码如下：

@Configuration
@EnableRabbit
@Slf4j
public class RabbitmqConfig {

    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    @Autowired
    public void setRabbitTemplate(RabbitTemplate rabbitTemplate) {
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) ->
            log.info("{} {} {}", correlationData, ack, cause));
        rabbitTemplate.setReturnsCallback(returned ->
            log.info("{} {} {} {} {}", returned.getExchange(), returned.getRoutingKey(),
                returned.getMessage(), returned.getReplyText(), returned.getReplyCode()));
    }
}

消息

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DemoMessage implements Serializable {

    private static final long serialVersionUID = 1L;

    private String id;
    private String message;
}

生产者

public class DemoProducer {

    private final RabbitTemplate rabbitTemplate;


    public DemoProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void produce() {
        produce("demo", "rabbitmq.demo");
    }

    public void produce(String exchange, String routingKey) {
        DemoMessage message = DemoMessage.builder()
            .id(UUID.randomUUID().toString())
            .message("This is a test message")
            .build();
        this.rabbitTemplate.convertAndSend(
            exchange, routingKey, message, new CorrelationData(message.getId()));
    }
}

消费者

@Component
@RabbitListener(queues = {"rabbitmq.demo"})
@Slf4j
public class DemoConsumer {

    @RabbitHandler
    public void handleMessage(@Payload DemoMessage demo, Message message, Channel channel) {
        log.info("{}", demo);

        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), true);
        } catch (IOException e) {
            log.error(e.getMessage(), e);
            // TODO retry
        }
    }
}

测试

测试Exchange、Queue、Binding创建；

@SpringBootTest
class AqmpTest {

    @Autowired
    private AmqpAdmin aqmpAdmin;


    @Test
    void testExchange() {
        this.aqmpAdmin.declareExchange(new DirectExchange("demo", true, false));
    }

    @Test
    void testQueue() {
        this.aqmpAdmin.declareQueue(new Queue("rabbitmq.demo", true, false, false));
    }

    @Test
    void testBinding() {
        this.aqmpAdmin.declareBinding(new Binding(
            "rabbitmq.demo", DestinationType.QUEUE, "demo", "rabbitmq.demo", null));
    }
}

测试生产着；

@SpringBootTest
class ProducerTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;


    @Test
    void testSendMessage() {
        DemoProducer producer = new DemoProducer(this.rabbitTemplate);
        producer.produce();
    }

    @Test
    void testSendError() {
        DemoProducer producer = new DemoProducer(this.rabbitTemplate);
        producer.produce("demo", "error");
    }
}