使用Spring cloud stream的事件驱动架构

Spring Cloud Stream

1. Spring Cloud Stream是一个由注解驱动的架构，允许开发人员在应用程序中轻松构建消息发布者和消费者，同时还运行开发人员抽象出正在使用的消息传递平台的实现细节；
2. Spring Cloud Stream架构；
   1. 发射器：source，spring注解接口，接收普通java对象，并将其序列化发送到通道；
   2. 通道：channel，队列(kafka中为主题)的抽象；
   3. 绑定器：binder，Spring Cloud Stream框架的一部分，负责与消息代理通信；
   4. 接收器：sink，从队列(kafka中为主题)中接收消息，并进行反序列化；               
   5. 简单消息生产者：
      1. 导入依赖包；

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

      2. 使用@EnableBinding(Source.class)注解标注引导类，告诉spring cloud stream希望将服务绑定到消息代理，注解中Source告诉spring cloud stream，该服务通过Source类中定义的通道与消息代理进行通信，记住，通道位于消息队列上；

      3. 消息发布：调用publishOrgChange方法发布消息；

         package com.thoughtmechanix.organization.events.source;
         
         import org.springframework.beans.factory.annotation.Autowired;
         import org.springframework.cloud.stream.messaging.Source;
         import org.springframework.messaging.support.MessageBuilder;
         import org.springframework.stereotype.Component;
         
         
         @Component
         public class SimpleSourceBean {
             private Source source;
         
         
             @Autowired
             public SimpleSourceBean(Source source){
                 this.source = source;
             }
         
             public void publishOrgChange(String action,String orgId){
                 OrganizationChangeModel change =  new OrganizationChangeModel(
                         OrganizationChangeModel.class.getTypeName(),
                         action,
                         orgId,
                         UserContext.getCorrelationId());
         
                 source.output().send(MessageBuilder.withPayload(change).build());
             }
         }
         

         的

      4. 将服务Source映射到kafka消息代理以及kafka中的消息主题；

         spring:
           cloud:
             stream:
               bindings:
                 output: #通道名称，映射Source类中的output通道
                     destination:  orgChangeTopic #消息要写入的消息队列或主题的名称
                     content-type: application/json #设置要发送的消息类型
               kafka:  #使用kafka作为服务中的消息总线
                 binder: 
                   zkNodes: localhost #zkNodesbrokers和告诉spring cloud stream kafka和zookeeper的网络位置
                   brokers: localhost
         
                 

      5. 编写消息消费者：

         1. 导入依赖项：

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

            房

         2. 使用@EnableBinding(Sink.class)修饰引导类，告诉服务器使用Sink中的通道来监听消息；

            package com.thoughtmechanix.licenses;
            
            import org.springframework.boot.SpringApplication;
            import org.springframework.boot.autoconfigure.SpringBootApplication;
            import org.springframework.cloud.stream.annotation.EnableBinding;
            import org.springframework.cloud.stream.annotation.StreamListener;
            import org.springframework.cloud.stream.messaging.Sink;
            
            @SpringBootApplication
            @EnableBinding(Sink.class)
            public class Application {
            
                @StreamListener(Sink.INPUT)
                public void loggerSink(OrganizationChangeModel orgChange) {
                    logger.debug("Received an event for organization id {}", orgChange.getOrganizationId());
                }
            
                public static void main(String[] args) {
                    SpringApplication.run(Application.class, args);
                }
            }
            

            的

         3. 将消费者映射到kafka消息代理；

            spring:
              cloud:
                stream:
                  bindings:
                    input: #通道名称，映射Sink类中的input通道
                      destination: orgChangeTopic
                      content-type: application/json
                      group: licensingGroup
                  kafka:
                    binder:
                      zkNodes: localhost
                      brokers: localhost
            

            注意：group消费组属性，通过有多个服务，每个服务有多个实例在监听消息队列，属于同一组的多个实例中，只有一个实例会消费和处理消息。

         4. 自定义通道：

            1. 定义消费者通道，使用@Input注解，返回一个SubscribableChannel的方法；

               package com.thoughtmechanix.licenses.events;
               
               
               import org.springframework.cloud.stream.annotation.Input;
               import org.springframework.messaging.SubscribableChannel;
               
               public interface CustomChannels {
                   @Input("inboundOrgChanges")
                   SubscribableChannel orgs();
               }
               

            2. 定义发送者通道，使用@OutPutChannel注解，返回一个MeaasgeChannelDE FANGFA ;

            3. 修改消费者配置，映射到Kafka主题，发送者配置的修改与之类似；

               spring:
                 cloud:
                   stream:
                     bindings:
                       inboundOrgChanges:  #自定义通道
                         destination: orgChangeTopic
                         content-type: application/json
                         group: licensingGroup
                     kafka:
                       binder:
                         zkNodes: localhost
                         brokers: localhost
               
               

               的

            4. 修改消费者引导类出@EnableBinding(CustomeChannels.class)，发布者出引导类修改与之类似，修改消费者监听器@StreamListener("inboundOrgChanges")，里面为通道名称。