搭建大型分布式服务（四十四）SpringBoot 无代码侵入实现多Kafka数据源：单分区提升至十万级消费速度！

本文主要是介绍搭建大型分布式服务（四十四）SpringBoot 无代码侵入实现多Kafka数据源：单分区提升至十万级消费速度！，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

系列文章目录

文章目录

系列文章目录
前言
- - 一、本文要点
  - 二、开发环境
  - 三、原项目
  - 四、修改项目
  - 五、测试一下
  - 五、小结

前言

在过去的一段时间里，我们利用了AI大模型写了一个多线程并发框架，那么，我们怎样集成到Kafka组件里，让消费速度提升N倍呢？

《AI大模型编写多线程并发框架（六十一）：从零开始搭建框架》
《AI大模型编写多线程并发框架（六十二）：限流和并发度优化》
《AI大模型编写多线程并发框架（六十三）：监听器优化·上》
《AI大模型编写多线程并发框架（六十四）：监听器优化·下》
《AI大模型编写多线程并发框架（六十五）：发布和应用》

国籍惯例，先上源码：Github源码

一、本文要点

本文将介绍通过封装一个starter，来实现多kafka数据源的配置，通过通过源码，可以学习以下特性。系列文章完整目录

SpringBoot 整合多个kafka数据源
SpringBoot 批量消费kafka消息
SpringBoot 优雅地启动或停止消费kafka
SpringBoot kafka本地单元测试（免集群）
SpringBoot 利用map注入多份配置
SpringBoot BeanPostProcessor 后置处理器使用方式
SpringBoot 将自定义类注册到IOC容器
SpringBoot 注入bean到自定义类成员变量
Springboot 取消限定符
SpringBoot 支持消费protobuf类型的kafka消息
SpringBoot Aware设计模式
SpringBoot 获取kafka消息中的topic、offset、partition、header等参数
SpringBoot 使用任意生产者发送kafka消息
SpringBoot 配置任意数量的kafka生产者
SpringBoot Kafka单次batch消息内并发处理

二、开发环境

jdk 1.8
maven 3.6.2
springboot 2.4.3
kafka-client 2.6.6
idea 2020
mmc-juc 1.1

三、原项目

1、接前文，我们已经发布了Kafka组件到中央仓库，所有开发者都可以下载使用本组件。虽然本组件支持批量消费Kafka消息，但是毕竟它是串行顺序处理的，尤其涉及高IO耗时调用时，比如消费Kafka，然后读写DB多表操作这种场景，会使消费速度下降。能否并发处理这些Kafka消息呢？

答案是可以的、但我们要升级和优化一下。

四、修改项目

1、新增ContainerConfig接口类，用于获取多线程任务容器配置，便于后续使用Apollo、Disconf、Consul等配置中心。

public interface ContainerConfig {/*** Get the execute rate.** @return rate*/int getRate();/*** Get the max task count for per thread.** @return max count*/int getThreshold();/*** The max thread count, default is numbers of processor.* @return count*/default int getParallelism() {return Runtime.getRuntime().availableProcessors();}
}

2、修改MmcMultiKafkaProperties配置类，增加容器配置；

@ToString
@Data
@ConfigurationProperties(prefix = "spring")
public class MmcMultiKafkaProperties {// 省略其他代码/*** MmcKafkaProperties.*/@Datastatic class MmcKafkaProperties {// 省略其他代码/*** 并发设置.*/private Container container = new Container();}@Datapublic static class Container implements ContainerConfig {/*** 是否启用多线程消费.*/private boolean enabled = true;/** 消费消息的速率（每秒接收的记录数），默认值为1000.*/private int rate = 1000;/** 最小批次数量，默认为2.*/private int threshold = 2;/** 设置并行度，默认值为可用处理器数量.*/private int parallelism = Runtime.getRuntime().availableProcessors();}
}

3、修改MmcMultiConsumerAutoConfiguration配置类，主要是增加inputer的初始化方法，用于后续构建多线程任务容器实例。


public interface MmcInputer {// 省略其他代码/*** 初始化kafka容器.*/void init();
}@Slf4j
@Configuration
@EnableConfigurationProperties(MmcMultiKafkaProperties.class)
@ConditionalOnProperty(prefix = "spring.kafka", value = "enabled", matchIfMissing = true)
public class MmcMultiConsumerAutoConfiguration extends BaseConsumerConfiguration {// 省略其他代码@Beanpublic MmcKafkaInputerContainer mmcKafkaInputerContainer(MmcKafkaProcessorFactory factory,MmcKafkaBeanPostProcessor beanPostProcessor) throws Exception {// 省略其他代码// 逐个遍历，并生成consumerfor (Map.Entry<String, MmcMultiKafkaProperties.MmcKafkaProperties> entry : kafkas.entrySet()) {// 省略其他代码// 是否开启if (properties.isEnabled() && CommonUtil.isNotBlank(properties.getGroupId())) {// 省略其他代码// 设置容器inputer.setContainer(container);inputer.setName(name);inputer.setProperties(properties);inputer.init(); // 增加初始化// 省略其他代码}}return new MmcKafkaInputerContainer(inputers);}
}

4、由于增加了inputer增加了init方法，所以超级父类KafkaAbstractProcessor也增加一个默认实现。

@Slf4j
@Setter
public abstract class KafkaAbstractProcessor<T> implements MmcInputer {// 省略其他代码@Overridepublic void init() {}
}

5、新增MmcKafkaParallelAbstractProcessor并发处理类，根据多线程并发框架mmc-juc的特性，配置初始化多线程任务容器，并保留很多回调函数，方便子类覆盖重写。


@Slf4j
@Setter
public abstract class MmcKafkaParallelAbstractProcessor<T, R> extends MmcKafkaAbstractProcessor<T> {/*** taskExecutor.*/protected MmcTaskExecutor<T, R> taskExecutor;/*** init.*/public void init() {ContainerConfig config = properties.getContainer();this.taskExecutor = MmcTaskExecutor.<T, R>builder().taskProcessor(this::handelBatchDatas).threshold(config.getThreshold()).rateLimiter(buildRateLimiter(config.getRate())).taskMerger(this::mergeResult).forkJoinPoolConcurrency(config.getParallelism()).build();}@Overrideprotected void dealMessage(List<T> datas) throws ExecutionException, InterruptedException {if (properties.getContainer().isEnabled()) {// 开启并发处理R result = taskExecutor.execute(MmcTask.<T, R>builder().taskSource(datas).taskName(getTaskName(datas)).build());dealMessageCallBack(result);} else {// 同步处理R result = handelBatchDatas(datas);dealMessageCallBack(result);}}/*** 合并小任务结果（默认不合并）.** @param left 左边处理结果* @param right 右边处理结果* @return 合并后的结果*/protected R mergeResult(R left, R right) {return null;}/*** 构建速率限制器.** @param rate qps* @return 速率限制器*/protected RateLimiter buildRateLimiter(int rate) {return new TokenBucket(rate, rate);}/*** 当所有消息处理完后，会调用该方法.** @param result 处理结果*/protected void dealMessageCallBack(R result) {// default null}/*** 获取任务名称.*/protected String getTaskName(List<T> datas) {return name;}/*** 真正处理消息的方法.** @param datas 待处理消息* @return 小任务处理完的结果*/protected abstract R handelBatchDatas(List<T> datas);}

五、测试一下

1、引入mmc-juc需要的jar。参考文章：kafka单元测试

       <dependency><groupId>io.github.vipjoey</groupId><artifactId>mmc-juc</artifactId><version>1.1</version></dependency>

2、增加并发消费者配置，生产者配置不变。

## json消息消费者
spring.kafka.five.enabled=true
spring.kafka.five.consumer.bootstrapServers=${spring.embedded.kafka.brokers}
spring.kafka.five.topic=mmc-topic-five
spring.kafka.five.group-id=group-consumer-five
spring.kafka.five.processor=fiveProcessor
spring.kafka.five.duplicate=true
spring.kafka.five.snakeCase=false
spring.kafka.five.consumer.auto-offset-reset=latest
spring.kafka.five.consumer.max-poll-records=10
spring.kafka.five.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.five.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
## 并发配置
spring.kafka.five.container.threshold=2
spring.kafka.five.container.rate=1000
spring.kafka.five.container.parallelism=8## json消息生产者
spring.kafka.five.enabled=true
spring.kafka.five.producer.name=fiveKafkaSender
spring.kafka.five.producer.bootstrap-servers=${spring.embedded.kafka.brokers}
spring.kafka.five.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.five.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

3、编写测试类。


@Slf4j
@Service("fiveProcessor")
public class FiveProcessor extends MmcKafkaParallelAbstractProcessor<ParalleMsg, Void> {@Overrideprotected Void handelBatchDatas(List<ParalleMsg> datas) {datas.forEach(x -> {log.info("handelBatchDatas one: {}", x);});return null;}
}@Slf4j
@ActiveProfiles("dev")
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = {MmcMultiProducerAutoConfiguration.class, MmcMultiConsumerAutoConfiguration.class,FiveProcessor.class})
@TestPropertySource(value = "classpath:application-paralle.properties")
@DirtiesContext
@EmbeddedKafka(partitions = 1, brokerProperties = {"listeners=PLAINTEXT://localhost:9092", "port=9092"},topics = {"${spring.kafka.five.topic}"})
public class KafkaParalleMessageTest {@Value("${spring.kafka.five.topic}")private String fiveTopic;@Resource(name = "fiveKafkaSender")private MmcKafkaSender mmcKafkaSender;@Testvoid testDealMessage() throws Exception {Thread.sleep(2 * 1000);// 模拟生产数据produceMessage();Thread.sleep(10 * 1000);}void produceMessage() {for (int i = 0; i < 10; i++) {DemoMsg msg = new DemoMsg();msg.setRoutekey("routekey" + i);msg.setName("name" + i);msg.setTimestamp(System.currentTimeMillis());String json = JsonUtil.toJsonStr(msg);mmcKafkaSender.sendStringMessage(fiveTopic, "aaa", json);}}
}