文章出處shenyifengtk.github.io 轉載請註明
本文由來，有一個需求要在瀏覽器輸入Kafka topic，消費組提交後自動開啟消費，這個做起來比較簡單，同事使用了Kafka 驅動包很快速完成這個。我突然想到能不能通過Spring Kafka自身框架完成這個功能，不使用底層驅動包來自做呢。而引出分析整個Spring Kafka 如何實現註解消費資訊，呼叫方法的。並且最後通過幾個簡單的程式碼完成上面小需求。
原始碼解析
EnableKafka入口
kafka 模組的開始先從@EnableKafka 上@Import(KafkaListenerConfigurationSelector.class)
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[] { KafkaBootstrapConfiguration.class.getName() };
}接著繼續看下KafkaBootstrapConfiguration類
public class KafkaBootstrapConfiguration implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
if (!registry.containsBeanDefinition(
KafkaListenerConfigUtils.KAFKA_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME)) {
registry.registerBeanDefinition(KafkaListenerConfigUtils.KAFKA_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME,
new RootBeanDefinition(KafkaListenerAnnotationBeanPostProcessor.class));
}
if (!registry.containsBeanDefinition(KafkaListenerConfigUtils.KAFKA_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME)) {
registry.registerBeanDefinition(KafkaListenerConfigUtils.KAFKA_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME,
new RootBeanDefinition(KafkaListenerEndpointRegistry.class));
}
}
}使用BeanDefinitionRegistry 將class 轉換成beanDefinition，註冊到beanDefinitionMap 容器中，容器會統一將Map Class全部進行例項化，其實就是將這個交給Spring 初始化。
KafkaListenerAnnotationBeanPostProcessor 解析
下面看下kafka核心處理類KafkaListenerAnnotationBeanPostProcessor 如何解析@KafkaListener 註解，postProcessAfterInitialization 在bean 例項化後呼叫方法，對bean 進行增強。
public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
if (!this.nonAnnotatedClasses.contains(bean.getClass())) {
//如果此時bean可能是代理類，則獲取原始class ，否則直接class
Class<?> targetClass = AopUtils.getTargetClass(bean);
//這時類上去找@KafkaListener ，因為在class 上可能出現多種複雜情況，這個方法封裝一系列方法能包裝找到註解
//這裡可能存在子父類同時使用註解，所有隻有找到一個就進行對應方法處理
Collection<KafkaListener> classLevelListeners = findListenerAnnotations(targetClass);
final boolean hasClassLevelListeners = classLevelListeners.size() > 0;
final List<Method> multiMethods = new ArrayList<>();
//從方法上找註解，找到方法放到map中，Method 當作key
Map<Method, Set<KafkaListener>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
(MethodIntrospector.MetadataLookup<Set<KafkaListener>>) method -> {
Set<KafkaListener> listenerMethods = findListenerAnnotations(method);
return (!listenerMethods.isEmpty() ? listenerMethods : null);
});
if (hasClassLevelListeners) { //如果類上有註解的話，都有搭配@KafkaHandler使用的，方法上找這個註解
Set<Method> methodsWithHandler = MethodIntrospector.selectMethods(targetClass,
(ReflectionUtils.MethodFilter) method ->
AnnotationUtils.findAnnotation(method, KafkaHandler.class) != null);
multiMethods.addAll(methodsWithHandler);
}
if (annotatedMethods.isEmpty()) { //將解析過class 快取起來
this.nonAnnotatedClasses.add(bean.getClass());
else {
// Non-empty set of methods
for (Map.Entry<Method, Set<KafkaListener>> entry : annotatedMethods.entrySet()) {
Method method = entry.getKey();
for (KafkaListener listener : entry.getValue()) {
processKafkaListener(listener, method, bean, beanName); //方法監聽處理的邏輯
}
}
this.logger.debug(() -> annotatedMethods.size() + " @KafkaListener methods processed on bean '"
+ beanName + "': " + annotatedMethods);
}
if (hasClassLevelListeners) {
processMultiMethodListeners(classLevelListeners, multiMethods, bean, beanName); //KafkaHandler 處理邏輯
}
}
return bean;
}@kafkaListener其實可以作用於Class 上的，搭配著@KafkaHandler一起使用，那怎麼樣使用呢，我用一個簡單例子展示下。
@KafkaListener(topics = "${topic-name.lists}",groupId = "${group}",concurrency = 4)
public class Kddk {
@KafkaHandler
public void user(User user){
}
@KafkaHandler
public void std(Dog dog){
}
}消費資訊不同物件區分進行處理，省去物件轉換的麻煩，我暫時想到場景就是這些，平常很少有這些。這個實現原理我就不深入分析了
protected void processKafkaListener(KafkaListener kafkaListener, Method method, Object bean, String beanName) {
//如果方法剛好被代理增強了，返回原始class 方法
Method methodToUse = checkProxy(method, bean);
MethodKafkaListenerEndpoint<K, V> endpoint = new MethodKafkaListenerEndpoint<>();
endpoint.setMethod(methodToUse);
String beanRef = kafkaListener.beanRef();
this.listenerScope.addListener(beanRef, bean);
String[] topics = resolveTopics(kafkaListener);
TopicPartitionOffset[] tps = resolveTopicPartitions(kafkaListener);
//這個方法是判斷方法上是否有@RetryableTopic 註解，有的話則放回true，註冊到KafkaListenerEndpointRegistry
if (!processMainAndRetryListeners(kafkaListener, bean, beanName, methodToUse, endpoint, topics, tps)) {
//解析@kafkaListener 屬性，設定到endpoint ，註冊到KafkaListenerEndpointRegistry
processListener(endpoint, kafkaListener, bean, beanName, topics, tps);
}
this.listenerScope.removeListener(beanRef);
}
protected void processListener(MethodKafkaListenerEndpoint<?, ?> endpoint, KafkaListener kafkaListener,
Object bean, String beanName, String[] topics, TopicPartitionOffset[] tps) {
processKafkaListenerAnnotationBeforeRegistration(endpoint, kafkaListener, bean, topics, tps);
String containerFactory = resolve(kafkaListener.containerFactory());
KafkaListenerContainerFactory<?> listenerContainerFactory = resolveContainerFactory(kafkaListener, containerFactory, beanName);
//這裡主要核心了，解析完成後，註冊到KafkaListenerEndpointRegistry 中，等待下一步操作了
this.registrar.registerEndpoint(endpoint, listenerContainerFactory);
processKafkaListenerEndpointAfterRegistration(endpoint, kafkaListener);
}類名MethodKafkaListenerEndpoint 都可以理解成端點物件，簡單地說，端點是通訊通道的一端。可以理解這個端點連線業務方法和kafka 資訊之間的通訊端點。
@RetryableTopic 是spring kafka 2.7 後出的一個註解，主要作用就是在消費kafka資訊時出現消費異常時，失敗重試而出現死信資訊的處理，由於Kafka內部並沒有死信佇列或者死信資訊這類東西。Spring 自己搞出來一個DLT topics (Dead-Letter Topic),意思就是當消費資訊失敗到達一定次數時，會將資訊傳送到指定DLT topic 中。註解可以設定重試次數、重試時間、故障異常、失敗策略等等。
其實這個processMainAndRetryListeners 方法跟下面processListener 作用差不多，都有解析註解內容，然後呼叫KafkaListenerEndpointRegistry.registerEndpoint 方法。
KafkaListenerEndpointRegistry 主要由Spring 容器建立，用於例項化MessageListenerContainer
KafkaListenerEndpointRegistrar主要程式碼new建立，並沒有交給spring容器管理，用於幫助bean 註冊到KafkaListenerEndpointRegistry中
這個兩個類類名特別相似，在分析原始碼時被搞到暈頭轉向，分清楚後其實就挺簡單了，這個類名搞混上浪費不算時間去理解。
註冊endpoint
public void registerEndpoint(KafkaLiEstenerEndpoint endpoint, @Nullable KafkaListenerContainerFactory<?> factory) {
// Factory may be null, we defer the resolution right before actually creating the container
// 這個只是一個內部類，用來裝兩個物件的，沒有任何實現意義，factory 實際可能為空，這裡使用延時建立解析這個問題
KafkaListenerEndpointDescriptor descriptor = new KafkaListenerEndpointDescriptor(endpoint, factory);
synchronized (this.endpointDescriptors) {
//這個 startImmediately 並沒有被初始化，這裡一定是false，當被設定true，會直接建立監聽器容器，這時應該是spring 容器已經初始化完成了
if (this.startImmediately) { // Register and start immediately
this.endpointRegistry.registerListenerContainer(descriptor.endpoint,
resolveContainerFactory(descriptor), true);
}
else {
this.endpointDescriptors.add(descriptor);
}
}
}這裡為什麼有一個startImmediately開關呢，這裡只是將endpoint 放入容器集中儲存起來，等到全部新增完成後，使用Spring InitializingBean介面afterPropertiesSet 方法進行基礎註冊啟動，這是利用了Spring bean 生命週期方法來觸發，如果是Spring 完全啟動完成後，那新增進來endpoint就是不能啟動的了，所以相當於一個閾值開關，開啟後立即啟動。
下面看下呼叫KafkaListenerEndpointRegistrar.afterPropertiesSet 來開啟各大endpoint 執行。
@Override
public void afterPropertiesSet() {
registerAllEndpoints();
}
protected void registerAllEndpoints() {
synchronized (this.endpointDescriptors) {
for (KafkaListenerEndpointDescriptor descriptor : this.endpointDescriptors) {
if (descriptor.endpoint instanceof MultiMethodKafkaListenerEndpoint //只有使用@KafkaHandler 才會生成這個物件
&& this.validator != null) {
((MultiMethodKafkaListenerEndpoint) descriptor.endpoint).setValidator(this.validator);
}
//通過endpoint ,containerFactory 建立資訊容器MessageListenerContainer
this.endpointRegistry.registerListenerContainer(
descriptor.endpoint, resolveContainerFactory(descriptor));
}
//全部處理完成了，就可以開啟start啟動按鈕，讓新增進來立即啟動
this.startImmediately = true; // trigger immediate startup
}
}
//獲取內部類KafkaListenerContainerFactory 具體例項，在延時啟動時，可能存在空，這時可以使用Spring 內部預設
// 如果註解上已經備註了要使用ContainerFactory 則使用自定義，為空則使用預設ConcurrentKafkaListenerContainerFactory
private KafkaListenerContainerFactory<?> resolveContainerFactory(KafkaListenerEndpointDescriptor descriptor) {
if (descriptor.containerFactory != null) {
return descriptor.containerFactory;
}
else if (this.containerFactory != null) {
return this.containerFactory;
}
else if (this.containerFactoryBeanName != null) {
Assert.state(this.beanFactory != null, "BeanFactory must be set to obtain container factory by bean name");
this.containerFactory = this.beanFactory.getBean(
this.containerFactoryBeanName, KafkaListenerContainerFactory.class);
return this.containerFactory; // Consider changing this if live change of the factory is required
}
else {
//.....
}
}MessageListenerContainer
看下KafkaListenerEndpointRegistry.registerListenerContainer 方法如何生成資訊監聽器的。
public void registerListenerContainer(KafkaListenerEndpoint endpoint, KafkaListenerContainerFactory<?> factory) {
registerListenerContainer(endpoint, factory, false);
}
public void registerListenerContainer(KafkaListenerEndpoint endpoint, KafkaListenerContainerFactory<?> factory,
boolean startImmediately) {
String id = endpoint.getId();
Assert.hasText(id, "Endpoint id must not be empty");
synchronized (this.listenerContainers) {
Assert.state(!this.listenerContainers.containsKey(id),
"Another endpoint is already registered with id '" + id + "'");
//建立監聽器容器
MessageListenerContainer container = createListenerContainer(endpoint, factory);
//使用map 將例項化容器儲存起來，key就是 @KafkaListener id ，這個就是所謂的beanName
this.listenerContainers.put(id, container);
ConfigurableApplicationContext appContext = this.applicationContext;
String groupName = endpoint.getGroup();
//如果註解中有設定自定義監聽組，這時需要獲取到監聽組例項，將監聽器容器裝起來
if (StringUtils.hasText(groupName) && appContext != null) {
//省略部分內容
}
if (startImmediately) { //如果是立即啟動，這時需要手動呼叫監聽器start 方法
startIfNecessary(container);
}
}
}
protected MessageListenerContainer createListenerContainer(KafkaListenerEndpoint endpoint,
KafkaListenercContainerFactory<?> factory) {
//監聽器被建立了
MessageListenerContainer listenerContainer = factory.createListenerContainer(endpoint);
if (listenerContainer instanceof InitializingBean) { //這時spring 容器已經初始化完成了，生命週期方法不會再執行了，這裡顯式呼叫它
try {
((InitializingBean) listenerContainer).afterPropertiesSet();
}
catch (Exception ex) {
throw new BeanInitializationException("Failed to initialize message listener container", ex);
}
}
int containerPhase = listenerContainer.getPhase();
if (listenerContainer.isAutoStartup() &&
containerPhase != AbstractMessageListenerContainer.DEFAULT_PHASE) { // a custom phase value
if (this.phase != AbstractMessageListenerContainer.DEFAULT_PHASE && this.phase != containerPhase) {
throw new IllegalStateException("Encountered phase mismatch between container "
+ "factory definitions: " + this.phase + " vs " + containerPhase);
}
this.phase = listenerContainer.getPhase();
}
return listenerContainer;
}
private void startIfNecessary(MessageListenerContainer listenerContainer) {
// contextRefreshed Spring 完全啟動完成true
if (this.contextRefreshed || listenerContainer.isAutoStartup()) {
listenerContainer.start();
}
}
主要就是通過KafkaListenercContainerFactory 資訊監聽工廠來建立監聽器MessageListenerContainer ，通過繼承了SmartLifecycle。SmartLifecycle介面是Spring 在初始化完成後，根據介面isAutoStartup() 返回值是否實現該介面的類中對應的start()。Spring 當spring 完全初始化完成後，SmartLifecycle 介面就不會被Spring 呼叫執行，這時就需要手動執行start 方法，所以startIfNecessary 方法才會判斷容器已經啟動完成了。
MessageListenerContainer
public C createListenerContainer(KafkaListenerEndpoint endpoint) {
C instance = createContainerInstance(endpoint);
JavaUtils.INSTANCE
.acceptIfNotNull(endpoint.getId(), instance::setBeanName);
if (endpoint instanceof AbstractKafkaListenerEndpoint) {
//配置kafka 設定，因為像資訊消費提交ack，資訊消費批量這些設定都是通過配置設定的，這些資訊都在factory儲存著，這時將配置資訊設定給endpoint
configureEndpoint((AbstractKafkaListenerEndpoint<K, V>) endpoint);
}
//這裡是核心，將註解宣告bean method 建立成MessagingMessageListenerAdapter 資訊監聽介面卡，在將介面卡初始化引數去建立資訊監聽器，交給instance
endpoint.setupListenerContainer(instance, this.messageConverter);
//將concurrency 併發數設定上
initializeContainer(instance, endpoint);
//自定義配置
customizeContainer(instance);
return instance;
}這時kafka 配置資訊、@KafkaListener 資訊、消費方法、bean 已經全部設定createListenerContainer，這時監聽器容器就可以啟動kafka 拉取資訊，呼叫方法進行處理了。
直接從資訊監聽器ConcurrentMessageListenerContainer啟動方法開始
public final void start() {
checkGroupId();
synchronized (this.lifecycleMonitor) {
if (!isRunning()) { //監聽狀態，測試還沒有開始監聽，所以監聽狀態應該為false
Assert.state(this.containerProperties.getMessageListener() instanceof GenericMessageListener,
() -> "A " + GenericMessageListener.class.getName() + " implementation must be provided");
//抽象方法，由子類去實現
doStart();
}
}
}
@Override
protected void doStart() {
if (!isRunning()) {
//topic 正則匹配，根據規則去匹配sever所有topic，沒有則丟擲異常
checkTopics();
ContainerProperties containerProperties = getContainerProperties();
//已經獲取到消費組的分割槽和offset
TopicPartitionOffset[] topicPartitions = containerProperties.getTopicPartitions();
if (topicPartitions != null && this.concurrency > topicPartitions.length) {
// 當 concurrency 併發數超過分割槽時，這裡會列印警告日誌
this.logger.warn(() -> "When specific partitions are provided, the concurrency must be less than or "
+ "equal to the number of partitions; reduced from " + this.concurrency + " to "
+ topicPartitions.length);
//注意這裡，強制將併發數改成最大分數，在設定消費併發時，不用擔心分割槽數量併發超過
this.concurrency = topicPartitions.length;
}
setRunning(true); //開始監聽
//concurrency 就是建立容器時，從@KafkaListener 解析處理的併發數
// 可以看出併發數控制著 KafkaMessageListenerContainer 例項產生
for (int i = 0; i < this.concurrency; i++) {
//建立 KafkaMessageListenerContainer 物件
KafkaMessageListenerContainer<K, V> container =
constructContainer(containerProperties, topicPartitions, i);
//配置監聽器容器攔截器、通知這些，如果沒有配置預設都是null
configureChildContainer(i, container);
if (isPaused()) {
container.pause();
}
container.start(); //啟動任務
//因為所有消費現場都是同一個容器建立的，當要停止某個消費topic，需要對containers進行操作
this.containers.add(container);
}
}
}
private KafkaMessageListenerContainer<K, V> constructContainer(ContainerProperties containerProperties,
@Nullable TopicPartitionOffset[] topicPartitions, int i) {
KafkaMessageListenerContainer<K, V> container;
if (topicPartitions == null) {
container = new KafkaMessageListenerContainer<>(this, this.consumerFactory, containerProperties); // NOSONAR
}
else { //如果存在分割槽，每一個消費都有平分分割槽
container = new KafkaMessageListenerContainer<>(this, this.consumerFactory, // NOSONAR
containerProperties, partitionSubset(containerProperties, i));
}
return container;
}看到了@KafkaListener 併發數如何實現的，並且併發數不能超過分割槽數的，如果併發數小於分割槽數，則會出現平分的情況，可能會讓一個消費佔有多個分割槽情況。這裡在建立KafkaMessageListenerContainer 去對Kafka topic 進行消費。
KafkaMessageListenerContainer
因為KafkaMessageListenerContainer和ConcurrentMessageListenerContainer都是通過extends AbstractMessageListenerContainer 重寫doStart()開啟任務，直接看見doStart就可以知道程式入口了。
protected void doStart() {
if (isRunning()) {
return;
}
if (this.clientIdSuffix == null) { // stand-alone container
checkTopics();
}
ContainerProperties containerProperties = getContainerProperties();
//檢查是否非自動ack，在org.springframework.kafka.listener.ContainerProperties.AckMode 有多種模式
checkAckMode(containerProperties);
//
Object = containerProperties.getMessageListener();
//任務執行器，看起倆像一個執行緒池Executor ，本質上是直接使用Thread來啟動任務的
AsyncListenableTaskExecutor consumerExecutor = containerProperties.getConsumerTaskExecutor();
if (consumerExecutor == null) {
consumerExecutor = new SimpleAsyncTaskExecutor(
(getBeanName() == null ? "" : getBeanName()) + "-C-");
containerProperties.setConsumerTaskExecutor(consumerExecutor);
}
GenericMessageListener<?> listener = (GenericMessageListener<?>) messageListener;
//這個一個列舉類，根據型別生成type，type 標記著如何處理kafka 資訊，有批量的、單條的、手動提交、自動提交
ListenerType listenerType = determineListenerType(listener);
//ListenerConsumer 內部類，有關Kafka 任何資訊都可以直接去取的
this.listenerConsumer = new ListenerConsumer(listener, listenerType);
setRunning(true); //設定執行狀態
this.startLatch = new CountDownLatch(1);
this.listenerConsumerFuture = consumerExecutor
.submitListenable(this.listenerConsumer);//啟動執行緒
try {
if (!this.startLatch.await(containerProperties.getConsumerStartTimeout().toMillis(), TimeUnit.MILLISECONDS)) {
this.logger.error("Consumer thread failed to start - does the configured task executor "
+ "have enough threads to support all containers and concurrency?");
publishConsumerFailedToStart();
}
}
catch (@SuppressWarnings(UNUSED) InterruptedException e) {
Thread.currentThread().interrupt();
}
}在這裡主要邏輯就是啟動執行緒去去處理kafka 資訊拉取。我們直接去看ListenerConsumer run() 就行了。
@Override // NOSONAR complexity
public void run() {
ListenerUtils.setLogOnlyMetadata(this.containerProperties.isOnlyLogRecordMetadata());
//向spring容器釋出事件
publishConsumerStartingEvent();
this.consumerThread = Thread.currentThread();
setupSeeks();
KafkaUtils.setConsumerGroupId(this.consumerGroupId);
this.count = 0;
this.last = System.currentTimeMillis();
//從kafka 獲取消費組 分割槽 offset，儲存起來
initAssignedPartitions();
//釋出事件
publishConsumerStartedEvent();
Throwable exitThrowable = null;
while (isRunning()) {
try {
//核心 拉取資訊和 呼叫方法去處理資訊
pollAndInvoke();
}
//省略pollAndInvoke 這個方法就是拉取資訊和處理的過程了，方法太繁瑣了，無非就是如何去呼叫endpoint 生成資訊處理器，並且將引數注入方法中。
總結
結合上面圖，簡單總結下Spring Kafka 如何通過一個簡單註解實現對方法消費資訊的。首先通過Spring 前置處理器機制使用KafkaListenerAnnotationBeanPostProcessor 掃描所有已經例項化的bean，找出帶有@KafkaListener bean 和方法，解析註解的內容設定到MethodKafkaListenerEndpoint，並且註冊到KafkaListenerEndpointRegistry，有它統一儲存起來，等到執行前置處理器統一將KafkaListenerEndpointRegistry儲存起來的enpoint，註冊到KafkaListenerEndpointRegistrar,根據enpoint生成ConcurrentMessageListenerContainer，在根據併發數去生成對應數量的KafkaMessageListenerContainer，最後使用Thread 非同步啟動Kafka 資訊拉去，呼叫bean 方法進行處理。
還理解了topic 分割槽和併發數如何關聯的，還知道kafka消費是可控制的，處理Kafka資訊方法，返回值可以被推送到另一個topic的、也是第一次知道有@RetryableTopic 重試機制，還有DLT 死信topic。如果不是看原始碼分析，平常工作場景估計很少用得上這些。現在看原始碼多了，越來越有感覺檢視程式碼更能加深你對框架學習，心得。
動態訂閱
看了這麼多程式碼，對照處理器CV下就，簡單版動態監聽就可以實現了
@Component
public class ListenerMessageCommand<K,V> implements CommandLineRunner {
@Autowired
private Cusmotd cusmotd;
@Autowired
private KafkaListenerEndpointRegistry endpointRegistry;
@Autowired
private KafkaListenerContainerFactory<?> kafkaListenerContainerFactory;
private Logger logger = LoggerFactory.getLogger(ListenerMessageCommand.class);
@Override
public void run(String... args) throws Exception {
MethodKafkaListenerEndpoint<K, V> endpoint = new MethodKafkaListenerEndpoint<>();
endpoint.setBean(cusmotd);
Method method = ReflectionUtils.findMethod(cusmotd.getClass(), "dis", ConsumerRecord.class);
endpoint.setMethod(method);
endpoint.setMessageHandlerMethodFactory(new DefaultMessageHandlerMethodFactory());
endpoint.setId("tk.shengyifeng.custom#1");
endpoint.setGroupId("test");
endpoint.setTopicPartitions(new TopicPartitionOffset[0]);
endpoint.setTopics("skdsk");
endpoint.setClientIdPrefix("comuserd_");
endpoint.setConcurrency(1);
endpointRegistry.registerListenerContainer(endpoint,kafkaListenerContainerFactory,true);
logger.info("register...............");
}
}我們看過完整程式碼，知道監聽動作是由KafkaListenerContainerFactory建立後，呼叫例項start 方法開始的，並且我們還能拿到監聽容器物件，可以呼叫物件各式API，可以動態停止對topic消費哦。
@RestController
@RequestMapping("kafka")
public class KafkaController<K,V> {
@Autowired
private Cusmotd cusmotd;
@Autowired
private KafkaListenerContainerFactory<?> kafkaListenerContainerFactory;
private Map<String,MessageListenerContainer> containerMap = new ConcurrentReferenceHashMap<>();
@GetMapping("start/topic")
public void startTopic(String topicName,String groupName){
MethodKafkaListenerEndpoint<K, V> endpoint = new MethodKafkaListenerEndpoint<>();
endpoint.setBean(cusmotd);
Method method = ReflectionUtils.findMethod(cusmotd.getClass(), "dis", ConsumerRecord.class);
endpoint.setMethod(method);
endpoint.setMessageHandlerMethodFactory(new DefaultMessageHandlerMethodFactory());
endpoint.setId("tk.shengyifeng.custom#1");
endpoint.setGroupId(groupName);
endpoint.setTopicPartitions(new TopicPartitionOffset[0]);
endpoint.setTopics(topicName);
endpoint.setClientIdPrefix("comuserd_");
endpoint.setConcurrency(1);
MessageListenerContainer listenerContainer = kafkaListenerContainerFactory.createListenerContainer(endpoint);
listenerContainer.start();
containerMap.put(topicName,listenerContainer);
}
@GetMapping("stop/topic")
public void stopTopic(String topicName){
if (containerMap.containsKey(topicName))
containerMap.get(topicName).stop();
}
}這個簡單http介面，通過介面方式支援對外擴容的方式動態訂閱頻道，並且支援已經訂閱topic消費停下來。
使用@kafkaListener 宣告方法消費的同學不用羨慕的，Spring 提供機制可以去獲取MessageListenerContainer，上面程式碼分析我們知道了KafkaListenerEndpointRegistry內部的listenerContainers 會儲存所有container例項，並且提供外部方法根據id去獲取物件，而且KafkaListenerEndpointRegistry還是有spring 進行例項化的，所以....
為了方便獲取id簡單，可以在使用註解時，手動指定id 值，如果沒有指定則id，預設生成規則是org.springframework.kafka.KafkaListenerEndpointContainer# + 自增長
SpringBoot 自動配置
大家可能好奇，Spring boot中Kafka配置資訊如何給kafkaListenerContainerFactory，因為它是通過Spring 容器初始化的，原始碼中並沒有看見帶有構造器的引數注入。想要具體瞭解，只有看KafkaAnnotationDrivenConfiguration，ConcurrentKafkaListenerContainerFactoryConfigurer
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(EnableKafka.class)
class KafkaAnnotationDrivenConfiguration {
private final KafkaProperties properties;
private final RecordMessageConverter messageConverter;
private final RecordFilterStrategy<Object, Object> recordFilterStrategy;
private final BatchMessageConverter batchMessageConverter;
private final KafkaTemplate<Object, Object> kafkaTemplate;
private final KafkaAwareTransactionManager<Object, Object> transactionManager;
private final ConsumerAwareRebalanceListener rebalanceListener;
private final ErrorHandler errorHandler;
private final BatchErrorHandler batchErrorHandler;
private final AfterRollbackProcessor<Object, Object> afterRollbackProcessor;
private final RecordInterceptor<Object, Object> recordInterceptor;
KafkaAnnotationDrivenConfiguration(KafkaProperties properties,
ObjectProvider<RecordMessageConverter> messageConverter,
ObjectProvider<RecordFilterStrategy<Object, Object>> recordFilterStrategy,
ObjectProvider<BatchMessageConverter> batchMessageConverter,
ObjectProvider<KafkaTemplate<Object, Object>> kafkaTemplate,
ObjectProvider<KafkaAwareTransactionManager<Object, Object>> kafkaTransactionManager,
ObjectProvider<ConsumerAwareRebalanceListener> rebalanceListener, ObjectProvider<ErrorHandler> errorHandler,
ObjectProvider<BatchErrorHandler> batchErrorHandler,
ObjectProvider<AfterRollbackProcessor<Object, Object>> afterRollbackProcessor,
ObjectProvider<RecordInterceptor<Object, Object>> recordInterceptor) {
this.properties = properties;
this.messageConverter = messageConverter.getIfUnique();
this.recordFilterStrategy = recordFilterStrategy.getIfUnique();
this.batchMessageConverter = batchMessageConverter
.getIfUnique(() -> new BatchMessagingMessageConverter(this.messageConverter));
this.kafkaTemplate = kafkaTemplate.getIfUnique();
this.transactionManager = kafkaTransactionManager.getIfUnique();
this.rebalanceListener = rebalanceListener.getIfUnique();
this.errorHandler = errorHandler.getIfUnique();
this.batchErrorHandler = batchErrorHandler.getIfUnique();
this.afterRollbackProcessor = afterRollbackProcessor.getIfUnique();
this.recordInterceptor = recordInterceptor.getIfUnique();
}作為其實Spring Boot自動配置原理就是由spring-boot-autoconfigure 包編碼實現的，在根據@ConditionalOnClass 註解來決定是否啟動配置類，所以當你引入對應pox時，就會啟動配置類了，配置資訊會注入到KafkaProperties物件中，然後將properties 設定到工廠物件，例項化物件交給spring 容器，你會發現大多數自動配置都是這樣套路。