Java Examples for org.springframework.kafka.core.KafkaTemplate

@Test
public void listenerProperties() {
    load("spring.kafka.template.default-topic=testTopic", "spring.kafka.listener.ack-mode=MANUAL", "spring.kafka.listener.ack-count=123", "spring.kafka.listener.ack-time=456", "spring.kafka.listener.concurrency=3", "spring.kafka.listener.poll-timeout=2000", "spring.kafka.jaas.enabled=true", "spring.kafka.jaas.login-module=foo", "spring.kafka.jaas.control-flag=REQUISITE", "spring.kafka.jaas.options.useKeyTab=true");
    DefaultKafkaProducerFactory<?, ?> producerFactory = this.context.getBean(DefaultKafkaProducerFactory.class);
    DefaultKafkaConsumerFactory<?, ?> consumerFactory = this.context.getBean(DefaultKafkaConsumerFactory.class);
    KafkaTemplate<?, ?> kafkaTemplate = this.context.getBean(KafkaTemplate.class);
    KafkaListenerContainerFactory<?> kafkaListenerContainerFactory = this.context.getBean(KafkaListenerContainerFactory.class);
    assertThat(new DirectFieldAccessor(kafkaTemplate).getPropertyValue("producerFactory")).isEqualTo(producerFactory);
    assertThat(kafkaTemplate.getDefaultTopic()).isEqualTo("testTopic");
    DirectFieldAccessor dfa = new DirectFieldAccessor(kafkaListenerContainerFactory);
    assertThat(dfa.getPropertyValue("consumerFactory")).isEqualTo(consumerFactory);
    assertThat(dfa.getPropertyValue("containerProperties.ackMode")).isEqualTo(AckMode.MANUAL);
    assertThat(dfa.getPropertyValue("containerProperties.ackCount")).isEqualTo(123);
    assertThat(dfa.getPropertyValue("containerProperties.ackTime")).isEqualTo(456L);
    assertThat(dfa.getPropertyValue("concurrency")).isEqualTo(3);
    assertThat(dfa.getPropertyValue("containerProperties.pollTimeout")).isEqualTo(2000L);
    assertThat(this.context.getBeansOfType(KafkaJaasLoginModuleInitializer.class)).hasSize(1);
    KafkaJaasLoginModuleInitializer jaas = this.context.getBean(KafkaJaasLoginModuleInitializer.class);
    dfa = new DirectFieldAccessor(jaas);
    assertThat(dfa.getPropertyValue("loginModule")).isEqualTo("foo");
    assertThat(dfa.getPropertyValue("controlFlag")).isEqualTo(AppConfigurationEntry.LoginModuleControlFlag.REQUISITE);
    assertThat(((Map<String, String>) dfa.getPropertyValue("options"))).containsExactly(entry("useKeyTab", "true"));
}

@Test
public void testInboundRecord() throws Exception {
    Map<String, Object> props = KafkaTestUtils.consumerProps("test1", "true", embeddedKafka);
    props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
    DefaultKafkaConsumerFactory<Integer, String> cf = new DefaultKafkaConsumerFactory<Integer, String>(props);
    ContainerProperties containerProps = new ContainerProperties(topic1);
    KafkaMessageListenerContainer<Integer, String> container = new KafkaMessageListenerContainer<>(cf, containerProps);
    KafkaMessageDrivenChannelAdapter<Integer, String> adapter = new KafkaMessageDrivenChannelAdapter<>(container);
    QueueChannel out = new QueueChannel();
    adapter.setOutputChannel(out);
    adapter.afterPropertiesSet();
    adapter.setRecordMessageConverter(new MessagingMessageConverter() {

        @Override
        public Message<?> toMessage(ConsumerRecord<?, ?> record, Acknowledgment acknowledgment, Consumer<?, ?> consumer, Type type) {
            Message<?> message = super.toMessage(record, acknowledgment, consumer, type);
            return MessageBuilder.fromMessage(message).setHeader("testHeader", "testValue").build();
        }
    });
    adapter.start();
    ContainerTestUtils.waitForAssignment(container, 2);
    Map<String, Object> senderProps = KafkaTestUtils.producerProps(embeddedKafka);
    ProducerFactory<Integer, String> pf = new DefaultKafkaProducerFactory<>(senderProps);
    KafkaTemplate<Integer, String> template = new KafkaTemplate<>(pf);
    template.setDefaultTopic(topic1);
    template.sendDefault(0, 1487694048607L, 1, "foo");
    Message<?> received = out.receive(10000);
    assertThat(received).isNotNull();
    MessageHeaders headers = received.getHeaders();
    assertThat(headers.get(KafkaHeaders.RECEIVED_MESSAGE_KEY)).isEqualTo(1);
    assertThat(headers.get(KafkaHeaders.RECEIVED_TOPIC)).isEqualTo(topic1);
    assertThat(headers.get(KafkaHeaders.RECEIVED_PARTITION_ID)).isEqualTo(0);
    assertThat(headers.get(KafkaHeaders.OFFSET)).isEqualTo(0L);
    assertThat(headers.get(KafkaHeaders.RECEIVED_TIMESTAMP)).isEqualTo(1487694048607L);
    assertThat(headers.get(KafkaHeaders.TIMESTAMP_TYPE)).isEqualTo("CREATE_TIME");
    assertThat(headers.get("testHeader")).isEqualTo("testValue");
    template.sendDefault(1, null);
    received = out.receive(10000);
    assertThat(received).isNotNull();
    assertThat(received.getPayload()).isInstanceOf(KafkaNull.class);
    headers = received.getHeaders();
    assertThat(headers.get(KafkaHeaders.RECEIVED_MESSAGE_KEY)).isEqualTo(1);
    assertThat(headers.get(KafkaHeaders.RECEIVED_TOPIC)).isEqualTo(topic1);
    assertThat(headers.get(KafkaHeaders.RECEIVED_PARTITION_ID)).isEqualTo(0);
    assertThat(headers.get(KafkaHeaders.OFFSET)).isEqualTo(1L);
    assertThat((Long) headers.get(KafkaHeaders.RECEIVED_TIMESTAMP)).isGreaterThan(0L);
    assertThat(headers.get(KafkaHeaders.TIMESTAMP_TYPE)).isEqualTo("CREATE_TIME");
    assertThat(headers.get("testHeader")).isEqualTo("testValue");
    adapter.setMessageConverter(new RecordMessageConverter() {

        @Override
        public Message<?> toMessage(ConsumerRecord<?, ?> record, Acknowledgment acknowledgment, Consumer<?, ?> consumer, Type type) {
            throw new RuntimeException("testError");
        }

        @Override
        public ProducerRecord<?, ?> fromMessage(Message<?> message, String defaultTopic) {
            return null;
        }
    });
    PollableChannel errors = new QueueChannel();
    adapter.setErrorChannel(errors);
    template.sendDefault(1, "bar");
    Message<?> error = errors.receive(10000);
    assertThat(error).isNotNull();
    assertThat(error.getPayload()).isInstanceOf(ConversionException.class);
    assertThat(((ConversionException) error.getPayload()).getMessage()).contains("Failed to convert to message for: ConsumerRecord(topic = testTopic1");
    adapter.stop();
}

@Bean("kafkaTemplate")
public KafkaTemplate<String, String> kafkaTemplate() {
    KafkaTemplate<String, String> kafkaTemplate = new KafkaTemplate<String, String>(producerFactory());
    return kafkaTemplate;
}

@Bean
public IntegrationFlow toKafka(KafkaTemplate<?, ?> kafkaTemplate) {
    return  f -> f.handle(Kafka.outboundChannelAdapter(kafkaTemplate).messageKey(this.properties.getMessageKey()));
}

/**
	 * Create an initial {@link KafkaProducerMessageHandlerSpec}.
	 * @param kafkaTemplate the {@link KafkaTemplate} to use
	 * @param <K> the Kafka message key type.
	 * @param <V> the Kafka message value type.
	 * @return the Kafka09ProducerMessageHandlerSpec.
	 */
public static <K, V> KafkaProducerMessageHandlerSpec<K, V> outboundChannelAdapter(KafkaTemplate<K, V> kafkaTemplate) {
    return new KafkaProducerMessageHandlerSpec<K, V>(kafkaTemplate);
}