RabbitMQ入门

初识MQ

同步通讯与异步通讯

服务间通讯有同步和异步两种方式：

同步通讯：就像打电话，需要实时响应。

异步通讯：就像发邮件，不需要马上回复。

两种方式各有优劣，打电话可以立即得到响应，但是你却不能跟多个人同时通话。发送邮件可以同时与多个人收发邮件，但是往往响应会有延迟。

同步通讯

同步调用的优点：

• 时效性较强，可以立即得到结果

同步调用的问题：

• 耦合度高
• 性能下降
• 有额外的资源消耗
• 有级联失败问题

异步通讯

异步调用则可以避免上述问题：

我们以购买商品为例，用户支付后需要调用订单服务完成订单状态修改，调用物流服务，从仓库分配响应的库存并准备发货。

在事件模式中，支付服务是事件发布者（publisher），在支付完成后只需要发布一个支付成功的事件（event），事件中带上订单id。

订单服务和物流服务是事件订阅者（Consumer），订阅支付成功的事件，监听到事件后完成自己业务即可。

为了解除事件发布者与订阅者之间的耦合，两者并不是直接通信，而是有一个中间人（Broker）。发布者发布事件到Broker，不关心谁来订阅事件。订阅者从Broker订阅事件，不关心谁发来的消息。

Broker 是一个像数据总线一样的东西，所有的服务要接收数据和发送数据都发到这个总线上，这个总线就像协议一样，让服务间的通讯变得标准和可控。

好处：

• 吞吐量提升：无需等待订阅者处理完成，响应更快速

• 故障隔离：服务没有直接调用，不存在级联失败问题

• 调用间没有阻塞，不会造成无效的资源占用

• 耦合度极低，每个服务都可以灵活插拔，可替换

• 流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件

缺点：

• 架构复杂了，业务没有明显的流程线，不好管理
• 需要依赖于Broker的可靠、安全、性能

好在现在开源软件或云平台上 Broker 的软件是非常成熟的，比较常见的一种就是我们今天要学习的MQ技术。

快速入门

安装MQ

方式一：在线拉取
docker pull rabbitmq:3.8-management

方式二：从本地加载(推荐使用这种)

在课前资料已经提供了镜像包：C:\Users\smoke\Documents\JavaWeb\解压版资料\项目一前置课b\day13-RabbitMQ\资料

【1】将该镜像包上传到虚拟机的tmp目录

【2】上传到虚拟机中后，切换到存放mq.tar文件的tmp的目录

【3】切换目录后使用命令加载镜像即可：
docker load -i mq.tar

【4】查看镜像

docker images

【5】安装

docker run \
 # 设置环境变量  用户名是 itcast
 -e RABBITMQ_DEFAULT_USER=itcast \
 # 设置环境变量  密码是 123321
 -e RABBITMQ_DEFAULT_PASS=123321 \
 # 挂载数据卷，后面高级会用到下面的插件
 -v mq-plugins:/plugins \
 # mq的名字
 --name mq \
 # 主机名 这里不配置也可以，后期如果是集群必须配置
 --hostname mq \
 # web可视化终端监控端口；mq的ui界面管理平台端口
 -p 15672:15672 \
 # 程序与mq交互的访问端口；发消息和收消息的端口
 -p 5672:5672 \
 # 后端运行
 -d \
 # 镜像名称
 rabbitmq:3.8-management

docker run \
 -e RABBITMQ_DEFAULT_USER=itcast \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3.8-management

15672端口：web可视化终端监控端口；mq的ui界面管理平台端口

5672端口：程序与mq交互的访问端口；发消息和收消息的端口

访问路径：http://192.168.204.136:15672/

1.发送简单队列消息

1.发送者

【1】导入依赖

 <!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

【2】在yml配置文件中配置连接mq服务器的参数

spring:
  rabbitmq:
    host: 192.168.204.136  # 主机名
    port: 5672 # 发送消息和接收消息的端口号
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码

【3】发送者代码实现

//TODO:是一个测试启动器，可以加载SpringBoot测试注解,让测试方法在Spring容器环境下执行
@RunWith(SpringRunner.class)
//TODO:目的是加载ApplicationContext，启动spring容器
@SpringBootTest
public class SpringAmqpTest {
    //自动装配RabbitTemplate模板对象
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * Basic Queue 简单队列模型
     */
    @Test
    public void testSimpleQueue() {
        //1.定义变量保存队列名
        String queueName = "simple.queue";
        //2.定义变量保存发送的消息
        String message="hello，我是锁哥，发送的基本消息";
        //3.发送消息
        rabbitTemplate.convertAndSend(queueName,message);
    }
}

2.消费者

【1】导入启动依赖

 <!--AMQP依赖，包含RabbitMQ-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>

【2】在yml配置文件中配置连接mq服务器的参数

spring:
      rabbitmq:
        host: 192.168.204.136 # 主机名
        port: 5672 # 发送消息和接收消息的端口号
        virtual-host: / # 虚拟主机
        username: itcast # 用户名
        password: 123321 # 密码

【3】消费者者代码实现

package cn.itcast.mq.listener;


import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;


//TODO:@Component表示将当前类放到SpringIOC容器中
@Component
public class SpringRabbitListener {

    //定义监听简单消息队列simple.queue的消息
    /*
        1.RabbitListener 注解中的属性：String[] queues() default {}; 书写监听哪个队列的名字
     */
//    @RabbitListener(queues = {"simple.queue"})
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleMessage(String msg){
        System.out.println("消费者接收到了生产者发送的消息:"+msg);
    }
}

2.WorkQueue队列

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。

此时就可以使用work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

1.生产者

/**
     * workQueue
     * 向队列中不停发送消息，模拟消息堆积。
     */
    @Test
    @RabbitListener(queuesToDeclare = @Queue("simple.queue"))
    public void testWorkQueue() throws InterruptedException {
        //1.定义变量保存存放消息的队列名
        String queueName = "simple.queue";
        //2.定义变量保存发送的消息
        String message="hello,work queue message_";
        //3.发送消息
        for (int i = 1; i <= 50; i++) {
            rabbitTemplate.convertAndSend(queueName,message+i);
            //每隔20毫秒发送
            Thread.sleep(20);
        }
    }

2.消费者

//定义消费者1消费工作队列即work queue的消息
    @RabbitListener(queues = "simple.queue")
    public void listenWork1Message(String msg) throws InterruptedException {
        System.out.println("消费者1接收到了生产者发送的消息:"+msg);
        //休眠20ms
        Thread.sleep(20);
    }

    //定义消费者1消费工作队列即work queue的消息
    @RabbitListener(queues = "simple.queue")
    public void listenWork2Message(String msg) throws InterruptedException {
        System.out.println("消费者2接收到了生产者发送的消息:"+msg);
        //休眠20ms
        Thread.sleep(100);
    } 

3.广播交换机实现

Fanout，英文翻译是扇出，我觉得在MQ中叫广播更合适。

在广播模式下，消息发送流程是这样的：

• 1） 可以有多个队列
• 2） 每个队列都要绑定到Exchange（交换机）
• 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
• 4） 交换机把消息发送给绑定过的所有队列
• 5） 订阅队列的消费者都能拿到消息

1.声明队列和交换机

在consumer中创建一个配置类，声明队列和交换机：

package cn.itcast.mq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {

    /**
     * 声明交换机
     * @return
     */
    @Bean //将返回值对象交给IOC容器管理  bean的方法名就是bean的key
    public FanoutExchange fanoutExchange() {
        //创建交换机并声明交换机名称
        return new FanoutExchange("itcast.fanout");
    }

    /**
     * 声明第一个队列
     * @return
     */
    @Bean
    public Queue queue1() {
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定交换机和队列
     * @param queue1 //队列 =public Queue queue1() 方法名
     * @param fanoutExchange //交换机 =public FanoutExchange fanoutExchange() 方法名
     * @return
     */
    @Bean
    public Binding bindingQueue1(Queue queue1,FanoutExchange fanoutExchange) {
        return  BindingBuilder.bind(queue1).to(fanoutExchange);
    }

    /**
     * 声明第二个队列
     * @return
     */
    @Bean
    public Queue queue2() {
       return new Queue("fanout.queue2");
    }

    /**
     * 绑定交换机和队列
     */
    @Bean
    public Binding bindingQueue2(Queue queue2,FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue2).to(fanoutExchange);
    }

}

2.生产者

//生产者发送的消息，只能发送到交换机
 /**
     * Fanout Exchange：广播
     */
    @Test
    public void testFanoutExchange() {
        //消息
        String message = "hello,大家好我是牛冲冲";
        //交换机
        String exchange = "itcast.fanout";
        for (int i = 0; i < 50; i++) {
            //参数1：交换机名称  参数2：路由键  参数3：消息
            rabbitTemplate.convertAndSend(exchange, "", message + " " + i);
        }

    }

3.消费者

    /广播模式监听//
    @RabbitListener(queues = "fanout.queue1")
    public void fanoutQueue1(String msg) {
        System.out.println("【消费者1】监听到的消息是：" + "【" + msg + "】");
    }
    @RabbitListener(queues = "fanout.queue2")
    public void fanoutQueue2(String msg)  {
        System.out.println("【消费者2】监听到的消息是：" + "【" + msg + "】");
    }

4.路由交换机实现

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下：

• 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
• 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
• Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

1.生产者

   /**
     * Direct Exchange：路由
     */
    @Test
    public void testSendDirectExchange() {
        String message = "快放暑假了，赶紧内卷";
        String routingKey = "blue";
        String exchange = "direct.exchange";
        //参数1：交换机名称  参数2：路由键  参数3：消息
        rabbitTemplate.convertAndSend(exchange, routingKey, message);

    }

2.消费者

  //路由模式监听//

    /**
     *1.@RabbitListener 注解属性：QueueBinding[] bindings() default {};
     *    说明：QueueBinding也是一个注解，作用是绑定队列和交换机
     *
     * 2.@QueueBinding 注解属性：
     *    Ⅰ：Queue value(); Queue 是一个注解，作用是创建一个队列
     *    Ⅱ：Exchange exchange();Exchange 是一个注解，作用是创建一个交换机 并可以设置类型
     *    Ⅲ：String[] key() default {}; 路由键
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "routing.queue1"),
            exchange = @Exchange(name = "direct.exchange",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
            ))
    public void routingQueue1(String msg) {
        System.out.println("【消费者1】监听到的消息是：" + "【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "routing.queue2"),
            exchange = @Exchange(name = "direct.exchange",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
             ))
    public void routingQueue2(String msg) {
        System.out.println("【消费者2】监听到的消息是：" + "【" + msg + "】");
    }

5.主题交换机实现

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.spu.insert 或者 item.spu

item.*：只能匹配item.spu

图示：

解释：

• Queue1：绑定的是china.# ，因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather
• Queue2：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news

1.生产者

 /**
     * Topic Exchange：主题
     */
    @Test
    public void testSendTopicExchange() {
        String message = "恭喜铁头攻占日本神厕";
        String exchange = "topic.exchange";
        String routingKey = "china.news";
        //参数1：交换机名称  参数2：路由键  参数3：消息
        rabbitTemplate.convertAndSend(exchange, routingKey, message);
    }

2.消费者

/主题模式监听//

    /**
     *与路由模式类似，只是路由键可以写通配符
     *key = {"china.#"}
     * 通配符规则：
     *    `#`：匹配一个或多个词
     *    `*`：匹配不多不少恰好1个词
     */
   @RabbitListener(bindings = @QueueBinding(
           value = @Queue(name = "topic.queue1"),
           exchange = @Exchange(name = "topic.exchange",type = ExchangeTypes.TOPIC),
           key = {"china.#"}
   ))
    public void topicQueue1(String msg) {
        System.out.println("【消费者1】监听到的消息是：" + "【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "topic.exchange",type = ExchangeTypes.TOPIC),
            key = {"#.news"}
    ))
    public void topicQueue2(String msg) {
        System.out.println("【消费者2】监听到的消息是：" + "【" + msg + "】");
    }

消息转换器

之前说过，Spring会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

只不过，默认情况下Spring采用的序列化方式是JDK序列化。众所周知，JDK序列化存在下列问题：

• 数据体积过大
• 有安全漏洞
• 可读性差

我们来测试一下。

测试默认转换器

1.消费者

我们在consumer中利用@Bean声明一个队列：

@Bean
public Queue objectMessageQueue(){
    return new Queue("object.queue");
}

2.生产者

我们修改消息发送的代码，发送一个Map对象：

	@Test
    public void testSendMap() throws InterruptedException {
        // 准备消息
        Map<String,Object> msg = new HashMap<>();
        msg.put("name", "Jack");
        msg.put("age", 21);
        // 发送消息
        rabbitTemplate.convertAndSend("simple.queue", msg);
    }

停止consumer服务，发送消息后查看控制台：

消息经过jdk序列化处理，阅读性很差，且数据体积过大！

配置JSON转换器

显然，JDK序列化方式并不合适。我们希望消息体的体积更小、可读性更高，因此可以使用JSON方式来做序列化和反序列化。

【1】在publisher和consumer两个服务中都引入依赖：

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

【2】在生产者方配置消息转换器。

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

【3】在消费者方配置消息转换器。

@RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String, Object> msg) {
        System.out.println("收到消息：【" + msg + "】");
    }

【4】执行生产者代码，查看mq服务器内容

【5】执行消费者代码，查看idea控制台。