SpringBoot支持Kafka多源配置的同时还要支持启停配置化，是真的会玩

开心一刻

今早，女朋友给我发微信

她：宝贝，你要记住

她：我可是你女朋友，你相亲就亲，想抱就抱

她：不要老是问我，男生要主动一些

我：可是你上次报警可不是这么说的

基础回顾

Spring Boot 集成 Kafka 非常简单，我相信你们都会，但我还是想带你们回顾下；只需要进行以下几步即可完成 Spring Boot 与 Kafka 的集成

1. 引入依赖

   如果只是单纯的集成，不考虑其他功能，那么添加如下依赖即可

   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.7.18</version>
   </parent>
   
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.kafka</groupId>
           <artifactId>spring-kafka</artifactId>
       </dependency>
   </dependencies>
   

   Spring Boot 并没有提供 starter 的方式来集成 Kafka，不要一根筋的去找 starter

   如果还需要 web 功能，则可以像如下一样添加依赖

   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.7.18</version>
   </parent>
   
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.kafka</groupId>
           <artifactId>spring-kafka</artifactId>
       </dependency>
   </dependencies>
   

   依赖就是如此简单；扯个题外问题

   spring-kafka 的版本在哪指定的？

2. 添加配置

   如果 Kafka 未开启认证，那配置可以非常简单

   spring:
     kafka:
       bootstrap-servers: 192.168.0.87:9092,192.168.0.88:9092,192.168.0.89:9092
   

   但实际使用中，往往会开启认证，并对 consumer 做定制化配置，配置往往类似如下

   spring:
     kafka:
       bootstrap-servers: 192.168.0.87:9092,192.168.0.88:9092,192.168.0.89:9092
       consumer:
         # 自动提交消费位移
         enable-auto-commit: false
         # 偏移量初始位置
         auto-offset-reset: latest
         # 一次拉取记录最大数
         max-poll-records: 5
         properties:
           security.protocol: SASL_PLAINTEXT
           sasl.mechanism: PLAIN
           #sasl.mechanism: SCRAM-SHA-256
           #username、password需要调整成实际值
           sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="username" password="password";
           #sasl.jaas.config: org.apache.kafka.common.security.scram.ScramLoginModule required username="username" password="password";
       listener:
         ack-mode: manual
       producer:
         properties:
           security.protocol: SASL_PLAINTEXT
           sasl.mechanism: PLAIN
           #sasl.mechanism: SCRAM-SHA-256
           #username、password需要调整成实际值
           sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="username" password="password";
           #sasl.jaas.config: org.apache.kafka.common.security.scram.ScramLoginModule required username="username" password="password";
   

   也不复杂，相信你们都能看懂

3. 进行使用

   分两点：消费消息 和 发送消息

   消费消息 实现很简单

   /**
    * @author: 青石路
    */
   @Component
   public class KafkaConsumer {
   
       private static final Logger log = LoggerFactory.getLogger(KafkaConsumer.class);
   
       @KafkaListener(topics = "tp_qsl_order_cancel", groupId = "gid_qsl_order_cancel")
       public void listenOrder(String message, Acknowledgment acknowledgment) {
           try {
               log.info("收到kafka message: {}", message);
               // TODO 业务处理
           } finally {
               acknowledgment.acknowledge();
           }
       }
   }
   

   监听的 topic 是 tp_qsl_order_cancel，消费者组指定为 gid_qsl_order_cancel；这样，消费监听就算完成了

   发送消息 实现同样简单，注入 KafkaTemplate，然后调用其 send 方法即可

   /**
    * @author: 青石路
    */
   @Component
   public class KafkaSender {
   
       private static final Logger log = LoggerFactory.getLogger(KafkaSender.class);
   
       @Resource
       private KafkaTemplate<String, String> kafkaTemplate;
   
       public void send(String topic, String msg) {
           kafkaTemplate.send(topic, msg).addCallback(
                   success -> {
                       if (success != null) {
                           log.info("消息发送成功: Topic={}, Partition={}, Offset={}",
                                   success.getRecordMetadata().topic(), success.getRecordMetadata().partition(), success.getRecordMetadata().offset());
                       }
                   },
                   failure -> {
                       log.error("消息发送失败：", failure.getCause());
                   }
           );
       }
   }
   

   KafkaTemplate 提供了多个 send 方法

   

   我们可以按需选择

上面 3 步都完成后，即可启动应用进行测试了

1. 消费消息

   这个测试很简单，直接往 tp_qsl_order_cancel topic 中发送一条消息即可

   

   点击 发送消息 后，控制台输出

   

   消息正常消费，没有任何毛病

2. 发送消息

   我加了一个 OrderController

   /**
    * @author: 青石路
    */
   @RestController
   @RequestMapping("order")
   public class OrderController {
   
       @Resource
       private KafkaSender kafkaSender;
   
       @GetMapping("add")
       public String add(String orderInfo) {
           // TODO 订单业务处理
           // 下发消息到库存
           kafkaSender.send("tp_qsl_inventory_order_add", orderInfo);
           return "下单成功";
       }
   }
   

   便于测试消息发送；直接发起 http 请求

   http://localhost:8080/order/add?orderInfo=订单完整信息
   

   然后就可以去 tp_qsl_inventory_order_add topic 中看消息是否发送成功

   

   消息正常发送，也没有任何毛病

至此，Spring Boot 集成 Kafka 就算大功告成了；如此简单，相信你们都能轻松拿捏

Kafka 多源

上述只讲了单 Kafka 源的情况，也就是 消费消息 与 发送消息 针对的是同个 Kafka 源；但实际工作中，同个项目连接多个 Kafka 源的情况是非常常见的，我们就以 2 个 Kafka 源为例，从其中一个源消费消息、向另一个源发送消息，该如何实现？其实也不难，按以下几步调整即可

1. 配置文件调整

   既然有 2 个 Kafka 源，那么我们的配置文件就需要配置 2 个，类似如下

   spring:
     kafka:
       first:
         bootstrap-servers: 192.168.0.87:9092,192.168.0.88:9092,192.168.0.89:9092
         consumer:
           # 自动提交消费位移
           enable-auto-commit: false
           # 偏移量初始位置
           auto-offset-reset: latest
           # 一次拉取记录最大数
           max-poll-records: 5
           # properties:
             # security.protocol: SASL_PLAINTEXT
             # sasl.mechanism: PLAIN
             #sasl.mechanism: SCRAM-SHA-256
             #username、password需要调整成实际值
             # sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="username" password="password";
             #sasl.jaas.config: org.apache.kafka.common.security.scram.ScramLoginModule required username="username" password="password";
         listener:
           ack-mode: manual
       second:
         bootstrap-servers: 192.168.0.90:9092
         #producer:
           #properties:
             #security.protocol: SASL_PLAINTEXT
             #sasl.mechanism: PLAIN
             #sasl.mechanism: SCRAM-SHA-256
             #username、password需要调整成实际值
             #sasl.jaas.config: org.apache.kafka.common.security.plain.PlainLoginModule required username="username" password="password";
             #sasl.jaas.config: org.apache.kafka.common.security.scram.ScramLoginModule required username="username" password="password";
   

   这里的 first 和 second 不是固定的，你们想怎么命名就怎么命名；既然这么灵活，那 Spring Boot 肯定是不支持的，那么如上配置，Spring Boot 是识别不了的，相当于没配，此时去启动应用，Spring Boot 会启用默认配置去连接 localhost:9092

   

   所以我们需要自定义配置 Kafka，而一旦我们进行了自定义，那么 Spring Boot 则不会启用默认配置

2. 自定义配置 Kafka

   针对每个 Kafka 源单独配置，配置内容比较固定

   1. FirstKafkaConfig

      /**
       * 第一个Kafka配置
       * @author: 青石路
       */
      @Configuration
      public class FirstKafkaConfig {
      
          @ConfigurationProperties(prefix = "spring.kafka.first")
          @Bean("firstKafkaProperties")
          public KafkaProperties firstKafkaProperties() {
              return new KafkaProperties();
          }
      
          @Bean("firstKafkaTemplate")
          public KafkaTemplate<String, String> firstKafkaTemplate() {
              return new KafkaTemplate<>(firstProducerFactory());
          }
      
          @Bean("firstKafkaListenerContainerFactory")
          public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> fisrtKafkaListenerContainerFactory() {
              ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
              factory.setConsumerFactory(firstConsumerFactory());
              factory.getContainerProperties().setAckMode(firstKafkaProperties().getListener().getAckMode());
              return factory;
          }
      
          @Bean("firstConsumerFactory")
          public ConsumerFactory<String, String> firstConsumerFactory() {
              return new DefaultKafkaConsumerFactory<>(firstKafkaProperties().buildConsumerProperties());
          }
      
          @Bean("firstProducerFactory")
          public DefaultKafkaProducerFactory<String, String> firstProducerFactory() {
              return new DefaultKafkaProducerFactory<>(firstKafkaProperties().buildProducerProperties());
          }
      }
      

   2. SecondKafkaConfig

      /**
       * 第二个Kafka配置
       * @author: 青石路
       */
      @Configuration
      public class SecondKafkaConfig {
      
          @ConfigurationProperties(prefix = "spring.kafka.second")
          @Bean("secondKafkaProperties")
          public KafkaProperties secondKafkaProperties() {
              return new KafkaProperties();
          }
      
          @Bean("secondKafkaTemplate")
          public KafkaTemplate<String, String> secondKafkaTemplate() {
              return new KafkaTemplate<>(secondProducerFactory());
          }
      
          @Bean("secondKafkaListenerContainerFactory")
          public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> fisrtKafkaListenerContainerFactory() {
              ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
              factory.setConsumerFactory(secondConsumerFactory());
              return factory;
          }
      
          @Bean("secondConsumerFactory")
          public ConsumerFactory<String, String> secondConsumerFactory() {
              return new DefaultKafkaConsumerFactory<>(secondKafkaProperties().buildConsumerProperties());
          }
      
          @Bean("secondProducerFactory")
          public DefaultKafkaProducerFactory<String, String> secondProducerFactory() {
              return new DefaultKafkaProducerFactory<>(secondKafkaProperties().buildProducerProperties());
          }
      }
      

   重点在

   @ConfigurationProperties(prefix = "spring.kafka.first")

   @ConfigurationProperties(prefix = "spring.kafka.second")

   多源之间不要配重、不要配混

3. 调整消息监听与消息发送

   因为配置了多源，那么 KafkaListenerContainerFactory 也对应配置了多个，所以我们要指定用哪个 KafkaListenerContainerFactory 来创建消息监听器

   @KafkaListener(topics = "tp_qsl_order_cancel", groupId = "gid_qsl_order_cancel")
   
   // 调整成
   
   @KafkaListener(topics = "tp_qsl_order_cancel", groupId = "gid_qsl_order_cancel", containerFactory = "firstKafkaListenerContainerFactory")
   

   消费消息 端就算调整完成；同理，KafkaTemplate 也配置了多个，那么发送消息的时候也需要指定用哪个 KafkaTemplate 来发送

   @Resource
   private KafkaTemplate<String, String> kafkaTemplate;
   
   // 调整成
   
   private KafkaTemplate<String, String> kafkaTemplate;
   @Autowired
   @Qualifier("secondKafkaTemplate")
   public void setKafkaTemplate(KafkaTemplate<String, String> kafkaTemplate) {
       this.kafkaTemplate = kafkaTemplate;
   }
   

   发送消息 端也就调整完成

都调整完成后，我们启动应用，会发现启动失败，并提示如下信息

这特喵的，跟预想的不一样吖

遇到问题先不要慌，我们仔细看下提示信息，我给你们翻译一下

KafkaAnnotationDrivenConfiguration 构造方法需要一个 KafkaProperties 实例，但在 Spring 容器中找到了 3 个，它懵圈了，不知道该使用哪一个

可以通过 @Primary 提高实例的优先级，或者使用 @Qualifier 明确指定使用哪个实例

所以处理方式就来了，使用 @Primary 来提高某个 KafkaProperties 实例的优先级，KafkaAnnotationDrivenConfiguration 就不会懵圈了，会使用优先级高的 KafkaProperties 实例

因为 KafkaAnnotationDrivenConfiguration 不是我们写的，没法通过 @Qualifier 明确指定

我们直接提高 firstKafkaProperties 的优先级

@ConfigurationProperties(prefix = "spring.kafka.first")
@Bean("firstKafkaProperties")
@Primary
public KafkaProperties firstKafkaProperties() {
    return new KafkaProperties();
}

再启动应用，发现正常启动了；你们就可以进行 消费消息 和 发送消息 测试了，我就不演示了，反正我测试都是通过的，不信？不信就不信，你能把我怎么样嘛

启停配置化

Kafka 不管是单源还是多源，应用进行集成，都是非常合理的需求，我们开发做对应的实现也是应该的；但如下这个需求我多少是有点抵触的

客户方的环境有诸多约束、限制，权限管控非常严，还有各种防火墙，需要各种申请流程，非常耗时；项目分多个应用，应用之间存在交互（Kafka 是方式之一），每个应用的交付时间不一样，自然在客户环境的演示时间也不一样，所以为了演示不受 Kafka 的限制，需要给每个 Kafka 源增加一个开关配置，通过开关来分别控制每个 Kafka 源的启停

这里的启停指的是 启用 与 停用；演示的时候，哪些 Kafka 源能正常使用就启用这些，哪些还不能使用就停用哪些，同时业务代码中也需要做适配调整。面对这个需求，你们说是不是不合理？所以你们能理解我的抵触了吧。但为了更好的演示，给甲方爸爸留下专业的印象，增加开关貌似是当下最合适的无奈之选，极不情愿的开启改造之旅

1. 增加开关配置

   在配置文件中增加开关配置，每个 Kafka 源有其独立的配置，有几个源就配置几个开关

   spring:
     kafka:
       first:
         enabled: true
         ...
       second:
         enabled: true
         ...
   

   enabled 配置成 true 表示启用，false 表示停用

2. 自定义配置适配开关

   需要根据开关值来决定是否启用 FirstKafkaConfig 和 SecondKafkaConfig，Spring Boot 正好提供了一个具有该功能的注解：ConditionalOnProperty，直接安排上

   /**
    * 第一个Kafka配置
    * @author: 青石路
    */
   @Configuration
   @ConditionalOnProperty(name = "spring.kafka.first.enabled", havingValue = "true")
   public class FirstKafkaConfig {
       ...
   
   /**
    * 第二个Kafka配置
    * @author: 青石路
    */
   @Configuration
   @ConditionalOnProperty(name = "spring.kafka.second.enabled", havingValue = "true")
   public class SecondKafkaConfig {
       ...
   

   这样就实现了通过开关来 启停 Kafka 源

3. 消费消息与发送消息适配开关

   消费端适配很简单

   /**
    * @author: 青石路
    */
   @Component
   @ConditionalOnProperty(name = "spring.kafka.first.enabled", havingValue = "true")
   public class KafkaConsumer {
       ...
   

   发送端适配则有点不一样，方式有多种，我提供一种；修改 KafkaSender，改 2 处即可

   KafkaTemplate 调整成非强制依赖，将 @Autowired 的 required 设置成 false

   @Autowired
   @Qualifier("secondKafkaTemplate")
   public void setKafkaTemplate(KafkaTemplate<String, String> kafkaTemplate) {
       this.kafkaTemplate = kafkaTemplate;
   }
   
   // 调整成
   
   @Autowired(required = false)
   @Qualifier("secondKafkaTemplate")
   public void setKafkaTemplate(KafkaTemplate<String, String> kafkaTemplate) {
       this.kafkaTemplate = kafkaTemplate;
   }
   

   使用 KafkaTemplate 时做 null 判断

   public void send(String topic, String msg) {
       kafkaTemplate.send(topic, msg).addCallback(
               success -> {
                   if (success != null) {
                       log.info("消息发送成功: Topic={}, Partition={}, Offset={}",
                               success.getRecordMetadata().topic(), success.getRecordMetadata().partition(), success.getRecordMetadata().offset());
                   }
               },
               failure -> {
                   log.error("消息发送失败：", failure.getCause());
               }
       );
   }
   
   // 调整成
   
   public void send(String topic, String msg) {
       if (kafkaTemplate == null) {
           log.warn("未启用secondKafka，不发送消息");
           return;
       }
       kafkaTemplate.send(topic, msg).addCallback(
               success -> {
                   if (success != null) {
                       log.info("消息发送成功: Topic={}, Partition={}, Offset={}",
                               success.getRecordMetadata().topic(), success.getRecordMetadata().partition(), success.getRecordMetadata().offset());
                   }
               },
               failure -> {
                   log.error("消息发送失败：", failure.getCause());
               }
       );
   }
   

至此改造就算完成；开关都为 true 的情况下，效果与未加开关前的多源是一致的，也就是正常的，我已经测过了，你们不放心的话自己再去测试一下；开关都为 false 时，相当于没注册消费监听器，也就相当于没有消费者，那么往 tp_qsl_order_cancel topic 中发消息，是没有消费者消费消息的，那么控制台就不会有任何输出，同理，此时的 KafkaTemplate 是没有注册成功的（也就是 null），发起 http 请求

http://localhost:8080/order/add?orderInfo=大订单

控制台输出如下

正是我们想要的效果，说明都为 false 的情况也是正确的；接下来我们看下 false、true 的情况

好家伙，直接启动失败！但这个问题我们前面碰到过，那么如何处理呢？用 @Primary 标记 secondKafkaProperties ？假设我们这么做了，那开关都为 true 的情况下，KafkaProperties 实例岂不是有多个 Primary，Spring Boot 又会懵圈，不知道该使用哪个 KafkaProperties 实例，显然这种方式行不通；我们把问题拓展下，多个 KafkaProperties 实例存在的情况下，需要动态指定一个 Primary，但不能是 Spring Boot 自动配置的那个，即

spring.kafka-org.springframework.boot.autoconfigure.kafka.KafkaProperties

除了这个，随便给哪个 KafkaProperties 实例指定成 Primary 都是没问题的，因为我们的业务代码中都明确指定了使用的是我们自定义的 kafka，所以我们需要在 Bean 实例化之前修改某个 KafkaProperties 的 BeanDefinition，设置其 Primary 为 true；实现方式有很多，我这里提供一种：BeanFactoryPostProcessor

/**
 * @author: 青石路
 */
@Component
public class KafkaPrimaryProcessor implements BeanFactoryPostProcessor {

    private static final Logger log = LoggerFactory.getLogger(KafkaPrimaryProcessor.class);

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String[] beanNames = beanFactory.getBeanNamesForType(KafkaProperties.class);
        if (beanNames.length <= 1) {
            return;
        }
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            // springboot的自动配置
            if (beanName.contains(KafkaProperties.class.getName())) {
                continue;
            }
            log.info("多KafkaProperties，指定primary[{}]", beanName);
            beanDefinition.setPrimary(true);
            return;
        }
    }
}

这个代码相信你们都能看懂，会从多个 KafkaProperties BeanDefinition 中取第一个（除了自动配置的），设置其 Primary 为 true，所以我们还需要调整下 firstKafkaProperties，拿掉其 @Primary

@ConfigurationProperties(prefix = "spring.kafka.first")
@Bean("firstKafkaProperties")
@Primary
public KafkaProperties firstKafkaProperties() {
    return new KafkaProperties();
}

// 调整成

@ConfigurationProperties(prefix = "spring.kafka.first")
@Bean("firstKafkaProperties")
public KafkaProperties firstKafkaProperties() {
    return new KafkaProperties();
}

这么调整之后，无论是有几个 Kafka 源，以及如何启停这些源，都能正常运转，是不是很优秀，值得鼓掌！

话说，需求至此已经算完美实现了，可以完结了，但作为一个开发，尤其是一个有追求的开发，还有一个疑点未得到解决，心里始终不舒坦，是什么疑点呢，我们继续往下看

排除自动配置

既然是我们自定义配置 Kafka，不再依赖 Spring Boot 的自动配置，我们是不是可以排除掉 Spring Boot 的 Kafka 自动配置？理论上来说是可行的，那就干呗；直接排除掉 KafkaAutoConfiguration.class

/**
 * @author: 青石路
 */
@SpringBootApplication(exclude = {KafkaAutoConfiguration.class})
public class KafkaApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaApplication.class, args);
    }
}

既然排除了自动配置，那么也就不需要指定 KafkaProperties 的 Primary 了，KafkaPrimaryProcessor 直接删掉，其他不用调整；将开关都设置成 true，我们启动应用后测试下

1. 发送消息

   直接 http 请求

   http://localhost:8080/order/add?orderInfo=排除自动配置
   

   日志显示发送成功

   

   我们在看下 Topic tp_qsl_inventory_order_add 中消息

   

   发送消息是没问题的

2. 消费消息

   往 Topic tp_qsl_order_cancel 中发送消息

   

   点击 发送消息 后，发现控制台并没有任何输出！！！

   

   先别慌，我们冷静分析下，控制台没有任何输出说明消费者没注册成功，也就是 @KafkaListener 没生效，为什么没生效，肯定是没有被解析，谁解析它呢，KafkaListener 中应该有说明

   

   已经描述的很清楚

   通过注册 KafkaListenerAnnotationBeanPostProcessor 来处理 KafkaListener 注解

   可以手动注册 KafkaListenerAnnotationBeanPostProcessor，也可以通过 EnableKafka 注解来注册

   EnableKafka 方便点，我们使用它

   /**
    * @author: 青石路
    */
   @SpringBootApplication(exclude = {KafkaAutoConfiguration.class})
   @EnableKafka
   public class KafkaApplication {
   
       public static void main(String[] args) {
           SpringApplication.run(KafkaApplication.class, args);
       }
   }
   

   重新启动应用，会发现控制台有如下输出

   

   消费消息也正常了；因为重启应用了，保险起见，发送消息最好再测一次，记得测！！！

至此，心中疑点得以解决，如此才算完美解决！

Tips：

跟进 KafkaAutoConfiguration，它有如下代码

@Import({ KafkaAnnotationDrivenConfiguration.class, KafkaStreamsAnnotationDrivenConfiguration.class })

跟进 KafkaAnnotationDrivenConfiguration，其最下面有如下代码

@Configuration(proxyBeanMethods = false)
@EnableKafka
@ConditionalOnMissingBean(name = KafkaListenerConfigUtils.KAFKA_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME)
static class EnableKafkaConfiguration {

}

这里使用了 @EnableKafka，这也是为什么自动配置（KafkaAutoConfiguration）能解析 @KafkaListener 的答案！

总结

1. Kafka 多源实现，大家需要掌握，至于启停配置化，大家就当看个热闹

   但是启停配置化的实现（@ConditionalOnProperty），还是值得大家掌握的

   Spring Boot 的条件注解非常多，在 Spring Boot 内部被广泛使用，感兴趣的可以查看：spring-boot-2.0.3源码篇 - @Configuration、Condition与@Conditional

2. 如果不使用Spring Boot的自动配置，建议把对应的自动配置类排除掉

   自动配置 与 手动配置 同时存在的话可能会产生冲突，就像文中的 KafkaProperties 多实例；直接排除可能会导致缺少某些功能，肯定是没有启用这些功能的依赖，细心去寻找依赖并启用即可

3. 完整代码：spring-boot-kafka