记录一次RabbitMq入门学习以及消息分发机制

初学RabbitMq

MQ的概念

• MQ:全称Message Queue 消息队列（又叫消息中间件）

是指用高效可靠的消息传递机制进行与平台无关的数据交流，通过提供消息传递和消息队列模型，可以在分布式环境下扩展进程的通信

• MQ的特点

1.是一个独立运行的服务；生产者，消费者都需要跟服务器建立连接
2.采用队列作为数据结构，有先进先出的特点
3.具有发布订阅模型,生产者发送消息，消费者接受消息

为什么要使用MQ

(不做详细阐述)
1.实现了异步通信
2.实现系统解耦
3.实现流量削峰(利用队列的特性）
4.实现了广播通信(可以达到一对多通信)

RabbitMQ 是什么

RabbitMQ 是一个开源的**AMQP(后面单独解释)**实现，服务器端用Erlang语言编写，支持多种客户端。用于在分布式系统中存储转发消息

RabbitMQ 特点

可靠性 高可用 多语言客户端 灵活的路由 插件机制 管理界面 消息集群 多种协议 跟踪机制

RabbitMQ工作模型

简述RabbitMQ的运转流程

生产者发送流程

1.生产者连接到rabbitMQ Broker,并建立一个connection,开启一个channel
2.生产者声明一个交换机，并设置其属性,比如:交换机类型,是否持久化等
3.生产者声明一个队列并设置相关属性,比如:是否排他，是否持久化，自动删除等
4.生产者通过路由键将交换器与队列绑定起来
5.生产者发送消息至rabbitMQ,消息包含两部分，消息体，附件信息(包括路由键，交换机等信息)
6.消息发送到交换机，按照交换机的类型根据路由键匹配目标队列 (不同交换机匹配规则不同)
7.如果信息匹配成功,消息顺利发送到目标队列，如果失败，则根据生产者设置的属性决定是丢弃还是回退
8.关闭信道，关闭连接

消费者接收流程

1.消费者连接到rabbitMQ Broker,并建立一个connection,开启一个channel
2.消费者向rabbitMQ Broker 请求消费目标队列中的信息，可能会设置相应的回调函数,以及做一些准备工作
3.等待rabbitMQ Broker 回应并投递队列中的信息，消费者接收信息
4.消费者确认(ack)接收到的消息
5.RabbitMQ 从队列中删除相应已经被确认的消息
6.关闭信道，关闭连接

RabbitMQ 核心概念

1.Producer

生产者，发送消息的一方
消息一般可以分为两个部门:
<1> 消息体:带有业务逻辑的数据结构，比如一个Json字符串，也可进一步对消息体做序列化操作
<2> 附加消息:用来表述这条消息,比如目标交换机的名称,路由键和一些自定义的属性等

2.Broker

消息中间件的服务节点，就是一台rabbitMQ服务器，可以部署多台集群模式

3.Virtual Host

虚拟主机,表示一批交换机,消息队列和相关对象
一个Broker可以有多个vhost,每个vhost本质上可以说是一个mini版的RabbitMQ服务器，拥有自己的队列，交换机,绑定和权限机制，因此在连接rabbitMQ时必须指定vhost

4.Channel

channel:信道，是建立在Connection连接上的一种轻量级的连接,生产者x,消费者与rabbitMQ的交互基本都是在Channel这个接口中完成的，比如:队列的声明,交换机的声明,队列的绑定，消息的发布，消费等

5.RoutingKey

路由键:生产者将消息发送给交换机的时候，一般会指定一个RoutingKey,用来指定这个消息的路由规则 （需要与exchange,bindingKey绑定使用）
在交换机类型和绑定键固定的情况下,生产者将消息发送给交换机，通过routingKey来决定消息的流向
(不同的交换机路由的匹配规则不同,当使用默认的交换机时，也可无需指定，默认交换机会有一条默认的路由,可仅指定queue也可发送)

6.Exchange

交换机:生产者将消息发送到交换机,由交换机将消息路由到一个或者多个队列中，如果路由不到，或返回生产者,或直接丢弃
类型:
1>.fanout:扇形交换机 可将消息广播到所有与当前交换机绑定的Queue
2>.direct：直连交换机 可把消息路由到那些RoutingKey绑定的bindingKey完全匹配的Queue中
3>.topic: 主题交换机 与direct类似，差距在于匹配RoutingKey绑定的bindingKey是模糊匹配，灵活性更强
4>.headers: 头交换机 不依赖路由键的匹配规则来路由消息，而是通过消息内容中的headers属性进行匹配
（headers 类型性能很差，而且不太实用）

7.Queue

队列:是RabbitMQ存储消息的对象

8.Binding

绑定:介于交换机与与队列之间的绑定，一个交换机可以对应一个或者多个queue，连接两者的媒介称为bindingKey

9.Consumer

消费者:接受消息的一方，消费者连接到RabbitMQ服务器，并订阅到队列上

SpringBoot 集成 rabbitMQ 以及简单使用

引入依赖

<!--rabbitmq依赖 -->
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.0.6.RELEASE</version>
        </dependency>      
        <!--测试依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

配置信息

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.listener.direct.retry.enabled=true
spring.rabbitmq.listener.direct.acknowledge-mode=
spring.rabbitmq.listener.type=simple
spring.rabbitmq.template.retry.enabled=true
spring.rabbitmq.listener.simple.acknowledge-mode=auto
spring.rabbitmq.listener.simple.prefetch=1

创建配置类

@Configuration
public class RabbitConfig {

    @Bean
    public RabbitTemplate rabbitTemplate(final ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        //解决: Caused by: org.springframework.amqp.AmqpException: No method found for class [B 异常
        //消息转换器,消息转化为json, setMessageConverter(MessageConverter ),这个方法就是这次异常的解决方案,创建一个Jackson2JsonMessageConverter对象放进去
        rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
        return rabbitTemplate;
    }

    // 三个交换机

    @Bean("directExchange")
    public DirectExchange getDirectExchange(){
        return  new DirectExchange("DIRECT_EXCHANGE");
    }

    @Bean("topicExchange")
    public TopicExchange getTopicExchange(){
        return new TopicExchange("TOPIC_EXCHANGE");
    }

    @Bean("fanoutExchange")
    public FanoutExchange getFanoutExchange(){
        return  new FanoutExchange("FANOUT_EXCHANGE");
    }

    // 三个队列
    @Bean("firstQueue")
    public Queue getFirstQueue(){
        Queue queue = new Queue("FIRST_QUEUE");
        return queue;
    }

    @Bean("secondQueue")
    public Queue getSecondQueue(){
        return new Queue("SECOND_QUEUE");
    }

    @Bean("thirdQueue")
    public Queue getThirdQueue(){
        return new Queue("THIRD_QUEUE");
    }

    // 三个绑定
    @Bean
    public Binding firstSecond(@Qualifier("firstQueue") Queue queue, @Qualifier("directExchange") DirectExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("zhangmr");
    }

    @Bean
    public Binding bindSecond(@Qualifier("secondQueue") Queue queue, @Qualifier("topicExchange") TopicExchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("#.zhangmr.#");
    }

    @Bean
    public Binding bindThird(@Qualifier("thirdQueue") Queue queue,@Qualifier("fanoutExchange") FanoutExchange exchange){
        return BindingBuilder.bind(queue).to(exchange);
    }
}

创建生产者

@Component
public class MyProvider {

    @Autowired
    AmqpTemplate amqpTemplate;

    public void send(){
        // 发送4条消息

        amqpTemplate.convertAndSend("DIRECT_EXCHANGE","zhangmr","-------- a direct msg");

        amqpTemplate.convertAndSend("TOPIC_EXCHANGE","test1.zhangmr.test1","-------- a topic msg : test1.zhangmr.test1");
        amqpTemplate.convertAndSend("TOPIC_EXCHANGE","test2.zhangmr.test2","-------- a topic msg : test2.zhangmr.test2");

        amqpTemplate.convertAndSend("FANOUT_EXCHANGE","","-------- a fanout msg");

    }
}

创建消费者

@Component
public class Consumer {
    
    @RabbitListener(queues = "FIRST_QUEUE")
    public void process(String msg){
        System.out.println(" first queue received msg : " + msg);
    }

    @RabbitListener(queues = "SECOND_QUEUE")
    public void processSecond(String msg){
        System.out.println(" second queue received msg : " + msg);
    }

    @RabbitListener(queues = "THIRD_QUEUE")
    public void processThird(String msg){
        System.out.println(" third queue received msg : " + msg);
    }
}

创建测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class ThreadApplicationTests {

    @Autowired
    private MyProvider provider;
    @Test
    public void contextLoads() {
        provider.send();
    }

}

运行结果正常

管理端界面显示代码创建的Exchange与Queue

web界面发送消息