org.springframework.kafka.support.Acknowledgment Java Examples

@KafkaListener(topics = {
    "mysqlcdc.cdc.USERS",
    "mysqlcdc.cdc.JOBS",
    "mysqlcdc.cdc.ADDRESSES"})
@Timed
public void handleEvents(List<ConsumerRecord<String, DebeziumEvent>> records,
                            Acknowledgment acknowledgment) {

  LOGGER.debug("Request to process {} records", records.size());

  List<ConsumerRecord<String, DebeziumEvent>> sortedRecords = records.stream()
      .sorted(Comparator.comparing(r -> r.value().getPayload().getDate()))
      .collect(Collectors.toList());

  sortedRecords.forEach(record -> {

    LOGGER.debug("Request to handle {} event in the topic {}", record.value().getPayload().getOperation(), record.topic());

    handlerFactory.getHandler(record.topic()).process(record.value());

  });

  acknowledgment.acknowledge();
}
 

/**
 * Receiving consumer messages on multiple topics
 *
 * @param records
 * @param ack
 */
@KafkaListener(topicPattern = TOPIC_KAFKA_RECEIVE_PATTERN, containerFactory = BEAN_KAFKA_BATCH_FACTORY)
public void onMetricReceive(List<ConsumerRecord<byte[], Bytes>> records, Acknowledgment ack) {
	try {
		if (log.isDebugEnabled()) {
			log.debug("Receive metric records - {}", records);
		}
		if (log.isInfoEnabled()) {
			log.info("Receive metric records size - {}", records.size());
		}

		doProcess(records, new MultiAcknowledgmentState(ack));
	} catch (Exception e) {
		log.error(String.format("Failed to receive process for ", records.size()), e);
	}
}
 

@StreamListener("index-message-in")
public void indexTorrent(Message<Torrent> message) {
	try {
		Acknowledgment acknowledgment = message.getHeaders().get(KafkaHeaders.ACKNOWLEDGMENT, Acknowledgment.class);
		Torrent torrent = message.getPayload();
		log.debug("Index torrent to elasticsearch, info hash is {}", torrent.getInfoHash());
		torrentService.index(torrent);
		//no error, execute acknowledge
		if (acknowledgment != null) {
			acknowledgment.acknowledge();
		}
	} catch (Exception e) {
		log.error("Index torrent error: {}", e);
	}
}
 

/**
 * Invoked with data from kafka.
 *
 * @param data           the data to be processed.
 * @param acknowledgment the acknowledgment.
 */
@Override
public void onMessage(ConsumerRecord data, Acknowledgment acknowledgment) {
    QueueMessage queueMessage = KafkaTool.covertToQueueMessage(data);
    publishableExceptionListener.handle(queueMessage, context -> {
        if (acknowledgment != null) {
            acknowledgment.acknowledge();
        }
    });
}
 

/**
 * Invoked with data from kafka.
 *
 * @param data           the data to be processed.
 * @param acknowledgment the acknowledgment.
 */
@Override
public void onMessage(ConsumerRecord<String, String> data, Acknowledgment acknowledgment) {
    QueueMessage queueMessage = KafkaTool.covertToQueueMessage(data);
    applicationMessageListener.handle(queueMessage, context -> {
        if (acknowledgment != null) {
            acknowledgment.acknowledge();
        }
    });
}
 

/**
 * Invoked with data from kafka.
 *
 * @param data           the data to be processed.
 * @param acknowledgment the acknowledgment.
 */
@Override
public void onMessage(ConsumerRecord<String, String> data, Acknowledgment acknowledgment) {
    QueueMessage queueMessage = KafkaTool.covertToQueueMessage(data);
    commandListener.handle(queueMessage, context -> {
        if (acknowledgment != null) {
            acknowledgment.acknowledge();
        }
    });
}
 

/**
 * Invoked with data from kafka. The default implementation throws
 * {@link UnsupportedOperationException}.
 *
 * @param data           the data to be processed.
 * @param acknowledgment the acknowledgment.
 */
@Override
public void onMessage(ConsumerRecord<String, String> data, Acknowledgment acknowledgment) {
    QueueMessage queueMessage = KafkaTool.covertToQueueMessage(data);
    domainEventListener.handle(queueMessage, context -> {
        if (acknowledgment != null) {
            acknowledgment.acknowledge();
        }
    });
}
 

/**
 * 指定消费某一个分区
 * @KafkaListener(id = "",topicPartitions ={@TopicPartition(topic=topic,partitions = {"1"})},containerFactory = "userRegisterSuccKafkaListenerContainerFactory",groupId = group_id)
 */
@KafkaListener(id = "",topics = topic,containerFactory = "userRegisterSuccKafkaListenerContainerFactory",groupId = group_id)
public void receiveInfo(Map userVerifyMap, Acknowledgment acknowledgment){
    try {
        log.info("收到一条注册消息"+userVerifyMap);
        sendMail(userVerifyMap);
        acknowledgment.acknowledge();//手动提交消息
    }catch (Exception e){
        e.printStackTrace();
    }
}
 

@StreamListener("torrent-message-in")
public void handleTorrent(Message<Torrent> message) {
	try {
		Acknowledgment acknowledgment = message.getHeaders().get(KafkaHeaders.ACKNOWLEDGMENT, Acknowledgment.class);
		Torrent torrent = message.getPayload();
		log.debug("Save torrent to MongoDB, info hash is {}", torrent.getInfoHash());
		torrentService.upsert(torrent);
		//no error, execute acknowledge
		if (acknowledgment != null) {
			acknowledgment.acknowledge();
		}
	} catch (Exception e) {
		log.error("Insert or update torrent error: {}", e);
	}
}
 

protected void handleConsumerRecord(final ConsumerRecord<String, String> consumerRecord, final Acknowledgment ack) {
    LOG.info("Received {}", ConsumerRecordLoggingHelper.toLogSafeString(consumerRecord, payloadSensitive));
    final EventProcessingState state = processAndMapExceptionsToState(consumerRecord);
    if (EventProcessingState.UNEXPECTED_ERROR == state) {
        unprocessableEventService.save(new UnprocessedEventEntity(consumerRecord));
    } else if (EventProcessingState.TEMPORARY_ERROR == state) {
        throw new TemporaryKafkaProcessingError("Message processing failed temporarily");
    }
    ack.acknowledge();
}
 

@KafkaListener(topics = KafkaConsts.TOPIC_TEST, containerFactory = "ackContainerFactory")
public void handleMessage(ConsumerRecord record, Acknowledgment acknowledgment) {
    try {
        String message = (String) record.value();
        log.info("收到消息: {}", message);
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    } finally {
        // 手动提交 offset
        acknowledgment.acknowledge();
    }
}
 

@Override
public void onMessage(ConsumerRecord<Object, Object> data,
		Acknowledgment acknowledgment, Consumer<?, ?> consumer) {
	onMessage(data);
}
 

@Override
public void onMessage(ConsumerRecord<Object, Object> data,
		Acknowledgment acknowledgment) {
	onMessage(data);
}
 

@Override
public void onMessage(ConsumerRecord<String, String> record, Acknowledgment acknowledgment) {
	System.out.println("Received: " + record.value());
	acknowledgment.acknowledge();
	this.latch.countDown();
}
 

@Test
@SuppressWarnings("unchecked")
public void testManualAckSucceedsWhenAutoCommitOffsetIsTurnedOff() throws Exception {
	Binder binder = getBinder();

	DirectChannel moduleOutputChannel = createBindableChannel("output",
			createProducerBindingProperties(createProducerProperties()));
	QueueChannel moduleInputChannel = new QueueChannel();

	Binding<MessageChannel> producerBinding = binder.bindProducer(
			"testManualAckSucceedsWhenAutoCommitOffsetIsTurnedOff",
			moduleOutputChannel, createProducerProperties());

	ExtendedConsumerProperties<KafkaConsumerProperties> consumerProperties = createConsumerProperties();
	consumerProperties.getExtension().setAutoCommitOffset(false);

	Binding<MessageChannel> consumerBinding = binder.bindConsumer(
			"testManualAckSucceedsWhenAutoCommitOffsetIsTurnedOff", "test",
			moduleInputChannel, consumerProperties);

	String testPayload1 = "foo" + UUID.randomUUID().toString();
	Message<?> message1 = org.springframework.integration.support.MessageBuilder
			.withPayload(testPayload1.getBytes()).build();

	// Let the consumer actually bind to the producer before sending a msg
	binderBindUnbindLatency();
	moduleOutputChannel.send(message1);

	Message<?> receivedMessage = receive(moduleInputChannel);
	assertThat(receivedMessage).isNotNull();
	assertThat(receivedMessage.getHeaders().get(KafkaHeaders.ACKNOWLEDGMENT))
			.isNotNull();
	Acknowledgment acknowledgment = receivedMessage.getHeaders()
			.get(KafkaHeaders.ACKNOWLEDGMENT, Acknowledgment.class);
	try {
		acknowledgment.acknowledge();
	}
	catch (Exception e) {
		fail("Acknowledge must not throw an exception");
	}
	finally {
		producerBinding.unbind();
		consumerBinding.unbind();
	}
}
 

@Override
public void onMessage(ConsumerRecord<Integer, String> data, Acknowledgment acknowledgment) {
    log.info("received: " + data);
}
 

@KafkaListener(topics = "order")
public void order(Invoice invoice, Acknowledgment acknowledgment) {
	log.info("Received invoice " + invoice.getId());
	invoiceService.generateInvoice(invoice);
	acknowledgment.acknowledge();
}
 

@KafkaListener(topics = "order")
public void order(Shipment shipment, Acknowledgment acknowledgment) {
	log.info("Received shipment " + shipment.getId());
	shipmentService.ship(shipment);
	acknowledgment.acknowledge();
}
 

@KafkaListener(topics = "${eventing.topic_name}")
public void listen(final ConsumerRecord<String, String> consumerRecord, final Acknowledgment ack) {
    super.handleConsumerRecord(consumerRecord, ack);
}
 

public MultiAcknowledgmentState(Acknowledgment ack) {
	super();
	this.ack = ack;
}
 

/**
 * 消费者拿到消息时就提交offset,消费失败时在消费者内部重试
 * 避免消费者服务中多个事件处理程序情况下，一个处理程序失败，导致其他处理程序重试的问题
 *
 * @param data
 * @param acknowledgment
 */
@Override
public void onMessage(ConsumerRecord<String, EventArg> data, Acknowledgment acknowledgment) {
    if (data == null) return;
    dispatcher.enqueue(data.value());
    acknowledgment.acknowledge();
}