今早，女朋友给我发微信
她：宝贝，你要记住
她：我可是你女朋友，你相亲就亲，想抱就抱
她：不要老是问我，男生要主动一些
我：可是你上次报警可不是这么说的
Spring Boot 集成 Kafka 非常简单，我相信你们都会，但我还是想带你们回顾下；只需要进行以下几步即可完成 Spring Boot 与 Kafka 的集成
引入依赖
如果只是单纯的集成，不考虑其他功能，那么添加如下依赖即可
<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的版本在哪指定的？
添加配置
如果 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";
也不复杂，相信你们都能看懂
进行使用
分两点：消费消息 和 发送消息
消费消息 实现很简单
/**
* @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 步都完成后，即可启动应用进行测试了
消费消息
这个测试很简单，直接往 tp_qsl_order_cancel topic 中发送一条消息即可
点击 发送消息 后，控制台输出
消息正常消费，没有任何毛病
发送消息
我加了一个 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 源的情况是非常常见的，我们就以 2 个 Kafka 源为例，从其中一个源消费消息、向另一个源发送消息，该如何实现？其实也不难，按以下几步调整即可
配置文件调整
既然有 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 则不会启用默认配置
自定义配置 Kafka
针对每个 Kafka 源单独配置，配置内容比较固定
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());
}
}
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")
多源之间不要配重、不要配混
调整消息监听与消息发送
因为配置了多源，那么 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 源能正常使用就启用这些，哪些还不能使用就停用哪些，同时业务代码中也需要做适配调整。面对这个需求，你们说是不是不合理？所以你们能理解我的抵触了吧。但为了更好的演示，给甲方爸爸留下专业的印象，增加开关貌似是当下最合适的无奈之选，极不情愿的开启改造之旅
增加开关配置
在配置文件中增加开关配置，每个 Kafka 源有其独立的配置，有几个源就配置几个开关
spring:
kafka:
first:
enabled: true
...
second:
enabled: true
...
enabled 配置成 true 表示启用，false 表示停用
自定义配置适配开关
需要根据开关值来决定是否启用 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 源
消费消息与发送消息适配开关
消费端适配很简单
/**
* @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，我们启动应用后测试下
发送消息
直接 http 请求
http://localhost:8080/order/add?orderInfo=排除自动配置
日志显示发送成功
我们在看下 Topic tp_qsl_inventory_order_add 中消息
发送消息是没问题的
消费消息
往 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的答案！
Kafka 多源实现，大家需要掌握，至于启停配置化，大家就当看个热闹
但是启停配置化的实现（@ConditionalOnProperty），还是值得大家掌握的
Spring Boot 的条件注解非常多，在 Spring Boot 内部被广泛使用，感兴趣的可以查看：spring-boot-2.0.3源码篇 - @Configuration、Condition与@Conditional
如果不使用Spring Boot的自动配置，建议把对应的自动配置类排除掉
自动配置 与 手动配置 同时存在的话可能会产生冲突，就像文中的 KafkaProperties 多实例；直接排除可能会导致缺少某些功能，肯定是没有启用这些功能的依赖，细心去寻找依赖并启用即可
完整代码：spring-boot-kafka
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。