Spring-Cloud-Stream & RocketMQ 简介及简单demo

Spring Cloud Stream 在 Spring Cloud 体系内用于构建高度可扩展的基于事件驱动的微服务，其目的是为了简化消息在 Spring Cloud 应用程序中的开发。

Spring Cloud Stream的核心构件是：

Destination Binders: 负责提供与外部消息系统集成的组件。
Destination Bindings: 作为消息中间件与应用程序的提供者和消费者之间的桥梁。
Message: 生产者和消费者用于与目的地装订器沟通的典型数据结构(从而通过外部消息系统与其他应用程序进行通信的典型数据结构)。
大概的意思就是我们以后就不用管消息中间件是啥了，这些都由spring-cloud-stream去管理。比如我们现在使用的是rabbitmq，后期项目要求换成rocketmq，我们不用去改代码。换个依赖，配置文件改一改就OK了。

如下图所示：

消息通过MessageChannel(output)发送（这里底层scs会怎样通过一系列调用将消息发送给mq我们都不用管）
mq收到消息后，中间件内部会有通道适配器，将中间件特有的消息格式转换为 SpringMessage，然后发送到
MessageChannel(input)
我们通过监听MessageChannel(input)就能拿到对应的消息进行消费了

上代码
pom依赖

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    4.0.0
   
        org.springframework.boot
        spring-boot-starter-parent
        2.2.6.RELEASE
       
   
    org.example
    mq
    1.0-SNAPSHOT

   
        1.8
        Hoxton.SR4
   

   
       
            com.alibaba.cloud
            spring-cloud-starter-stream-rocketmq
            2.2.1.RELEASE
       
       
            org.springframework.boot
            spring-boot-starter-web
       
       
            org.springframework.cloud
            spring-cloud-stream-test-support
            test
       
       
            org.springframework.cloud
            spring-cloud-stream
       
       
            org.springframework.boot
            spring-boot-starter
       

       
            org.springframework.boot
            spring-boot-starter-test
            test
           
               
                    org.junit.vintage
                    junit-vintage-engine
               
           
       
       
            junit
            junit
            test
       
   

   
       
           
                org.springframework.cloud
                spring-cloud-dependencies
                ${spring-cloud.version}
                pom
                import
           
       
   

   
       
           
                org.springframework.boot
                spring-boot-maven-plugin
           
       
   

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
配置文件application.yml

spring:
  cloud:
    stream:
      rocketmq:
        binder:
          name-server: "127.0.0.1:9876"
      bindings:
        my-output:
          destination: topic1 #相当于RocketMQ中的topic
          content-type: application/json # 内容格式。这里使用 JSON
        my-input:
          destination: topic1 #相当于RocketMQ中的topic
          group:  group1 #消费组
          content-type: application/json # 内容格式。这里使用 JSON
          consumer:
            concurrency: 5 #实例数量
            broadcasting: false # 是否使用广播消费，默认为 false 使用集群消费，如果要使用广播消费值设成true。
        #集群消费：相同消费者下的实例平摊消息
        #广播消费：相同消费组下的每个实例都消费所有消息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
创建一个消息管道 MyChannel
创建完成之后记得在启动类上加注解 @EnableBinding({MyChannel.class}) 让启动类知道这个自定义消息管道

import org.springframework.cloud.stream.annotation.Input;
import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.SubscribableChannel;
import org.springframework.stereotype.Component;

@Component
public interface MyChannel {

    String OUTPUT = "my-output";
    String INPUT = "my-input";

    //声明了一个名字为my-output的Output Binding。注意，这个名字要和我们配置文件中的 spring.cloud.stream.bindings 配置项对应上。
    @Output(MyChannel.OUTPUT)
    MessageChannel output();

    //声明了一个名字为my-input的Output Binding。注意，这个名字要和我们配置文件中的 spring.cloud.stream.bindings 配置项对应上。
    @Input(MyChannel.INPUT)
    SubscribableChannel input();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
创建生产者

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    @Autowired
    private MyChannel myChannel;

    @RequestMapping("/send")
    public void send(String message,String headerValue){
        Message myMessage = MessageBuilder.withPayload(message)
                .setHeader("myheader",headerValue)
                .build();
        myChannel.output().send(myMessage);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
创建消费者

@Component
public class MyCustomer {

    //value指定监听的Channel condition实现多个监听者方法的选择调度
    @StreamListener(value = MyChannel.INPUT, condition = "headers['myheader']=='header1'")
    public void testCustomListener(Message message) {
        System.out.println(message.getHeaders().get("myheader") + "||" + message.getPayload().toString());
    }

    @StreamListener(value = MyChannel.INPUT, condition = "headers['myheader']=='header2'")
    public void testCustomListener(@Payload String message) {
        //如果消息对象是引用类型，需要使用@Payload进行反序列化 这里String其实不用也可以
        System.out.println("header2||" + message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
启动程序，发送一条消息

再发送一条消息 localhost:8080/send?message=消息1&headerValue=header2

可以看到@StreamListener注解中的condition限制了消费者去消费对应的消息。我理解和rocketmq中的tag差不多

解耦
通过集群消费的机制，我们可以实现针对相同 Topic ，不同消费者分组实现各自的业务逻辑。
比如说来了一个用户注册请求，主要业务是将新用户数据插入数据库。然后还有一些什么发邮箱给用户，发短信给用户，这些次要服务都是通过消息队列异步操作的，同时也实现了解耦，只需要干自己的事就行了。
scs可以使用相同 Topic ，不同消费者分组实现。
改造上面的demo
配置文件

spring:
  cloud:
    stream:
      rocketmq:
        binder:
          name-server: "127.0.0.1:9876"
      bindings:
        my-output:
          destination: topic1 #相当于RocketMQ中的topic
          content-type: application/json # 内容格式。这里使用 JSON
        my-input:
          destination: topic1 #相当于RocketMQ中的topic
          group:  group1 #消费组
          content-type: application/json # 内容格式。这里使用 JSON
          consumer:
            concurrency: 5 #实例数量
            broadcasting: false # 是否使用广播消费，默认为 false 使用集群消费，如果要使用广播消费值设成true。
        #集群消费：相同消费者下的实例平摊消息
        #广播消费：相同消费组下的每个实例都消费所有消息
        mail-input:
          destination: topic1 #相当于RocketMQ中的topic
          group:  group2 #消费组
          content-type: application/json # 内容格式。这里使用 JSON
          consumer:
            concurrency: 5 #实例数量
            broadcasting: false # 是否使用广播消费，默认为 false 使用集群消费，如果要使用广播消费值设成true。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
新增一个channel

@Component
public interface MailChannel {

    String INPUT = "mail-input";

    @Input(MailChannel.INPUT)
    SubscribableChannel input();
}
1
2
3
4
5
6
7
8
新增一个消费者

@Component
public class MailCustomer {
    @StreamListener(value = MailChannel.INPUT, condition = "headers['myheader']=='header1'")
    public void testCustomListener(@Payload String message) {
        //如果消息对象是引用类型，需要使用@Payload进行反序列化 这里String其实不用也可以
        System.out.println("邮箱消费||" + message);
    }
}
1
2
3
4
5
6
7
8
生产一条消息

可以看到两个消费组都消费了该消息

————————————————
版权声明：本文为CSDN博主「南城.南城」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_49558851/article/details/115489785