RabbitMQ

RabbitMQ各组件功能

・
・
Broker：标识消息队列服务器实体.

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

Exchange：交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。

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

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

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

Connection：网络连接，比如一个TCP连接。

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

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

Message：消息，消息是不具名的，它是由消息头和消息体组成。消息体是不透明的，而消息头则是由一系列的可选属性组成，这些属性包括routing-key(路由键)、priority(优先级)、delivery-mode(消息可能需要持久性存储[消息的路由模式])等。

・
・
・
・

RabbitMQ的多种Exchange类型

・

direct

・消息中的路由键(routing key)如果和Binding中的binding key一致，交换器就将消息发到对应的队列中。路由键与队列名完全匹配。
・

・

fanout

・每个发到fanout类型交换器的消息都会分到所有绑定的队列上去。fanout交换器不处理该路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。fanout类型转发消息是最快的。

・

・

topic

・topic交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键(routing-key)和绑定键(bingding-key)的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符："#“和”*"。#匹配0个或多个单词，匹配不多不少一个单词。

・

・

・

RabbitMQ与SpringBoot整合

・
・
1、导入依赖
・

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

・
2、修改配置信息
・

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/

3、修改主启动类
・

@EnableRabbit
@MapperScan("com.atguigu.gulimail.order.dao")
@SpringBootApplication
public class GulimailOrderApplication {

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

}

・

测试

・
1、创建一个交换机：
・

在这里插入代码片
    @Autowired
    AmqpAdmin amqpAdmin;
    @Test
    public void contextLoads() {

             //true处的参数代表是否持久化交换机，false处参数代表是否自动删除交换机
        DirectExchange directExchange = new  DirectExchange("hello.exchange",true,false);
        amqpAdmin.declareExchange(directExchange);
        System.out.println("Exchange创建成功，hello.exchange");

    }

・
2、创建一个队列
・

        //参数一：名字，参数二：是否持久化，参数三：排他（只能跟建立关系的一个连接），参数四：是否自动删除
        Queue queue = new Queue("hello-queue",true,false,false);
        amqpAdmin.declareQueue(queue);

・
3、队列跟交换机进行绑定
・

//String destination(目的地-队列的名字),
// Binding.DestinationType destinationType（目的地类型）,
// String exchange（交换机）,
// String routingKey（路由键）,
// Map<String, Object> arguments（自定义参数）
        Binding binding = new Binding("hello-java-queue",
                Binding.DestinationType.QUEUE,"hello-java-exchange",
                "hello.java",
                null);
        amqpAdmin.declareBinding(binding);

・
・
4、利用RabbitTemplate进行消息的发送
・
给hello-java-exchange交换机发送HELLO WORLD消息带上hello.java路由头
・

rabbitTemplate.convertAndSend("hello-java-exchange","hello.java","HELLO WORLD");

・
给hello-java-exchange交换机发送一个对象消息带上hello.java路由头，如果发送的消息是个对象，这个对象必须实现序列化

  OrderReturnReasonEntity entity = new OrderReturnReasonEntity();
        entity.setId(1L);
        entity.setName("哈哈哈");  
        rabbitTemplate.convertAndSend("hello-java-exchange","hello.java",entity);

・

RabbitMQ的序列化转Json的解决方式(插)

@Configuration
public class MyRabbitConfig {

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

}

・
・

监听队列消息

・
1、主启动类必须开启@EnableRabbit注解
・
・
2、（1）创建一个方法或者在一个类上加上 @RabbitListener 监听注解，@RabbitListener必须在容器中才能起作用，queues声明需要监听hello-java-queue队列,只有hello-java-queue队列中有消息它就能取到消息。（2）@RabbitHandler: 标在方法上
・

/**
     * @RabbitListener必须在容器中才能起作用，queues声明需要监听的队列
     */
    @RabbitListener(queues ={"hello-java-queue"} )
    public void recive(Object message){

        System.out.println("接收到的消息是"+message);

    }

・
・
3、被 @RabbitListener 监听的方法可以写多个参数：Messgae:原生消息详细信息，头+体。自定义参数类：OrderReturnReasonEntity content, 返回的数据用OrderReturnReasonEntity 封装。Channel：当前传输数据通道。
・
・

・
・
4、如果一个队列被多个客户端监听，同一个消息只能有一个客户收到。
・
・


・
・
5、当客户端接收到消息需要时间进行逻辑处理时，只有等一个消息完全处理完，方法运行结束，我们就可以接收到下一个消息。
・
・

・
・
6、@RabbitListener、@RabbitHandler 一起使用，@RabbitListener标在类上，@RabbitHandler标在方法上。 解决当一个消息队列中有两种类型的消息数据时一个接收数据
・
・

・

・

・
・

消息确认机制

・
・
・

・
・
・

发送端确认

・
・
服务收到消息就回调

1、修改配置文件

spring.rabbitmq.publisher-confirms=true

・
2、设置确认回调

@Configuration
public class MyRabbitConfig {
    
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Bean
    public Jackson2JsonMessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
    /**
     *
     * 定制RabbitTemplate
     */
    @PostConstruct//MyRabbitConfig对象创建完成以后，执行这个方法
    public void initRabbitTemplate(){
            //设置确认回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){
            /**
             *   1、只要消息抵达Broker就ack=true
             * @param correlationData 当前消息的唯一关联数据（这个是消息的唯一id）
             * @param b 消息是否成功
             * @param s 失败的原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
            }
        });

・
消息正确抵达队列进行回调
・
1、修改配置文件

#开启发送端消息正抵达队列的确认
spring.rabbitmq.publisher-returns=true

#如果消息抵达队列，以异步方式优先回调这个returnconfirms
spring.rabbitmq.template.mandatory=true

・
2、设置确认回调
・

  //设置消息抵达队列的确认回调
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {

            /**
             * 只要消息没有投递给指定的队列，就触发这个失败回调
             * @param message  投递失败的消息详细信息
             * @param i  回复的状态码
             * @param s  回复的文本内容
             * @param s1 当时这个消息发给那个交换机
             * @param s2 当时这个消息用那个路由键
             */
            @Override
            public void returnedMessage(Message message, int i, String s, String s1, String s2) {

            }
        });

・
・

消费端确认机制（保证每一个消息被正确确认，此时才可以borker删除这个消息）

・
1、默认是自动确认的，只要消息接收到，客户端就会自动确认，服务端就会移除这个消息。
但是这种自动确认消息会引发一些问题：
・我们收到很多消息，自动回复给服务器，但是当只要一个消息在客户端处理成功后，客户端就宕机了，就会发生消息的丢失。

・解决方法：
・手动确认，只要我们没有明确告诉MQ,消息被签收（没有被ACK），消息就一直是unacked状态。即使客户端宕机，队列的数据也不会丢失会重新变为Ready状态，下一次有新的客户端连接进来再发给新的客户端

 修改配置文件：

#设置消息抵达队列回复服务器确认消息的方式改为手动模式(手动ACK消息)

spring.rabbitmq.listener.simple.acknowledge-mode=manual

・
・ 如何手动签收（channel.basicAck()）
・

  @RabbitListener(queues ={"hello-java-queue"} )
    public void recive(Message message, OrderReturnApplyEntity orderReturnApplyEntity, Channel channel) throws IOException {

        System.out.println("接收到的消息是"+message);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        //签收消息，非批量模式
        channel.basicAck(deliveryTag,false);

      
    }

・
・
・如何手动拒绝签收( channel.basicNack(long var1, boolean var3, boolean var4))
・
(long var1, boolean var3, boolean var4)，拒绝签收的三个参数 var3是否批量拒绝，var4消息是否重新发回MQ队列
・

   //拒绝签收的三个参数 var3是否批量拒绝，var4消息是否重新发回MQ队列
        //(long var1, boolean var3, boolean var4)
        channel.basicNack(deliveryTag,false,true);

・
・