spring-kafka-2.8.2使用示例

前言

kafka是目前IT中常用组件，java+kafka、python+kafka、lua+kafka、go+kafka是常见组合。

kafka常用语业务层的异步数据处理。

也用于agent层服务器数据的采集。

大数据，ELK中kafka更是核心组件，flink+kafka进行海量数据的处理。

云计算心跳管理，IT七大对象自动化监管，lua+kafka也是常见场景。

kafka很牛，虽然和redis内存库不同，采用磁盘进行数据存储但是读写速度超强，因为他是顺序读写。

所以使用场景下，快速掌握kafka的使用及其重要，当然至于Kafka的saas化不需要太多考虑，只需要直接云上申请服务集群即可。

使用场景说明-springboot+kafka

在Spring Boot微服务集成Kafka客户端spring-kafka-2.8.2操作Kafka。
使用Spring封装的KafkaTemplate操作Kafka生产者Producer。

使用Spring封装的@KafkaListener操作Kafka的消费者Consumer。

JDK 1.8,

Spring Boot 2.7.11, -- springboot 3.x之后有了巨大变化，但是目前企业用的主流JDK还是8，JDK21虽然很新，但是企业追求的是稳定。

spring-kafka-2.8.2。

基础概念

Event：An event records the fact that "something happened" in the world or in your business. It is also called record or message in the documentation.

Broker：一个Kafka节点就是一个broker；多个Broker可以组成一个Kafka集群。

Topic：Kafka根据Topic对消息进行归类，发布到Kafka的每条消息都需要指定一个Topic。

Producer：消息生产者，向Broker发送消息的客户端。

Consumer：消息消费者，从Broker读取消息的客户端。

ConsumerGroup：每个Consumer属于一个特定的ConsumerGroup，一条消息可以被多个不同的ConsumerGroup消费；但是一个ConsumerGroup中只能有一个Consumer能够消费该消息。

Partition：一个topic可以分为多个partition，每个partition内部消息是有序的。

publish：发布，使用Producer向Kafka写入数据。

subscribe：订阅，使用Consumer从Kafka读取数据。

kafka使用demo

添加依赖

        <!--kafka-->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>2.8.2</version>
        </dependency>

增加kafka配置

这里使用的application.properties文件，当然目前yaml也非常流行，但是自动化部署中yaml不太好用，对缩进要求太严格

其实最完美的配置是json，但是目前看业界很少用，只有前端vue项目，或者底层go-agent类项目，采用json配置的较多。

特别说明：

网上基本千篇一律的demo都是自动装配，标准配置，但是在真实的IT生产中是不可能的。

application.properties文件也不会使用标准的K-V配置，自动装配。

就拿一个出海项目为例可能几十个profile配置文件，真实业务也往往使用多集群，多实例，账号密码还要加密认证，使用3~4级工作秘钥进行安全加固。

往往都需要手工装载，初始化bean，然后再使用。

spring.kafka.demo.bootstrap-servers=192.168.19.203:29001
spring.kafka.demo.username=demo
spring.kafka.demo.password=demo#123
spring.kafka.demo.kafka.ssl.truststore.password=demo@123
spring.kafka.demo.consumer.group-id=test_group_id
spring.kafka.demo.enable-auto-commit=true
spring.kafka.demo.auto-offset-rest=latest
spring.kafka.demo.auto-commit-interval=100
spring.kafka.demo.max-poll-records=100

装载bean

我们不使用：spring-boot-autoconfigure-2.6.3.jar，@ConfigurationProperties 自动去状态bean。

springboot提供了大量的data-template，有个大的json罗列了各种组件start的模板。

package com.wht.test.kafka;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.config.SslConfigs;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.system.ApplicationHome;
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.*;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

/**
 * desc
 *
 * @Author 红尘过客
 * @DateTime 2023-07-29 21:54:25
 */
@Configuration
@Slf4j
public class KafkaConfig {
    @Value("$(spring.kafka.demo.bootstrap-servers)")
    private String kafkaStrapServers;

    @Value("$(spring.kafka.demo.username:null)")
    private String username;

    @Value("$(spring.kafka.demo.password:null)")
    private String password;

    @Value("$(spring.kafka.demo.kafka.ssl.truststore.password:null)")
    private String jskPassword;

    @Value("$(spring.kafka.demo.consumer.group-id)")
    private String testGroupId;

    @Value("$(spring.kafka.demo.enable-auto-commit)")
    private String enableAutoCommit;

    @Value("$(spring.kafka.demo.auto-offset-rest)")
    private String autoOffsetRest;

    @Value("$(spring.kafka.demo.auto-commit-interval)")
    private String autoCommitInterval;

    @Value("$(spring.kafka.demo.max-poll-records)")
    private String maxPollRecords;

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

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(getConsumerFactory());
        factory.setConcurrency(3);
        factory.setBatchListener(true);
        factory.getContainerProperties().setPollTimeout(3000);
        return factory;
    }

    private ProducerFactory<String, String> getProducerFactory() {
        return new DefaultKafkaProducerFactory<String, String>(producerConfig());
    }

    private ConsumerFactory<String, String> getConsumerFactory() {
        return new DefaultKafkaConsumerFactory<String, String>(consumerConfig());
    }

    private Map<String, Object> producerConfig() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaStrapServers);
        props.put(ProducerConfig.RETRIES_CONFIG, 0);
        props.put(ProducerConfig.ACKS_CONFIG, "1");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        setKafkaSecurity(props);
        return props;
    }

    private void setKafkaSecurity(Map<String, Object> props) {
        if (username != null) {
            props.put("security.protocol", "SASL.SSL");
            props.put("sasl.mechanism", "PLAIN");
            props.put("sasl.jaas.config", "org.apache.kafka.common.security.plain.PlainLoginModule " +
                    "required username=\"" + username + "\" password=\"" + password + "\";");
            props.put("ssl.truststore.password", jskPassword);
            props.put("ssl.endpoint.identification.algorithm", "");
            props.put(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG, getConfigFilePath());
        }
    }

    private Map<String, Object> consumerConfig() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkaStrapServers);
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        props.put(ConsumerConfig.GROUP_ID_CONFIG, testGroupId);
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetRest);
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        setKafkaSecurity(props);
        return props;
    }

    private String getConfigFilePath() {
        ApplicationHome applicationHome = new ApplicationHome(this.getClass());
        String rootPath = applicationHome.getSource().getParentFile().toString();
        String configFilePath = rootPath + File.separator + "resources" + File.separator + "client.truststore.jks";
        File configFile = new File(configFilePath);
        if (!configFile.exists()) {
            configFilePath = rootPath + File.separator + "config" + File.separator + "client.truststore.jks";
        }
        log.info("jks file path = {}", configFilePath);
        return configFilePath;
    }
}

推送消息示例

package com.wht.test.kafka;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * 发送消息demo
 *
 * @Author 红尘过客
 * @DateTime 2023-07-29 22:39:58
 */
@Component
@Slf4j
public class ProducerTest {
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    private int count;

    @Scheduled(cron = "*/30 * * * * ?")
    public void run() {
        for (int i = 0; i < 100; i++) {
            kafkaTemplate.send("test_kafka_topic", "test_message_" + count++);
            log.info("推送消息成功。。。。。。。。。。。。。。", count);
        }
    }
}

消费消息示例

package com.wht.test.kafka;

import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * kafka消费验证
 *
 * @Author 红尘过客
 * @DateTime 2023-07-29 22:43:04
 */
@Component
@Slf4j
public class KafkaListenTest {

    @KafkaListener(topics = "", containerFactory = "test_kafka_topic", clientIdPrefix = "test_kafka_topic-", concurrency = "3")
    public void Listen(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            log.info("批量消费消息成功-{}", list.size());
            log.info(list.get(i));
        }

    }
}

暂时记录

kafka的使用很简单，但是也会遇到各种问题。

例如2分钟推送5亿数据，消费过程中可能遇到OOM，cpu爆掉，参数配置不合理，消费组掉线。

JKS启动报错等等问题。