springboot 接双 Kafka

配置文件

spring:
  kafka:
    # 第一个kafka的配置
    first:
      bootstrap-servers: *********
      #生产者配置
      producer:
        # Kafka提供的序列化和反序列化类
        key-serializer: org.apache.kafka.common.serialization.StringSerializer #序列化
        value-serializer: org.apache.kafka.common.serialization.StringSerializer
        retries: 1 # 消息发送重试次数
        #acks = 0：设置成 表示 producer 完全不理睬 leader broker 端的处理结果。此时producer 发送消息后立即开启下 条消息的发送，根本不等待 leader broker 端返回结果
        #acks= all 或者－1 ：表示当发送消息时， leader broker 不仅会将消息写入本地日志，同时还会等待所有其他副本都成功写入它们各自的本地日志后，才发送响应结果给，消息安全但是吞吐量会比较低。
        #acks = 1：默认的参数值。 producer 发送消息后 leader broker 仅将该消息写入本地日志，然后便发送响应结果给producer ，而无须等待其他副本写入该消息。折中方案，只要leader一直活着消息就不会丢失，同时也保证了吞吐量
        acks: 1 #应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
        batch-size: 16384 #批量大小
        properties:
          linger:
            ms: 0 #提交延迟
        buffer-memory: 33554432 # 生产端缓冲区大小
      # 消费者配置
      consumer:
        key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        # 默认分组id
        #group-id: DEMO_${random.uuid}
        #是否自动提交偏移量，默认值是true,为了避免出现重复数据和数据丢失，可以把它设置为false,然后手动提交偏移量
        enable-auto-commit: false
        #自动提交的时间间隔 在spring boot 2.X 版本中这里采用的是值的类型为Duration 需要符合特定的格式，如1S,1M,2H,5D
        auto-commit-interval: 1s
        #当kafka中没有初始offset或offset超出范围时将自动重置offset
        # earliest:重置为分区中最小的offset;
        # latest:重置为分区中最新的offset(消费分区中新产生的数据);
        # none:只要有一个分区不存在已提交的offset,就抛出异常;
        auto-offset-reset: earliest
        #批量消费每次最多消费多少条消息
        #每次拉取一条，一条条消费，当然是具体业务状况设置
        max-poll-records: 100
      listener:
        # 在侦听器容器中运行的线程数。
        concurrency: 5
        #listner负责ack，每调用一次，就立即commit
        ack-mode: manual
        missing-topics-fatal: false
    # 第二个kafka的配置
    second:
      bootstrap-servers: *********
      producer:
        # Kafka提供的序列化和反序列化类
        key-serializer: org.apache.kafka.common.serialization.StringSerializer #序列化
        value-serializer: org.apache.kafka.common.serialization.StringSerializer
        retries: 1 # 消息发送重试次数
        #acks = 0：设置成 表示 producer 完全不理睬 leader broker 端的处理结果。此时producer 发送消息后立即开启下 条消息的发送，根本不等待 leader broker 端返回结果
        #acks= all 或者－1 ：表示当发送消息时， leader broker 不仅会将消息写入本地日志，同时还会等待所有其他副本都成功写入它们各自的本地日志后，才发送响应结果给，消息安全但是吞吐量会比较低。
        #acks = 1：默认的参数值。 producer 发送消息后 leader broker 仅将该消息写入本地日志，然后便发送响应结果给producer ，而无须等待其他副本写入该消息。折中方案，只要leader一直活着消息就不会丢失，同时也保证了吞吐量
        acks: 1 #应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
        batch-size: 16384 #批量大小
        properties:
          linger:
            ms: 0 #提交延迟
        buffer-memory: 33554432 # 生产端缓冲区大小
      # 消费者配置
      consumer:
        key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        # 默认分组id
        #group-id: DEMO_${random.uuid}
        #是否自动提交偏移量，默认值是true,为了避免出现重复数据和数据丢失，可以把它设置为false,然后手动提交偏移量
        enable-auto-commit: false
        #自动提交的时间间隔 在spring boot 2.X 版本中这里采用的是值的类型为Duration 需要符合特定的格式，如1S,1M,2H,5D
        auto-commit-interval: 1s
        #当kafka中没有初始offset或offset超出范围时将自动重置offset
        # earliest:重置为分区中最小的offset;
        # latest:重置为分区中最新的offset(消费分区中新产生的数据);
        # none:只要有一个分区不存在已提交的offset,就抛出异常;
        auto-offset-reset: earliest
        #批量消费每次最多消费多少条消息
        #每次拉取一条，一条条消费，当然是具体业务状况设置
        max-poll-records: 1
      listener:
        # 在侦听器容器中运行的线程数。
        concurrency: 5
        #listner负责ack，每调用一次，就立即commit
        ack-mode: manual
        missing-topics-fatal: false

firstKafka

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

@Configuration
public class FirstKafkaConfig {

	/**
	 * @return 第一个kafka配置
	 */
	@Primary
	@ConfigurationProperties(prefix = "spring.kafka.first")
	@Bean
	public KafkaProperties firstKafkaProperties() {
		return new KafkaProperties();
	}

	/**
	 * @param firstKafkaProperties 第一个kafka配置
	 * @return 第一个kafka的生产者发送template
	 */
	@Primary
	@Bean(name = "firstKafkaTemplate")
	public KafkaTemplate<String, String> firstKafkaTemplate(
			@Autowired @Qualifier("firstKafkaProperties") KafkaProperties firstKafkaProperties) {
		return new KafkaTemplate<>(firstProducerFactory(firstKafkaProperties));
	}

	/**
	 * 构建第一个kafka的消费者监听容器工厂
	 * @param firstKafkaProperties 第一个kafka配置
	 * @return 第一个kafka的消费者监听容器工厂
	 */
	@Bean("firstKafkaListenerContainerFactory")
	public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>> firstKafkaListenerContainerFactory(
			@Autowired @Qualifier("firstKafkaProperties") KafkaProperties firstKafkaProperties) {
		ConcurrentKafkaListenerContainerFactory<Integer, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
		factory.setConsumerFactory(firstConsumerFactory(firstKafkaProperties));
		return factory;
	}

	/**
	 * 新建第一个kafka的消费者工厂
	 * @param firstKafkaProperties 第一个kafka配置
	 * @return 第一个kafka的消费者工厂
	 */
	private ConsumerFactory<? super Integer, ? super String> firstConsumerFactory(
			KafkaProperties firstKafkaProperties) {
		return new DefaultKafkaConsumerFactory<>(firstKafkaProperties.buildConsumerProperties());
	}

	/**
	 * 新建第一个kafka的生产者工厂
	 * @param firstKafkaProperties 第一个kafka配置
	 * @return 第一个kafka的生产者工厂
	 */
	public DefaultKafkaProducerFactory<String, String> firstProducerFactory(KafkaProperties firstKafkaProperties) {
		return new DefaultKafkaProducerFactory<>(firstKafkaProperties.buildProducerProperties());
	}
}

secondKafka

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

@Configuration
public class SecondKafkaConfig {

	/**
	 * @return 第二个kafka配置
	 */
	@ConfigurationProperties(prefix = "spring.kafka.second")
	@Bean
	public KafkaProperties secondKafkaProperties() {
		return new KafkaProperties();
	}

	/**
	 *
	 * @param secondKafkaProperties 第二个kafka配置
	 * @return 第二个kafka的生产者发送template
	 */
	@Bean(name = "secondKafkaTemplate")
	public KafkaTemplate<String, String> secondKafkaTemplate(
			@Autowired @Qualifier("secondKafkaProperties") KafkaProperties secondKafkaProperties) {
		return new KafkaTemplate<>(secondProducerFactory(secondKafkaProperties));
	}

	/**
	 *
	 * @param secondKafkaProperties 第二个kafka配置
	 * @return 第二个kafka的消费者监听容器工厂
	 */
	@Bean("secondKafkaListenerContainerFactory")
	public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>> secondKafkaListenerContainerFactory(
			@Autowired @Qualifier("secondKafkaProperties") KafkaProperties secondKafkaProperties) {
		ConcurrentKafkaListenerContainerFactory<Integer, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
		factory.setConsumerFactory(secondConsumerFactory(secondKafkaProperties));
		return factory;
	}

	/**
	 *
	 * @param secondKafkaProperties 第二个kafka配置
	 * @return 第二个kafka的消费者工厂
	 */
	private ConsumerFactory<? super Integer, ? super String> secondConsumerFactory(
			KafkaProperties secondKafkaProperties) {
		return new DefaultKafkaConsumerFactory<>(secondKafkaProperties.buildConsumerProperties());
	}

	/**
	 *
	 * @param secondKafkaProperties 第二个kafka配置
	 * @return 第二个kafka的生产者工厂
	 */
	public DefaultKafkaProducerFactory<String, String> secondProducerFactory(KafkaProperties secondKafkaProperties) {
		return new DefaultKafkaProducerFactory<>(secondKafkaProperties.buildProducerProperties());
	}
}

消息监听方法

containerFactory 为Kafka消费监听容器工厂

    @KafkaListener(id = "groupid", topics = { "${kafka.***.topic}" }, containerFactory = "firstKafkaListenerContainerFactory")
	public void awsSecretMessage(@Payload String strObj, Acknowledgment ack) {
		if (StringUtils.isEmpty(strObj)) {
			return;
		}
		log.info("CMS kafka消息内容 = {}", strObj);
		/*****************业务逻辑***********************/
		ack.acknowledge();
	}