SpringBoot与消息

概述：

1.    大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力。

以用户注册创建账户为例： 

  注册信息写入数据库 ，发送注册邮件，发送注册信息

假定该三步操作都需要50ms

       

如上图所示， 放在以前，当我们进行同步调用时，写入数据库后，调用发送注册邮件的方法，在调用发送注册短信的， 如第一种所示，则需要150ms ，用户收到注册成功回馈。 

当我们采用多线程的方式，发送注册邮件和发送注册短信异步执行，仍旧需要 100ms，用户收到注册成功回馈。如第二种所示。

此时，如果我们引入消息队列，当注册信息写入数据库后，可以很快的将该信息写入队列中(时间很短)，此时用户就可以收到响应注册成功的消息。而发送邮件和发送短信的业务，都可以通过异步自动读取这些信息，给用户发邮件、发消息。如第三种所示。

再如： 应用解耦

 

 比如有订单系统和库存 系统，假如写在一个应用中，如第一种，下完单后，再去调用库存系统，其耦合度很高，同时也像第一个案例一样，响应时间过长。

如果把库存和订单系统单独抽离，例如微服务形式调用，如果在引入 消息队列，下单后，将订单信息写入消息队列，而库存系统通过订阅消息队列中的消息，来进行库存的相关业务操作，这就大大降低了耦合度，而且提高了响应时间。

再如：流量削峰，特别是用于秒杀系统

   假如某件商品仅有1万份，十万人进行秒杀，如果每一个人的请求都发过来，tomcat进行处理，这将瞬间击垮服务器，此时怎么做呢？  我们可以把用户的请求放入到消息队列中，并给消息队列指定长度，比如1万，此时用户的速度快，就抢先进入队列，当消息队列长度(用户请求书)达到上限(1万)，就立马抛出响应失败，也即其他9万人的请求，立马被抛回。 而这些在消息队列中的内容(用户请求)，秒杀业务就开始慢慢取出内容，进行相关业务操作。

通过这三个案例，就展示了为什么要引入消息中间件---消息队列。

2. 消息服务的两个重要概念：

   消息代理(message borker) 和 目的地(destination)，当消息发送者发送消息后，将有消息代理接管，消息代理保证消息传递到指定目的地。

3. 主要有两种形式的目的地： 

   1. 队列(queue): 点对点消息通信(point-to-point)

   2. 主题(topic): 发布(publish) /订阅(subscribe) 消息通信

4. 点对点式：

  - 消息发送者发送消息，消息代理将其放入一个队列中，消息接受者从队列中获取消息内容，消息读取后被移除队列

 - 消息只有唯一的发送者和接受者，但不是说只能有一个接收者。

5. 发布订阅式：

 - 发送者(发布者)发送消息到主题，多个接收者(订阅者)监听(订阅)这个主题，那么就会在消息到达时同时接收到消息

6. JMS (Java Message Service)Java消息服务

 - 基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现。

7. AMQP(Advanced Message Queuing Protocol)

  -高级消息队列协议，也是一个消息代理的规范，兼容JMS

 - RabbitMQ是AMQP的实现。

JMS和AMQP的对比如下：

 8. Spring支持

   - Spring-jms 提供了对JMS的支持

  - spring-rabbit 提供了对AMQP的支持

 - 需要ConnectionFactory的实现来连接消息代理

 - 提供JmsTemplate、RabbitTemplate来发送消息

- @JmsListener(JMS) 、@RabbitListener(AMQP) 注解在方法上监听消息代理发布的消息

- @EnableJms、@EnableRabbit 开启支持

9. Spring Boot自动配置

- JmsAutoConfiguration

- RabbitAutoConfiguration

  下面介绍 RabbitMQ相关内容：

RabbitMQ简介

是一个由erlang开发的AMQP(Advanved Message Queue Protocol)的开源实现。

核心概念 

  Message

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

 Publisher

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

 Exchange

 交换器，用来接收生产者发送的消息，并将这些消息路由给服务器中的队列。有4中类型：direct(默认)，fanout，topic，和headers，不同类型的Exchange转发消息的策略有所区别。

Queue

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

Binding

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

Exchange和Queue的绑定可以是多对多的关系。

Connection

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

Channel

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

Consumer

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

Virtual Host

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

Broker 

表示消息队列服务器实体

2. RabbitMQ运行机制

AMQP中的消息路由

  AMQP中消息的路由过程和Java开发者熟悉的JMS存在一定差别，AMQP中增加了Exchange和Binding的角色。生产者把消息发布到Exchange上，消息最终到达队列并被消费者接收，而Binding决定交换器的消息应该发送到哪个队列。

Exchange类型

 Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型：direct，fanout，topic，headers。headers匹配AMQP消息的header而不是路由键，headers交换器和direct交换器完全一致，但性能差很多，目前几乎不用，所以直接了解其它三种类型：

Direct Exchange  ：消息中的路由键(routing key) ，如果和Binding中的binding key一致，交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为"dog"，则只会转发 routing key 标记的为 "dog"的消息，不会转发"dog.puppy" ，也不会转发"dog.guard"等等。它是完全匹配、单播的模式。

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

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

安装 RabbitMQ ：我是安装在linux上，关于安装，请参考这篇文章 ：centos7安装RabbitMQ

登录后，可以在网页上进行简单操作，比如，创建几个Exchange，Queues，并进行绑定，然后发送消息，查看Queue里面接收到的消息。

下面我们用springBoot 来整合RabbitMQ。

在项目pom文件中引入相关依赖：

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

 在yml文件中配置如下：

spring:
  rabbitmq:
    host: 192.168.xxx.xxx
    username: guest
    password: guest
    port: 5672  # 默认就是5672

 事实上，springBoot已经自动装配了我们操作RabbitMq的模板类RabbitTemplate ，查看 RabbitAutoConfiguration.class ，就可以发现，自动装配了 RabbitTemplate,我们可以在需要用的地方，直接注入。

默认的模板类的配置如下：

   

 所以，如果RabbitMQ装在本机，并且没有修改其端口的话，我们可以直接启动项目，观察是否连接。

继续阅读代码，发现还自动装配了 AmqpAdmin （RabbitMQ系统管理功能组件，创建和删除 Queue，Exchange功能等）

 查看RabbitMessagingTemplate.class ，发现默认使用的消息转换器 MessageConverter 为SimpleMessageConverter ，而其中实际使用的是java的序列化机制，如下：

 实际项目中，我们更希望 消息以json这种跨平台，轻量级的形式发送，于是我们可以编写一个配置类，自定义一个消息转换器，并注入到容器，使其生效。我们仅需要将其注入到容器中，即可（查看自动装配的配置类，如果容器中没有消息转换器，就自动创建一个SimpleMessageConverter  ，如果有就使用容器中自带的。）

@Configuration
public class MyAMQPConfig {
    @Bean  // 修改默认的消息转换器，使用Json的消息转换器
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}

简单查看了其配置类，下面我们用代码展示其使用。

发送消息：

 // Message 需要 自己构造一个， 定义消息体内容和消息头
       rabbitTemplate.send(exchange,routeKey,message);
        // object默认当成消息体，只需要传入要发送的对象，自动序列化发送给rabbitmq。
      rabbitTemplate.convertAndSend(exchange,routeKey,object);

发送消息：

可以使用模板类中的send和convertAndSend方法， 两者的区别就在于 前者需要自定义消息体内容和消息头。后者只需要传入要发送的对象(消息体)，自动回序列化(MessageConverter)并发送给rabbitMQ 。例如，我们往名为“exchange.direct”的交换器上发送一个消息对象，并指定其routingKey为  zhao.news

@Test
    public void contextLoads() {
       rabbitTemplate.convertAndSend("exchange.direct", "zhao.news", new Book("西游记", "吴承恩"));
    }

执行该测试方法，发现测试通过，然后我们就可以在页面上看到队列里多了一条数据。

查看消息，如下：

 注意看：默认使用的是 java的序列化机制，所以这里看到的是字节形式，可以按照我上面MyAMQPConfig 配置类，使用json的消息转换器。 在发送一次消息：

@Test
    public void contextLoads() {

        Map<String, Object> map = new HashMap<>();
        map.put("msg", "这是第一个消息");
        map.put("data", Arrays.asList("helloWorld", 1, 2, 3, "test", true));

      
        // 消息的转换用的是 MessageConverter 
       rabbitTemplate.convertAndSend("exchange.direct", "zhao.news", map);
      
    }

 其接收到的消息如下：

 

接收消息：   receiveAndConvert()

 @Test
    public void receive() {
        Object o = rabbitTemplate.receiveAndConvert("zhao.news");
        System.out.println(o.getClass());
        System.out.println(o);
    }

 监听消息：  @EnableRabbit+@RabbitListener

  当有这样的情景时：订单系统和库存系统通过消息队列来传递消息时，当下了单后，将订单信息放入消息队列后，此时库存系统怎么知道该接收消息呢？可以通过监听消息队列来实现，当消息队列中有新的订单信息，库存系统就进行库存的相关操作。

在springBoot中可以使用 @EnableRabbit+@RabbitListener  注解来实现监听。使用如下:

 定义一个service ，用来监听消息队列中的消息。

@Service
public class BookService {
    @RabbitListener(queues = "zhao.news")  //使用该注解，监听指定的队列，需要在主启动类上开启注解 @EnableRabbit
    public void receive(Book book) { // 拿到消息头中的实体book对象
        System.out.println("收到消息："+book);
    }

    @RabbitListener(queues = "zhao")
    public void receiveMsg(Message message){  //获取完整的消息，包括消息头
       // System.out.println("监听队列完整的信息");
       // System.out.println(message.getBody());
      //  System.out.println(message.getMessageProperties());
    }
}

@RabbitListener注解中的queues指定监听的队列，也可以监听多个队列。

注意：使用该注解，想使得该注解生效，需要在主启动类上添加注解@EnableRabbit，开启基于注解的RabbitMQ监听。

该方法执行于监听的队列中的内容变化后。

重新发送一次消息，就会发现控制台输出如下：

 

 

 AmqpAdmin:  

 RabbitMQ系统管理功能组件,创建和删除 Queue，Exchange等。前面说过，自动装配了AmqpAdmin对象，所以我们可以直接注入并使用。

代码创建Exchange，queue如下：

 @Autowired
 private AmqpAdmin amqpAdmin;   //AmqpAdmin 用来管理组件

@Test
    public void createExchange(){// declareXXX用于创建
        amqpAdmin.declareExchange(new DirectExchange("amqpadmin.exchange"));// 创建direct类型的exchange

        System.out.println("创建完成");

        amqpAdmin.declareQueue(new Queue("amqpadmin.queue",true));// 名字，是否持久化

        // 创建绑定
        amqpAdmin.declareBinding(new Binding("amqpAdmin.queue",Binding.DestinationType.QUEUE,
                "amqpadmin.exchange","amqp.haha",null));
    }

可以在网页上查看，其队列的变化。

  exchange:

queue: 

 

 binding（绑定）:

还可以进行删除操作(deleteXXX) ,这里就不在展示了。