RabbitMQ系列（二）入门实例+高级应用

这里使用springboot集成rabbitmq

一、入门使用

            

这里会创建两个服务：消息提供者和消息消费者

1、创建消息提供者模块

pom文件：

        org.springframework.boot
        spring-boot-starter-parent
        2.3.0.RELEASE
    

    
        UTF-8
        UTF-8
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-amqp
        
    

yml：

server:
  port: 10086

spring:
  rabbitmq:
    host: 192.168.211.20
    port: 5672
    password: admin
    username: admin
    virtual-host: / #虚拟机名称,不配置则使用默认的
  application:
    name: producer

 

 

rabbitMQ各个组件的配置类（注意这里配置信息也可以使用RabbitAdmin进行创建）

/**
 * 类功能描述：

 * Broker:它提供一种传输服务,它的角色就是维护一条从生产者到消费者的路线，保证数据能按照指定的方式进行传输,
 * Exchange：消息交换机,它指定消息按什么规则,路由到哪个队列。
 * Queue:消息的载体,每个消息都会被投到一个或多个队列。
 * Binding:绑定，它的作用就是把exchange和queue按照路由规则绑定起来.
 * Routing Key:路由关键字,exchange根据这个关键字进行消息投递。
 * vhost:虚拟主机,一个broker里可以有多个vhost，用作不同用户的权限分离。
 * Producer:消息生产者,就是投递消息的程序.
 * Consumer:消息消费者,就是接受消息的程序.
 * Channel:消息通道,在客户端的每个连接里,可建立多个channel.
 * 

 * 
类功能描述1

 * 
类功能描述2

 * 
类功能描述3

 * 
 * 修改记录：

 * 

 * 
修改记录描述1

 * 
修改记录描述2

 * 
修改记录描述3

 * 
 *
 * @author xuefl
 * @version 5.0 since 2020-01-02
 */
@Configuration
public class RabbitConfig {
    //这里分别创建fanout、Direct、Topic三种交换机，及其相应的队列、路由键

    public static final String FANOUT_QUEUE_NAME = "test_fanout_queue";
    public static final String FANOUT_QUEUE_NAME1 = "test_fanout_queue1";
    public static final String TEST_FANOUT_EXCHANGE = "testFanoutExchange";

    public static final String DIRECT_QUEUE_NAME = "test_direct_queue";
    public static final String TEST_DIRECT_EXCHANGE = "testDirectExchange";
    public static final String DIRECT_ROUTINGKEY = "test";


    public static final String TOPIC_QUEUE_NAME = "test_topic_queue";
    public static final String TEST_TOPIC_EXCHANGE = "testTopicExchange";
    public static final String TOPIC_ROUTINGKEY = "test.*";



    //创建一个队列
    @Bean
    public Queue directQueue(){

        return new Queue(DIRECT_QUEUE_NAME,true); //队列名字，是否持久化
    }

    //创建一个交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(TEST_DIRECT_EXCHANGE,true,false);//交换器名称、持久化、不自动删除
    }

    //创建交换机和队列的binding
    //将队列、交换机、路由key（该路由key会根据相应的规则和发送消息端的路由可以进行比较，
    // 成立了则将消息发送到banding的队列）
    @Bean
    Binding binding(Queue queue, DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DIRECT_ROUTINGKEY);
    }
}

控制层：

@RestController
public class SendController {

    @Autowired
    SendService sendService;

    @GetMapping("Send")
    public void SendMes(){
        sendService.send("123456");
    }
}

service层：

@Service
public class SendService {

    @Autowired
    RabbitTemplate rabbitTemplate;

    public void send(String message){
        System.out.println("发送消息："+message);


        //如果在参数列表中省略 Exchange 名称，或者同时省略 Exchange 名称和 routing key 的话，
        // RabbitTemplate 将会使用默认的 Exchange 名称和 routing key。
        //这里它传入了三个参数：Exchange 的名称、routing key 以及要发送的消息
        rabbitTemplate.convertAndSend("testDirectExchange","test",message);
    }
}

启动类：

@SpringBootApplication
public class ProducerApp {

    public static void main(String[] args) {

        SpringApplication.run(ProducerApp.class,args);
    }
}

2、创建消息消费者模块

pom同上

yml：

server:
  port: 10087

spring:
  rabbitmq:
    host: 192.168.211.20
    password: admin
    username: admin
    port: 5672
    virtual-host: /  #虚拟机名称
  application:
    name: consumer

监听类（接收消息）注意：这里的监听是使用了@RabbitListener+@RabbitHandler两个注解实现的，可以是直接监听某个队列，或者你详细的指定队列+交换机等信息。

@Component
@RabbitListener(queues = "test_direct_queue") //监听哪个队列
public class ReceiverService {

    //该消费者监听banding是：队列为FANOUT_QUEUE_NAME（持久化），fanout类型的交换机名称是TEST_FANOUT_EXCHANGE
  /*  @RabbitListener(bindings =
            {@QueueBinding(value = @Queue(value = "队列名称", durable = "true"),
                    exchange = @Exchange(value = "交换机名称", type = "fanout"))
            })
    @RabbitHandler
    public void abc(Message message){//Message类型即java对象序列化来的
        System.out.println("接收消息："+message);
    }*/

    //获取到消息要执行的方法
    @RabbitHandler
    public void handler(String message){

        System.out.println("接收消息："+message);
    }


}

启动类：

@SpringBootApplication
public class ConsumerApp {


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

此时启动两个服务，访问消息提供者的接口：http://localhost:10086/Send。查看提供者控制台：

再查看消费者是否消费了：

我们打开rabbitmq的客户端也可以看到创建的队列交换机等：

       

这样rabbitmq的简单入门就到这里的。

二、高级应用

1、利用确认机制+持久化保证消息不丢失

这里会将mq的确认机制、消息返回机制、重试机制、设置过时队列/消息、死信队列、消息的幂等性。

还有这里也会说明利用上面的特性实现分布式事务，rabbitmq的其他方法+消息的类型及序列化问题。

1、rbmq的确认机制分为发送端的消息确认、消费端的消息确认。（期间会进行队列、交换机、消息的持久化）

1.1、发送端的消息确认：使用confirm模式。+消息返回机制

发送端的消息确认机制保证了发送端到mq过程中的消息丢失问题

（1）yml文件：其中新版本的rbmq的配置换成了 publisher-confirm-type。至于mandatory、publisher-confirms（新版用publisher-confirm-type）、publisher-return的说明看：https://blog.csdn.net/yaomingyang/article/details/106857104

对于老版的publisher-confirms和新版的publisher-confirm-type使用说明看：https://blog.csdn.net/z69183787/article/details/109371628

server:
  port: 10086

spring:
  rabbitmq:
    host: 192.168.211.20
    port: 5672
    password: admin
    username: admin
    virtual-host: / #虚拟机名称,不配置则使用默认的
    publisher-confirm-type: correlated   #新版对的确认机制（找到交换机机制）
    publisher-returns: true    #设置return为true（找不到匹配的队列返回）
    template:
      mandatory: true     #搭配上面两个一起使用
  application:
    name: producer

（2）将发送消息的方法进行改造，如下面代码所见，进行确认机制+消息返回处理即实现ConfirmCallback的confirm方法+ReturnCallback+ReturnCallback类的returnedMessage方法。

@Slf4j
@Component
public class ConfirmService implements RabbitTemplate.ConfirmCallback{



    //确认后的回调方法，可以在这里处理是否确认到交换机的处理逻辑
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {

        if (!ack) {  //返回false证明没到交换机
            System.out.println("消息发送异常!");
        } else {    //发送正常到达交换机
            System.out.println("发送者已经收到确认");
        }

    }


  

}
---------------------------------------------

@Slf4j
@Component
public class returneService RabbitTemplate.ReturnCallback{

  //return回调方法，对消息是否达到队列进行逻辑处理
  // 消息如果无法在队列中持久化就会被删除，为了避免被删除此时进行逻辑处理
  //如果消息未能投递到目标 queue 里将触发回调 returnCallback ，
  // 一旦向 queue 投递消息未成功，这里一般会记录下当前消息的详细投递数据，
  // 方便后续做重发或者补偿等操作。
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("returnedMessage ===> replyCode={} ,replyText={} ,exchange={} ,routingKey={}", replyCode, replyText, exchange, routingKey);
    }

}



--------------------------------
改造发送方法

@Slf4j
@Service
public class SendService {

    @Autowired
    RabbitTemplate rabbitTemplate;



    public void send(String message){
//将那两个类传进来即可

        rabbitTemplate.setReturnCallback(returneService);
        rabbitTemplate.setConfirmCallback(ConfirmService);

        System.out.println("发送消息："+message);


        //如果在参数列表中省略 Exchange 名称，或者同时省略 Exchange 名称和 routing key 的话，
        // RabbitTemplate 将会使用默认的 Exchange 名称和 routing key。
        //这里它传入了三个参数：Exchange 的名称、routing key 以及要发送的消息
        rabbitTemplate.convertAndSend("testDirectExchange","test",message);
    }



}

当时这样貌似有点麻烦，我这里换了一种做法，即在rabbitmq配置类中设置，两种都可以不用纠结

@Slf4j
@Configuration

public class RabbitConfig {
    //这里分别创建fanout、Direct、Topic三种交换机，及其相应的队列、路由键

    public static final String FANOUT_QUEUE_NAME = "test_fanout_queue";
    public static final String FANOUT_QUEUE_NAME1 = "test_fanout_queue1";
    public static final String TEST_FANOUT_EXCHANGE = "testFanoutExchange";

    public static final String DIRECT_QUEUE_NAME = "test_direct_queue";
    public static final String TEST_DIRECT_EXCHANGE = "testDirectExchange";
    public static final String DIRECT_ROUTINGKEY = "test";


    public static final String TOPIC_QUEUE_NAME = "test_topic_queue";
    public static final String TEST_TOPIC_EXCHANGE = "testTopicExchange";
    public static final String TOPIC_ROUTINGKEY = "test.*";



    //创建一个队列
    @Bean
    public Queue directQueue(){

        return new Queue(DIRECT_QUEUE_NAME,true); //队列名字，是否持久化
    }

    //创建一个交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(TEST_DIRECT_EXCHANGE,true,false);//交换器名称、持久化、不自动删除
    }

    //创建交换机和队列的binding
    //将队列、交换机、路由key（该路由key会根据相应的规则和发送消息端的路由可以进行比较，
    // 成立了则将消息发送到banding的队列）
    @Bean
    Binding binding(Queue queue, DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with(DIRECT_ROUTINGKEY);
    }


    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setConfirmCallback((CorrelationData correlationData, boolean ack, String cause)->{
            if (!ack) {  //返回false证明没到交换机
                System.out.println("消息发送异常!");
            } else {    //发送正常到达交换机
                System.out.println("发送者已经收到确认");
            }
        });

        rabbitTemplate.setReturnCallback((Message message, int replyCode, String replyText, String exchange, String routingKey)->{
            log.info("returnedMessage ===> replyCode={} ,replyText={} ,exchange={} ,routingKey={}", replyCode, replyText, exchange, routingKey);

        });

        return rabbitTemplate;
    }
}

此时重新启动该服务，访问发送信息端口：http://localhost:10086/Send  查看控制台

此时则成功了，return回调方法是要在消息无法找到对应队列时才会调用的方法，所以这里不会被调用。

此时虽然成功了，但是为了保证我们的到的那个消息是我们发的，此时可以在发送消息的时候再给消息一个id，并且对消息做持久化操作。

将原先的发送消息代码改为

/**
         * 发送消息
         */
        rabbitTemplate.convertAndSend(exchange, routingKey, msg,
                message -> {  //消息的持久化处理                    message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                    return message;
                },   //为消息设置唯一id，这样可以保证消息的唯一性
                new CorrelationData(UUID.randomUUID().toString()));

为了测试我们在回调方法中打印下消息的id

此时我们收到了这个id的消息发送成功，就可以根据发送的所有消息知道那条消息没有发送出去，从而进行重发的逻辑。

1.2、消费端的消息确认：使用手动ACK。

发送端的消息确认机制保证了mq消费者过程中的消息丢失问题

看完消费者+发送者的消息确认机制，其实两者就是为了保证消息的丢失，这也是MQ要实现的基本要求

手动ACK比较简单。使用@RabbitHandler注解标注的方法要增加 channel(信道)、message 两个参数。然后执行channel的相应手动ACK方法即可

（1）、yml文件

• ACK 机制还可以起到限流作用，比如在接收到某条消息时休眠几秒钟
• 消息确认模式有：
  • AcknowledgeMode.NONE：自动确认
  • AcknowledgeMode.AUTO：根据情况确认
  • AcknowledgeMode.MANUAL：手动确认

    server:
      port: 10087
    
    spring:
      rabbitmq:
        host: 192.168.211.20
        password: admin
        username: admin
        port: 5672
        virtual-host: /  #虚拟机名称
        listener:
          simple:
            acknowledge-mode: manual
      application:
        name: consumer

     

（2）将接收消息类改为

@Slf4j
@Component
@RabbitListener(queues = "test_direct_queue") //监听哪个队列
public class ReceiverService {

    //该消费者监听banding是：队列为FANOUT_QUEUE_NAME（持久化），fanout类型的交换机名称是TEST_FANOUT_EXCHANGE
  /*  @RabbitListener(bindings =
            {@QueueBinding(value = @Queue(value = "队列名称", durable = "true"),
                    exchange = @Exchange(value = "交换机名称", type = "fanout"))
            })
    @RabbitHandler
    public void abc(Message message){//Message类型即java对象序列化来的
        System.out.println("接收消息："+message);
    }*/

    //获取到消息要执行的方法
    @RabbitHandler
    public void handler(String msg ,Channel channel, Message message) throws IOException {
        System.out.println(message.getMessageProperties().getDeliveryTag());

        try {
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {

            if (message.getMessageProperties().getRedelivered()) {

                log.error("消息已重复处理失败,拒绝再次接收...");

                channel.basicReject(message.getMessageProperties().getDeliveryTag(), false); // 拒绝消息
            } else {

                log.error("消息即将再次返回队列处理...");

                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
            }


            System.out.println("接收消息：" + msg);
        }
    }

}

此时查看控制台

这里为什么会出现消费三个消息，三个的message.getMessageProperties().getDeliveryTag()分别是1、2、3。这个代表手动ack下消息投递的序号。

对于一些概念讲解

其中手动ack有三种方法

消费消息有三种回执方法，我们来分析一下每种方法的含义。

1、basicAck

basicAck：表示成功确认，使用此回执方法后，消息会被rabbitmq broker 删除。

void basicAck(long deliveryTag, boolean multiple) 

deliveryTag：表示消息投递序号，每次消费消息或者消息重新投递后，deliveryTag都会增加。手动消息确认模式下，我们可以对指定deliveryTag的消息进行ack、nack、reject等操作。

multiple：是否批量确认，值为 true 则会一次性 ack所有小于当前消息 deliveryTag 的消息。

举个栗子： 假设我先发送三条消息deliveryTag分别是5、6、7，可它们都没有被确认，当我发第四条消息此时deliveryTag为8，multiple设置为 true，会将5、6、7、8的消息全部进行确认。

2、basicNack

basicNack ：表示失败确认，一般在消费消息业务异常时用到此方法，可以将消息重新投递入队列。

void basicNack(long deliveryTag, boolean multiple, boolean requeue)

deliveryTag：表示消息投递序号。

multiple：是否批量确认。

requeue：值为 true 消息将重新入队列。

3、basicReject

basicReject：拒绝消息，与basicNack区别在于不能进行批量操作，其他用法很相似。

void basicReject(long deliveryTag, boolean requeue)

deliveryTag：表示消息投递序号。

requeue：值为 true 消息将重新入队列。

 

1.3、MQ持久化（队列+交换机+message，三者进行持久化设置）

那么从发送端到消费端的消息丢失问题就只剩下在MQ里面了，而为了保证MQ中的消息不会丢失，则需要将队列+交换机+message（消息）进行持久化（前面创建的时候已经将队列、交换机、message进行设置为持久化了）。必要是对MQ进行集群保证其可用性。

进一步讨论

1.将queue，exchange, message等都设置了持久化之后就能保证100%保证数据不丢失了嚒？
答案是否定的。
首先，从consumer端来说，如果这时autoAck=true，那么当consumer接收到相关消息之后，还没来得及处理就crash掉了，那么这样也算数据丢失，这种情况也好处理，只需将autoAck设置为false(方法定义如下)，然后在正确处理完消息之后进行手动ack（channel.basicAck）.

String basicConsume(String queue, boolean autoAck, Consumer callback) throws IOException;

其次，关键的问题是消息在正确存入RabbitMQ之后，还需要有一段时间（这个时间很短，但不可忽视）才能存入磁盘之中，RabbitMQ并不是为每条消息都做fsync的处理，可能仅仅保存到cache中而不是物理磁盘上，在这段时间内RabbitMQ broker发生crash, 消息保存到cache但是还没来得及落盘，那么这些消息将会丢失。那么这个怎么解决呢？首先可以引入RabbitMQ的mirrored-queue即镜像队列，这个相当于配置了副本，当master在此特殊时间内crash掉，可以自动切换到slave，这样有效的保障了HA, 除非整个集群都挂掉，这样也不能完全的100%保障RabbitMQ不丢消息，但比没有mirrored-queue的要好很多，很多现实生产环境下都是配置了mirrored-queue的。还有要在producer引入事务机制或者Confirm机制来确保消息已经正确的发送至broker端，有关RabbitMQ的事务机制或者Confirm机制可以参考：RabbitMQ之消息确认机制（事务+Confirm）. 幸亏本文的主题是讨论RabbitMQ的持久化而不是可靠性，不然就一发不可收拾了。RabbitMQ的可靠性涉及producer端的确认机制、broker端的镜像队列的配置以及consumer端的确认机制，要想确保消息的可靠性越高，那么性能也会随之而降，鱼和熊掌不可兼得，关键在于选择和取舍。

2.消息什么时候刷到磁盘？
写入文件前会有一个Buffer,大小为1M,数据在写入文件时，首先会写入到这个Buffer，如果Buffer已满，则会将Buffer写入到文件（未必刷到磁盘）。
有个固定的刷盘时间：25ms,也就是不管Buffer满不满，每个25ms，Buffer里的数据及未刷新到磁盘的文件内容必定会刷到磁盘。
每次消息写入后，如果没有后续写入请求，则会直接将已写入的消息刷到磁盘：使用Erlang的receive x after 0实现，只要进程的信箱里没有消息，则产生一个timeout消息，而timeout会触发刷盘操作。

2、利用重发机制保证消息发送失败进行再次发送

1、消息放回机制、失败重发机制

放回可以根据前面的确认机制，发送者的return回调，消费者的手动ack模式。

2、重试机制

发送端重发、消费端消费失败重发。

 

 

3、设置过时消息、过时队列

设置队列的过期时间，则消息到过期时间后会从队列删除

设置消息的过期时间，会在消息投递给消费者的时候判断，是否过期，过期则删除

设置过时消息：

 /**
         * 发送消息
         */
        rabbitTemplate.convertAndSend("testDirectExchange","test",msg,
                message -> {
                    message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
         //设置消息的过期时间为60s
                    message.getMessageProperties().setExpiration("60*1000");
                    return message;
                },
                new CorrelationData(UUID.randomUUID().toString()));

    }

那如果此时消息过期了怎么办？被丢弃？

设置过时队列

//创建一个队列
    @Bean
    public Queue directQueue(){
        HashMap map = new HashMap();
        map.put("x-expires",1000);

        return new Queue(DIRECT_QUEUE_NAME,true,false,false,map); //队列名字，是否持久化
    }

这样就设置好了单个消息、整个队列的TTL过期时间。

关于TTL的设置具体可以参考：https://blog.csdn.net/mytt_10566/article/details/90814609

TTL设置一般是结合死信队列实现延时队列的功能。（而实现延时队列不仅可以用TTL，也可以用脚本实现，至于怎么实现延时队列在讲完死信队列的时候再讲）

 

4、死信队列（并结合死信队列+TTL/脚本 实现延时队列的功能）

可以先参考：https://blog.csdn.net/eumenides_/article/details/86025773?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param

https://blog.csdn.net/eumenides_/article/details/86027185

https://blog.csdn.net/qq_29914837/article/details/94070677

 

5、MQ中怎么保证消息的幂等性？

https://blog.csdn.net/m0_37968982/article/details/107831150

 

6、MQ怎么实现消息的有序性？