Spring Boot integra modo consumo kafka AckMode y consumo manual

gestión de dependencia

Importar dependencias en el archivo pom.xml

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>

Modificación del archivo de configuración

Configuración cuando necesita configurar AckMode usted mismo

spring:
  application:
    name: base.kafka
  kafka:
    bootstrap-servers: kafka服务地址1:端口,kafka服务地址2:端口,kafka服务地址3:端口
    producer:
      # 写入失败时，重试次数。当leader节点失效，一个repli节点会替代成为leader节点，此时可能出现写入失败，
      # 当retris为0时，produce不会重复。retirs重发，此时repli节点完全成为leader节点，不会产生消息丢失。
      retries: 0
      #procedure要求leader在考虑完成请求之前收到的确认数，用于控制发送记录在服务端的持久化，其值可以为如下：
      #acks = 0 如果设置为零，则生产者将不会等待来自服务器的任何确认，该记录将立即添加到套接字缓冲区并视为已发送。在这种情况下，无法保证服务器已收到记录，并且重试配置将不会生效（因为客户端通常不会知道任何故障），为每条记录返回的偏移量始终设置为-1。
      #acks = 1 这意味着leader会将记录写入其本地日志，但无需等待所有副本服务器的完全确认即可做出回应，在这种情况下，如果leader在确认记录后立即失败，但在将数据复制到所有的副本服务器之前，则记录将会丢失。
      #acks = all 这意味着leader将等待完整的同步副本集以确认记录，这保证了只要至少一个同步副本服务器仍然存活，记录就不会丢失，这是最强有力的保证，这相当于acks = -1的设置。
      #可以设置的值为：all, -1, 0, 1
      acks: 1
    consumer:
      group-id: testGroup
      # smallest和largest才有效，如果smallest重新0开始读取，如果是largest从logfile的offset读取。一般情况下我们都是设置smallest
      auto-offset-reset: earliest
      # 设置自动提交offset
      enable-auto-commit: true
      max-poll-records: 2
server:
  port: 8060

Consumir mensajes kafka

El modo de consumo soportado por kafka se establece en AbstractMessageListenerContainer.AckModela enumeración, la diferencia entre cada modo se presenta a continuación

	/**
	 * The offset commit behavior enumeration.
	 */
	public enum AckMode {

		/**
		 * Commit after each record is processed by the listener.
		 */
		RECORD,

		/**
		 * Commit whatever has already been processed before the next poll.
		 */
		BATCH,

		/**
		 * Commit pending updates after
		 * {@link ContainerProperties#setAckTime(long) ackTime} has elapsed.
		 */
		TIME,

		/**
		 * Commit pending updates after
		 * {@link ContainerProperties#setAckCount(int) ackCount} has been
		 * exceeded.
		 */
		COUNT,

		/**
		 * Commit pending updates after
		 * {@link ContainerProperties#setAckCount(int) ackCount} has been
		 * exceeded or after {@link ContainerProperties#setAckTime(long)
		 * ackTime} has elapsed.
		 */
		COUNT_TIME,

		/**
		 * User takes responsibility for acks using an
		 * {@link AcknowledgingMessageListener}.
		 */
		MANUAL,

		/**
		 * User takes responsibility for acks using an
		 * {@link AcknowledgingMessageListener}. The consumer
		 * immediately processes the commit.
		 */
		MANUAL_IMMEDIATE,

	}

Modo de reconocimiento

Modo de reconocimiento	efecto
MANUAL	Después de que el oyente consumidor (ListenerConsumer) procese cada lote de datos de encuesta(), llame manualmente a Acknowledgment.acknowledge() y envíe
MANUAL_IMMEDIATO	Confirme inmediatamente después de llamar manualmente Acknowledgment.acknowledge()
REGISTRO	Confirmado después de que el oyente del consumidor procesa cada registro (ListenerConsumer)
LOTE	Enviado después de que el agente de escucha del consumidor (ListenerConsumer) procese cada lote de datos de encuesta()
TIEMPO	Después de que el oyente consumidor (ListenerConsumer) procese cada lote de datos de encuesta(), envíe cuando el tiempo transcurrido desde el último envío sea mayor que TIME
CONTAR	Después de que el agente de escucha del consumidor (ListenerConsumer) procese cada lote de datos de encuesta(), envíelo cuando el número de registros procesados ​​sea mayor o igual a COUNT
COUNT_TIME	TIME o COUNT Enviar cuando se cumpla una de las condiciones

La clase de configuración para la fábrica de oyentes:

/**
 * kafka消费者配置
 */
@Configuration
@EnableKafka
public class KafkaConsumerConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String servers;
    //会话过期时长,consumer通过ConsumerCoordinator间歇性发送心跳
    //超期后,会被认为consumer失效,服务迁移到其他consumer节点.(group)
    //需要注意,Coordinator与kafkaConsumer共享底层通道,也是基于poll获取协调事件,但是会在单独的线程中
    @Value("${spring.kafka.consumer.session.timeout}")
    private String sessionTimeout;

    @Value("${spring.kafka.consumer.concurrency}")
    private int concurrency;
    //单次最多允许poll的消息条数.
    //此值不建议过大,应该考虑你的业务处理效率.
    @Value("${spring.kafka.consumer.maxpoll.records}")
    private int maxPollRecords;
    //两次poll之间的时间隔间最大值,如果超过此值将会被认为此consumer失效,触发consumer重新平衡.
    //此值必须大于,一个batch所有消息处理时间总和.
    //最大500000
    //2分钟
    @Value("${spring.kafka.consumer.maxpoll.interval}")
    private int maxPollIntervalMS;

    @Value("${spring.kafka.consumer.group-id}")
    private String groupId;


    @Bean
    public StringJsonMessageConverter converter() {
        return new StringJsonMessageConverter();
    }

    @Bean
    public KafkaListenerContainerFactory<?> batchDataFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        Map<String, Object> consumerConfig =  consumerConfigs();
        consumerConfig.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        ConsumerFactory<String, String>  consumerFactory = new DefaultKafkaConsumerFactory<>(consumerConfig);
        factory.setConsumerFactory(consumerFactory);
        factory.setConcurrency(concurrency);
        //设置为批量消费，每个批次数量在Kafka配置参数中设置ConsumerConfig.MAX_POLL_RECORDS_CONFIG
        factory.setBatchListener(true);
        factory.setMessageConverter(new BatchMessagingMessageConverter());
        //设置提交偏移量的方式
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
        factory.getContainerProperties().setPollTimeout(3000);
        return factory;
    }


    public Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap<>();
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //每一批数量
        propsMap.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, this.maxPollRecords);
        propsMap.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG,this.maxPollIntervalMS);
        return propsMap;
    }

    @Bean
    public TestMessages listener() {
        return new TestMessages();
    }

}

La configuración utilizada por el oyente.

@Component
public class TestMessages {

    /**
     * MANUAL   当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交
     * @param message
     * @param ack
     */
    @KafkaListener(containerFactory = "batchDataFactory" , topics = "kafka(topic名称)")
    public void onMessageManual(List<Object> message, Acknowledgment ack){
        log.info("batchDataFactory处理数据量：{}",message.size());
        message.forEach(item -> log.info("batchDataFactory处理数据内容：{}",item));
        ack.acknowledge();//直接提交offset
    }

}

MANUAL_IMMEDIATO

Confirmado después de que el oyente del consumidor procesa cada registro (ListenerConsumer)

Lo mismo y diferencia entre MANUAL y MANUAL_IMMEDIATE

Similitudes
Ambos modos requieren la confirmación manual de ack.acknowledge(); para completar el consumo del mensaje, de lo contrario, el consumidor volverá a recibir los datos cuando se reinicie la instancia del consumidor.

La diferencia entre los dos
es MANUAL: después de que se hayan procesado todos los resultados de la última encuesta, la cola se pone en cola y las compensaciones se confirman en una sola operación. Se puede considerar como comprometer compensaciones al final del lote
MANUAL_IMMEDIATE: Confirmar compensaciones tan pronto como se realice el reconocimiento en el subproceso de escucha. Se envían uno por uno durante la ejecución por lotes.

Para otros modos, puede modificar la configuración en la clase de fábrica de procesamiento por lotes:

    factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);

El contenido anterior puede no estar claro o ser incorrecto. Si los estudiantes de desarrollo lo encuentran, hágamelo saber a tiempo y modificaré el contenido relevante lo antes posible. Si mi contenido es de alguna ayuda para ti, por favor dame un pulgar hacia arriba. Su alabanza es la fuerza que me impulsa a seguir adelante.