Spring Cloud Stream 消息驱动微服务 相关图形，dljd，cat - springcloud nexflix

一 业务：多个微服务

二 需求与问题

1 需求

1. 微服务之间传递消息
   1. 使用消息中间件，在服务与服务之间传递消息 ，RabbitMQ/Kafaka

2 问题

1. 消息中间件和服务之间耦合，换中间件，变动大/修改多         

三 解决方案：

1 功能“集”：降低微服务和消息中间件的耦合性

2 “神”工具：Spring Cloud Stream，整合消息中间件，限制RabbitMQ、Kafaka

四 完成学习：垃圾，关疑重难；体会，提图表短。

1 设计思想

1. 解耦
   1. 开发人员无感知地使用消息中间件
      1. 即可以做到代码层面对消息中间件的无感知
      2. 甚至于动态的切换中间件(rabbitmq切换为kafka)，实现轻松在不同消息中间件间切换的目的

2 体系组织

Applicatoin core：微服务应用程序 + spring cloud stream框架。

inputs：输入，consumer消费者，从消息服务器中，消费消息。

outputs：输出，provider生产者，生产消息，把消息推送到消息服务器中。

消息服务器：限制rabbitmq、kafaka。

Binder：绑定器，包装了消息服务器。

             微服务应用 + spring cloud stream 《》Binder 《》消息服务器

1. 我们只需关注如何与Binder交互即可，而无需关注与具体消息中间件的交互。 
   1. 应用程序通过input（相当于消费者consumer）、output（相当于生产者producer）来与Spring Cloud Stream中Binder交互。

      1. Binder负责与消息中间件交互

组成	说明
Binder	Binder是应用与消息中间件之间的封装，或者称为桥梁，目前实现了Kafka和RabbitMQ的Binder，通过Binder可以很方便的连接中间件，可以动态的改变消息类型(对应于Kafka的topic，RabbitMQ的exchange)，这些都可以通过配置文件来实现；
@Input	该注解标识输入通道，通过该输入通道接收消息进入应用程序。 消费服务器 》消息 》binder 》应用程序消费消息。
@Output	该注解标识输出通道，发布的消息将通过该通道离开应用程序。 应用程序生产消息 》消息 》binder 》消费服务器。
@StreamListener	监听队列，用于消费者的队列的消息接收
@EnableBinding	将信道channel和exchange绑定在一起

3 流原

1. Spring Cloud Stream 是一个构建消息驱动微服务的框架。
   1. Spring Cloud Stream对消息中间件的进一步封装
      1. 微服务在对接消息服务器时，按照统一的接口进行开发，屏蔽了底层的消息服务器的差异，实现底层消息服务器的自由切换
         1. 有点类似于Hibernate，底层即可以连接mysql也可以连接oracle，但上层的Hibernate API却是一致的。即，如果使用了Hibernate，那么底层的数据库用什么都可以（可以使用mysql，不爽了，可以切换成oracle，dao层的代码不需要改变）。

生产者：

1. 第一步：执行业务逻辑代码
2. 第二步：通过spring cloud stream框架，帮我们发送消息到消息服务器（消息传递系统）
   1. source，系统默认为output，Exchange交换机名称，可以自定义
   2. channel 与 source绑定
   3. Binder 与 channel绑定
   4. Binder把消息推送到消息服务器（消息传递系统），如rabbitmq或kafaka

消费者：

1. 第一步：执行业务逻辑代码
2. 第二步：通过spring cloud stream框架，帮我们从消息服务器（消息传递系统）接收消息
   1. 生产者把消息推送到消息服务器
   2. Binder接收到消息
   3. channel
   4. Sink，系统默认为input，可自定义
   5. spring cloud stream框架，可以启动监听，得到消息，消费消息

4 只官配play：系统的消息通道（名称）

（1）启动rabbitmq消息服务器

（2）生产者：

1. 第一步：创建SpringBoot应用34-springcloud-service-stream；
2. 第二步：添加依赖

   <!-- spring-cloud-starter-stream-rabbit -->
   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
   </dependency>

3. 第三步：配置文件 application.properties

   #对接具体的消息中间件
   #spring.cloud.stream.binders本身是一个Map,其中rabbitmq是键，type=rabbit是值
   #你也可以写成：spring.cloud.stream.binders.xxx.type=rabbit,其中xxx是键，type=rabbit是值
   spring.cloud.stream.binders.rabbitmq.type=rabbit
   #spring.cloud.stream.binders.rabbitmq.environment本身也是一个map<String,Object>
   #其中spring是键值，rabbitmsq.host=192.168.10.128是值
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.host=192.168.10.128
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.port=5672
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.username=guest
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.password=guest
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.virtual-host=/
   
   #消息生产者
   #其中output是一个key，这个名字是一个通道的名称，在代码中会用到
   #destination表示要使用的Exchange名称定义
   spring.cloud.stream.bindings.output.destination=spring.cloud.stream.exchange
   #设置要绑定的消息服务的binder
   spring.cloud.stream.bindings.output.binder=rabbitmq

4. 第四步：消息发送方法

   @EnableBinding(Source.class)
   public class MessageSender {
       @Autowired
       private MessageChannel output; // 消息的发送管道
   
       public void publish(String msg) {
           //  把发出去的消息转换成一个json对象，这个对象是Message message
           output.send(MessageBuilder.withPayload(msg).build());
           System.out.println("消息发送：<" + msg + "> 完成，时间：" + new Date());
       }
   }

5. 第五步：在业务层发送消息方法
   
6. 第六步：在springboot启动类中调用业务层方法发送消息 

（3）消费者：

1. 第一步：配置消息消费者

   #对接具体的消息中间件
   #spring.cloud.stream.binders本身是一个Map,其中rabbitmq是键，type=rabbit是值
   #你也可以写成：spring.cloud.stream.binders.xxx.type=rabbit,其中xxx是键，type=rabbit是值
   spring.cloud.stream.binders.rabbitmq.type=rabbit
   #spring.cloud.stream.binders.rabbitmq.environment本身也是一个map<String,Object>
   #其中spring是键值，rabbitmsq.host=192.168.10.128是值
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.host=192.168.10.128
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.port=5672
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.username=guest
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.password=guest
   spring.cloud.stream.binders.rabbitmq.environment.spring.rabbitmq.virtual-host=/
   
   #配置消息消费者
   #指定交换机
   spring.cloud.stream.bindings.input.destination=spring.cloud.stream.exchange
   #设置要绑定的消息服务的binder
   spring.cloud.stream.bindings.input.binder=rabbitmq

2. 第二步：消息接收方法

   @EnableBinding(Sink.class)
   public class MessageReceiver {
       //  自动监听，一旦消息生产者有消息，立马接收消息
       @StreamListener(Sink.INPUT)
       public void input(Message message) {
           System.out.println("消息接收：<" + message.getPayload()  + "> 完成，时间：" + new Date());
       }
   }

5 只官配play：自定义消息通道（名称）

        在前面的案例中，我们已经实现了一个基础的 Spring Cloud Stream 消息传递处理操作，但在操作之中使用的是系统提供的 Source （output）、Sink（input），接下来我们来看一下自定义通道名称；

        注意：自定义消息通道（名称）以后，配置文件要使用指定的自定义的那个名称。

（1）生产者：

1. 第一步：接口，生产者，自定义名称为myOutput

   public interface MessageSource {
   
       //channel名称
       String OUTPUT = "myOutput";
   
       @Output(OUTPUT)
       MessageChannel output();
   }

2. 第二步：配置消息生产者：使用自定义名称：myOutput

   #消息生产者
   #其中utput是一个key，这个名字是一个通道的名称，在代码中会用到
   #destination表示要使用的Exchange名称定义
   spring.cloud.stream.bindings.myOutput.destination=spring.cloud.stream.exchange
   #设置要绑定的消息服务的binder
   spring.cloud.stream.bindings.myOutput.binder=rabbitmq

3. 第三步：修改启动类Application.java
   

（2）消费者

1. 第一步：接口，消费者，自定义名称为myInput

   public interface MessageSink {
   
       String INPUT = "myInput";
   
       @Input(Sink.INPUT)
       SubscribableChannel input();
   }

2. 配置消息消费者：使用自定义名称：myInput

   #配置消息消费者
   #指定交换机
   spring.cloud.stream.bindings.myInput.destination=spring.cloud.stream.exchange
   #设置要绑定的消息服务的binder
   spring.cloud.stream.bindings.myInput.binder=rabbitmq

3. 第三步：修改启动类

6 只官配play：分组与持久化

1. 临时消息
   1. 有一条消息，如果没有消费者进行消费处理，那么该消息是不会被永久保留，可能会造成消息的丢失。

2. 分组的作用：

   1. 作用1：实现持久化消息

      1. 需要在消息的消费端配置一个分组，有分组就表示该消息可以进行持久化；
         1. 在Spring Cloud Stream 中在消费者端如果将队列设置为持久化队列，则队列名称会变为为destination.group，此时消费端的微服务宕机或重启，该队列信息依然会被保留在 RabbitMQ中，后续依然可以进行消费；
         2. 剩官配play：

            #指定分组，可以进行消息的持久化 applies to consumers only
            #此分组属性仅仅只能用于消费端
            spring.cloud.stream.bindings.myInput.group=rabbitmq-group

   2. 作用2：可以实现同一分组只有一个消费者能接收到消费

      1. 分组：可以让一个消息只能被同一分组内的一个消费者接收，避免一个消息被多个消费者消费。

      2. 不分组：

         1. 消费者要先启动起来，然后再用生产者发送消息，这样才可以接收到消息，否则发送的消息就丢失了，生产者先发了消息，消费者后面才启动的话是接收不到消息的；
         2. 多个消费者都能接收消息，也就是一个消息可以被多个消费者接收；

7 只官配play：设置路由键

        默认情况下Spring Cloud Stream传送消息属于广播消息，默认匹配方式是 #，表示所有消费者都可以匹配上，我们也可以通过指定路由键 RoutingKey实现按需求匹配消息消费端进行消息接收处理；

在消费端进行设置：

#设置一个RoutingKey路由key，默认是#，我们可以指定
spring.cloud.stream.rabbit.bindings.myInput.consumer.bindingRoutingKey=spring.cloud.stream.#

五 注应用

1 归纳总结：开发的时候有两种选择

1. 一种就是 直接SpringBoot + rabbitmq整合实现消息传送；
2. 一种就是 使用Spring Cloud Stream对消息中间件的包装，来实现消息传送；