spring kafka consumer原理解析一

前言：Spring kafka 是 Spring 对 kafka API的一次封装，省去了写生产和消费的代码，而只需要加个注解即可使用 kafka 收发消息。然而 Spring 是如何实现的呢？与我们自己手写有啥不同？see ↓

以下仅对消费者源码进行分析：

一、消费者的创建

老套路：查看源码首先是找到入口，无可厚非，spring kafka 的入口即为@KafkaListenner注解，因为我们在使用Spring kafka时配置一个@KafkaListnner即可消费到 kafka 的数据。

（1）入口：KafkaListenerAnnotationBeanPostProcessor 一个实现了 BPP 的类，以下只贴出核心的几个方法 ↓

public class KafkaListenerAnnotationBeanPostProcessor<K, V>
        implements BeanPostProcessor, Ordered, BeanFactoryAware, SmartInitializingSingleton {

    @Override
    public Object postProcessAfterInitialization(final Object bean, final String beanName) throws BeansException {
        if (!this.nonAnnotatedClasses.contains(bean.getClass())) {
            Class<?> targetClass = AopUtils.getTargetClass(bean);
            Collection<KafkaListener> classLevelListeners = findListenerAnnotations(targetClass); // 找到所有有@KafkaListenner的方法和类
            final boolean hasClassLevelListeners = classLevelListeners.size() > 0;
            final List<Method> multiMethods = new ArrayList<Method>();
            Map<Method, Set<KafkaListener>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
                    new MethodIntrospector.MetadataLookup<Set<KafkaListener>>() {

                        @Override
                        public Set<KafkaListener> inspect(Method method) {
                            Set<KafkaListener> listenerMethods = findListenerAnnotations(method);
                            return (!listenerMethods.isEmpty() ? listenerMethods : null);
                        }

                    });
            if (hasClassLevelListeners) {
                Set<Method> methodsWithHandler = MethodIntrospector.selectMethods(targetClass,
                        new ReflectionUtils.MethodFilter() {

                            @Override
                            public boolean matches(Method method) {
                                return AnnotationUtils.findAnnotation(method, KafkaHandler.class) != null;
                            }

                        });
                multiMethods.addAll(methodsWithHandler);
            }
            if (annotatedMethods.isEmpty()) {
                this.nonAnnotatedClasses.add(bean.getClass());
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("No @KafkaListener annotations found on bean type: " + 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);
                    }
                }
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug(annotatedMethods.size() + " @KafkaListener methods processed on bean '"
                            + beanName + "': " + annotatedMethods);
                }
            }
            if (hasClassLevelListeners) {
                processMultiMethodListeners(classLevelListeners, multiMethods, bean, beanName); // 然后跟着这行代码往下面这个方法看，接下来对取到的有@KafkaListenner类和方法进行了什么处理
            }
        }
        return bean;
    }

    private void processMultiMethodListeners(Collection<KafkaListener> classLevelListeners, List<Method> multiMethods,
            Object bean, String beanName) {
        List<Method> checkedMethods = new ArrayList<Method>();
        for (Method method : multiMethods) {
            checkedMethods.add(checkProxy(method, bean));
        }
　　　　　// 这里会遍历拿到的 classLevelListeners 集合，即每一个 kafkaListenner, 然后创建了一个 endpoint 对象,接下来看 processListenner 方法
        for (KafkaListener classLevelListener : classLevelListeners) {
            MultiMethodKafkaListenerEndpoint<K, V> endpoint = new MultiMethodKafkaListenerEndpoint<K, V>(checkedMethods,
                    bean);
            endpoint.setBeanFactory(this.beanFactory);
            processListener(endpoint, classLevelListener, bean, bean.getClass(), beanName);
        }
    }

    protected void processListener(MethodKafkaListenerEndpoint<?, ?> endpoint, KafkaListener kafkaListener, Object bean,
            Object adminTarget, String beanName) {
　　　　  // 从这个方法可以知道，spring 会把拿到的 kafkaListenner 的一些信息（topic, partitions等）封装到那个 endpoint 里面 
        endpoint.setBean(bean);
        endpoint.setMessageHandlerMethodFactory(this.messageHandlerMethodFactory);
        endpoint.setId(getEndpointId(kafkaListener));
        endpoint.setTopicPartitions(resolveTopicPartitions(kafkaListener));
        endpoint.setTopics(resolveTopics(kafkaListener));
        endpoint.setTopicPattern(resolvePattern(kafkaListener));
        String group = kafkaListener.group();
        if (StringUtils.hasText(group)) {
            Object resolvedGroup = resolveExpression(group);
            if (resolvedGroup instanceof String) {
                endpoint.setGroup((String) resolvedGroup);
            }
        }

        KafkaListenerContainerFactory<?> factory = null;
        String containerFactoryBeanName = resolve(kafkaListener.containerFactory());
        if (StringUtils.hasText(containerFactoryBeanName)) {
            Assert.state(this.beanFactory != null, "BeanFactory must be set to obtain container factory by bean name");
            try {
                factory = this.beanFactory.getBean(containerFactoryBeanName, KafkaListenerContainerFactory.class);
            }
            catch (NoSuchBeanDefinitionException ex) {
                throw new BeanInitializationException("Could not register Kafka listener endpoint on [" + adminTarget
                        + "] for bean " + beanName + ", no " + KafkaListenerContainerFactory.class.getSimpleName()
                        + " with id '" + containerFactoryBeanName + "' was found in the application context", ex);
            }
        }
　　　　　// 封装成了 endpoint 对象之后则进行注册
        this.registrar.registerEndpoint(endpoint, factory);
    }
}

通过分析这个 BPP 可以获得的信息是：在  IOC 容器初始化的时候获取所有带有 @KafkaListenner 注解的方法或类，然后将其信息封装到 endpoint 对象中，最后则对 endpoint 对象进行注册。接下来对注册进行分析 ↓

（2）KafkaListenerEndpointRegistrar 一个实现了 InitializingBean 的类，为啥要实现它呢？暂且埋下伏笔。

public class KafkaListenerEndpointRegistrar implements BeanFactoryAware, InitializingBean {

    private final List<KafkaListenerEndpointDescriptor> endpointDescriptors = new ArrayList<>();

    public void registerEndpoint(KafkaListenerEndpoint endpoint, KafkaListenerContainerFactory<?> factory) {
        Assert.notNull(endpoint, "Endpoint must be set");
        Assert.hasText(endpoint.getId(), "Endpoint id must be set");
        // 可以看出 这里又将 endpoint 封装到了 KafkaListenerEndpointDescriptor 对象中，然后将其注册（保存）到了endpointDescriptors （一个List）中去。
        // 于是从一开始根据 @KafkaListener 注解获取对象到注册则全部结束,是不是 consumer 创建就到此结束？当然还有一些工作，接下来就是真正核心的东西：创建 kafkaListener 容器
        KafkaListenerEndpointDescriptor descriptor = new KafkaListenerEndpointDescriptor(endpoint, factory);
        synchronized (this.endpointDescriptors) {
            if (this.startImmediately) { // Register and start immediately
                this.endpointRegistry.registerListenerContainer(descriptor.endpoint,
                        resolveContainerFactory(descriptor), true);
            }
            else {
                this.endpointDescriptors.add(descriptor);
            }
        }
    }

    // 创建容器 start, 这就是为什么要实现 InitializingBean 接口的原因。因为在获取 @KafkaListener 的一些信息以及注册完成之后，还需要创建 KafkaListener 容器
    @Override
    public void afterPropertiesSet() {
        registerAllEndpoints();
    }

    protected void registerAllEndpoints() {
        synchronized (this.endpointDescriptors) {
   　　　　　 // 这里发现，spring 对每一个 kafkaListener 注册一个 ListenerContainer 容器，即有多少个 @KafkaListener 它就会注册多少个 Listener 容器　
            for (KafkaListenerEndpointDescriptor descriptor : this.endpointDescriptors) {
                this.endpointRegistry.registerListenerContainer(
                        descriptor.endpoint, resolveContainerFactory(descriptor));
            }
            this.startImmediately = true;  // trigger immediate startup
        }
    }

}        

从以上解析可以知道：spring 会将 @KafkaListener 注解中的信息注册到一个 list 集合中，信息注册完成之后则会进行容器的创建，有多少个 @KafkaListener 就注册多少个 Listener 容器。然而，容器到底是什么容器呢？是如何注册的？又有什么用呢？

（3）KafkaListenerEndpointRegistry   在这个类里我们将看到 Spring 是如何进行容器注册的

public class KafkaListenerEndpointRegistry implements DisposableBean, SmartLifecycle, ApplicationContextAware,
        ApplicationListener<ContextRefreshedEvent> {

　　private final Map<String, MessageListenerContainer> listenerContainers = new ConcurrentHashMap<String, MessageListenerContainer>();

    public void registerListenerContainer(KafkaListenerEndpoint endpoint, KafkaListenerContainerFactory<?> factory) {
        registerListenerContainer(endpoint, factory, false);
    }

    public void registerListenerContainer(KafkaListenerEndpoint endpoint, KafkaListenerContainerFactory<?> factory,
            boolean startImmediately) {
        Assert.notNull(endpoint, "Endpoint must not be null");
        Assert.notNull(factory, "Factory must not be null");
　　　　　// 获取 id 即为 @KafkaListener 里的 id 作为 Map 的 key 值
        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);
   　　　　　 // 将容器注册到 listenerContainers （一个 Map）中
            this.listenerContainers.put(id, container);
            if (StringUtils.hasText(endpoint.getGroup()) && this.applicationContext != null) {
                List<MessageListenerContainer> containerGroup;
                if (this.applicationContext.containsBean(endpoint.getGroup())) {
                    containerGroup = this.applicationContext.getBean(endpoint.getGroup(), List.class);
                }
                else {
                    containerGroup = new ArrayList<MessageListenerContainer>();
                    this.applicationContext.getBeanFactory().registerSingleton(endpoint.getGroup(), containerGroup);
                }
                containerGroup.add(container);
            }
　　　　　　  // 容器启动
            if (startImmediately) {
                startIfNecessary(container);
            }
        }
    }

}

单单这个类远远满足不了我们对容器注册的好奇心，这里我们只能获取到这些信息：创建容器然后将容器注册到了一个 Map 中，最后是启动容器。然而容器是什么容器又是如何创建的还未知，于是接着摸索 ↓

（4）ConcurrentKafkaListenerContainerFactory  通过不懈的追踪，终于找到了 ‘元凶’.是的就是这个类创建了 Listener 容器。

public class ConcurrentKafkaListenerContainerFactory<K, V>
        extends AbstractKafkaListenerContainerFactory<ConcurrentMessageListenerContainer<K, V>, K, V> {

　　@Override
    protected ConcurrentMessageListenerContainer<K, V> createContainerInstance(KafkaListenerEndpoint endpoint) {
        Collection<TopicPartitionInitialOffset> topicPartitions = endpoint.getTopicPartitions();
        if (!topicPartitions.isEmpty()) {
            ContainerProperties properties = new ContainerProperties(
                    topicPartitions.toArray(new TopicPartitionInitialOffset[topicPartitions.size()]));
            return new ConcurrentMessageListenerContainer<K, V>(getConsumerFactory(), properties);
        }
        else {
            Collection<String> topics = endpoint.getTopics();
            if (!topics.isEmpty()) {
                ContainerProperties properties = new ContainerProperties(topics.toArray(new String[topics.size()]));
                return new ConcurrentMessageListenerContainer<K, V>(getConsumerFactory(), properties);
            }
            else {
                ContainerProperties properties = new ContainerProperties(endpoint.getTopicPattern());
                return new ConcurrentMessageListenerContainer<K, V>(getConsumerFactory(), properties);
            }
        }
    }

}

哎呀，原来是创建了 ConcurrentMessageListenerContainer 啊，现在终于明白了 Spring 原来是创建这个 Listener 容器。然而这个容器又是何方圣神，come on ↓

（5）ConcurrentMessageListenerContainer  于是明白了容器的注册过程（创建 ConcurrentMessageListenerContainer  容器，然后把容器注册到 listenerContainers （一个 Map）中，最后就是启动容器）之后，就是研究容器究竟做了什么。

// 大家留意一下 AbstractMessageListenerContainer 这个类喔，待会有惊喜

public class ConcurrentMessageListenerContainer<K, V> extends AbstractMessageListenerContainer<K, V> {

　　 private final List<KafkaMessageListenerContainer<K, V>> containers = new ArrayList<>();

    private int concurrency = 1;

    @Override
    protected void doStart() {
        if (!isRunning()) {
            ContainerProperties containerProperties = getContainerProperties();
            TopicPartitionInitialOffset[] topicPartitions = containerProperties.getTopicPartitions();
　　　　　　　// 这里可以知道，分区数不能小于这个 concurrency，这个东西到底是什么呢？现在知道它是一个 int 属性而且默认值为1
            if (topicPartitions != null && this.concurrency > topicPartitions.length) {
                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 遍历创建 KafkaMessageListenerContainer，并启动这个容器，最后将其注册到 containers （一个 List）中
            for (int i = 0; i < this.concurrency; i++) {
                KafkaMessageListenerContainer<K, V> container;
                if (topicPartitions == null) {
                    container = new KafkaMessageListenerContainer<>(this.consumerFactory, containerProperties);
                }
                else {
                    container = new KafkaMessageListenerContainer<>(this.consumerFactory, containerProperties,
                            partitionSubset(containerProperties, i));
                }
                if (getBeanName() != null) {
                    container.setBeanName(getBeanName() + "-" + i);
                }
                if (getApplicationEventPublisher() != null) {
                    container.setApplicationEventPublisher(getApplicationEventPublisher());
                }
                container.setClientIdSuffix("-" + i);
                container.start();
                this.containers.add(container);
            }
        }
    }

}

看了这里是不是有些疑问？为啥容器里面又创建容器？而且这个容器创建的个数还可以使用 concurrency 指定。那么这个 KafkaMessageListenerContainer 又是何方圣神，它和 ConcurrentMessageListenerContainer  又有什么关系呢？带着这些疑问继续追寻。

（6）KafkaMessageListenerContainer 

// 大家发现没，这个类也继承了 AbstractMessageListenerContainer，这一点可以知道，此类和 ConcurrentMessageListenerContainer 是来自一个老子的（兄弟关系）

public class KafkaMessageListenerContainer<K, V> extends AbstractMessageListenerContainer<K, V> {

　　private GenericAcknowledgingMessageListener<?> acknowledgingMessageListener;

    @Override
    protected void doStart() {
        if (isRunning()) {
            return;
        }
        ContainerProperties containerProperties = getContainerProperties();

        if (!this.consumerFactory.isAutoCommit()) {
            AckMode ackMode = containerProperties.getAckMode();
            if (ackMode.equals(AckMode.COUNT) || ackMode.equals(AckMode.COUNT_TIME)) {
                Assert.state(containerProperties.getAckCount() > 0, "'ackCount' must be > 0");
            }
            if ((ackMode.equals(AckMode.TIME) || ackMode.equals(AckMode.COUNT_TIME))
                    && containerProperties.getAckTime() == 0) {
                containerProperties.setAckTime(5000);
            }
        }

        Object messageListener = containerProperties.getMessageListener();
        Assert.state(messageListener != null, "A MessageListener is required");
        if (messageListener instanceof GenericAcknowledgingMessageListener) {
            this.acknowledgingMessageListener = (GenericAcknowledgingMessageListener<?>) messageListener;
        }
        else if (messageListener instanceof GenericMessageListener) {
            this.listener = (GenericMessageListener<?>) messageListener;
        }
        else {
            throw new IllegalStateException("messageListener must be 'MessageListener' "
                    + "or 'AcknowledgingMessageListener', not " + messageListener.getClass().getName());
        }
        if (containerProperties.getConsumerTaskExecutor() == null) {
            SimpleAsyncTaskExecutor consumerExecutor = new SimpleAsyncTaskExecutor(
                    (getBeanName() == null ? "" : getBeanName()) + "-C-");
            containerProperties.setConsumerTaskExecutor(consumerExecutor);
        }
        if (containerProperties.getListenerTaskExecutor() == null) {
            SimpleAsyncTaskExecutor listenerExecutor = new SimpleAsyncTaskExecutor(
                    (getBeanName() == null ? "" : getBeanName()) + "-L-");
            containerProperties.setListenerTaskExecutor(listenerExecutor);
        }
　　　　 // 终于，在这里我们知道原来 Spring 是在这里创建的 kafka consumer，不信可以到这个 ListenerConsumer 里去瞧瞧
        this.listenerConsumer = new ListenerConsumer(this.listener, this.acknowledgingMessageListener);
        setRunning(true);
　　　　 // 看到这个 Future 似乎 get 到了啥东西。是的，多线程，这里使用了多线程-为每一个listenerConsumer开启一个线程
        this.listenerConsumerFuture = containerProperties
                .getConsumerTaskExecutor()
                .submitListenable(this.listenerConsumer);
    }

}

通过对这个类的分析，我们明白了 KafkaMessageListenerContainer 和 ConcurrentMessageListenerContainer  的关系，而且还发现 Spring 实际创建 kafka consumer 也是在这个容器中发生的，而且还嗅到了多线程。于是进一步确认，经过资料查阅果然：

//接口，封装原生KafkaConsumer，一个container封装一个consumer
interface MessageListenerContainer;
//单线程container实现，只启动一个consumer
class KafkaMessageListenerContainer implemets MessageListenerContainer;
//多线程container实现，负责创建多个KafkaMessageListenerContainer
class ConcurrentMessageListenerContainer implemets MessageListenerContainer;

//接口，工厂模式，container工厂，负责创建container，当使用@KafkaListener时需要提供
interface KafkaListenerContainerFactory<C extends MessageListenerContainer>;
//container工厂的唯一实现，且参数为多线程container，如果需要单线程，setConsurrency(null)即可，这也是默认参数
class KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<K, V>>

大家看到了没有，一切都水落石出：原来 Spring 提供了单线程和多线程两种方式使用 kafka consumer，而是否使用多线程由之前那个 int 属性  concurrency 变量决定，而且在分析 ConcurrentMessageListenerContainer  的时候知道它的默认值是1,也就是默认是使用单线程的。而且这个线程数还不能大于分区数。顺便提及一下：spring kafka 提供了两种提交方式，手动提交和自动提交，而手动提交 Spring 是如何监听到的呢，这个就是在 KafkaMessageListenerContainer 我们看到的那个 acknowledgingMessageListener 做出的贡献了。

消费者剩下花絮请看：spring kafka consumer原理解析二