springboot项目引入kafka订阅主题、产生消息、消费消息
基于 kafka+单节点+kraft+ssl+sasl 的部署的基础上,springboot项目引入kafka订阅主题、产生消息、消费消息
一、springboot项目引入kafka配置
1.生产者 application.yml 配置
spring:
kafka:
producer:
# Kafka服务器
bootstrap-servers: node1:8066
# 开启事务,必须在开启了事务的方法中发送,否则报错
transaction-id-prefix: kafkaTx-
# 发生错误后,消息重发的次数,开启事务必须设置大于0。
retries: 3
# acks=0 : 生产者在成功写入消息之前不会等待任何来自服务器的响应。
# acks=1 : 只要集群的首领节点收到消息,生产者就会收到一个来自服务器成功响应。
# acks=all :只有当所有参与复制的节点全部收到消息时,生产者才会收到一个来自服务器的成功响应。
# 开启事务时,必须设置为all
acks: all
# 当有多个消息需要被发送到同一个分区时,生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小,按照字节数计算。
batch-size: 16384
# 生产者内存缓冲区的大小。
buffer-memory: 1024000
# 键的序列化方式
key-serializer: org.springframework.kafka.support.serializer.JsonSerializer
# 值的序列化方式(建议使用Json,这种序列化方式可以无需额外配置传输实体类)
value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
security.protocol: SASL_SSL
ssl.keystore.location: /你的路径/ssl/kafka.keystore
ssl.keystore.password: yourpassword
ssl.truststore.location: /你的路径/ssl/kafka.truststore
ssl.truststore.password: yourpassword
ssl.endpoint.identification.algorithm:
ssl.key.password: yourpassword
sasl.mechanism: PLAIN
sasl.jaas.config: org.apache.kafka.common.security.scram.ScramLoginModule required username="yykj" password="123456";
2.生产者配置文件 KafkaProviderConfig.java
import org.apache.kafka.clients.CommonClientConfigs;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.config.SaslConfigs;
import org.apache.kafka.common.config.SslConfigs;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonSerializer;
import org.springframework.kafka.transaction.KafkaTransactionManager;
import java.util.HashMap;
import java.util.Map;
@SpringBootConfiguration
public class KafkaProviderConfig {
@Value("${spring.kafka.producer.bootstrap-servers}")
private String bootstrapServers;
@Value("${spring.kafka.producer.transaction-id-prefix}")
private String transactionIdPrefix;
@Value("${spring.kafka.producer.acks}")
private String acks;
@Value("${spring.kafka.producer.retries}")
private String retries;
@Value("${spring.kafka.producer.batch-size}")
private String batchSize;
@Value("${spring.kafka.producer.buffer-memory}")
private String bufferMemory;
@Value("${spring.kafka.security.protocol}")
private String securityProtocol;
@Value("${spring.kafka.ssl.keystore.location}")
private String keystoreLocation;
@Value("${spring.kafka.ssl.keystore.password}")
private String keystorePassword;
@Value("${spring.kafka.ssl.truststore.location}")
private String truststoreLocation;
@Value("${spring.kafka.ssl.truststore.password}")
private String truststorePassword;
@Value("${spring.kafka.ssl.endpoint.identification.algorithm}")
private String endpointIdentificationAlgorithm;
@Value("${spring.kafka.ssl.key.password}")
private String keyPassword;
@Value("${spring.kafka.sasl.mechanism}")
private String saslMechanism;
@Value("${spring.kafka.sasl.jaas.config}")
private String jaasConfig;
@Bean
public Map<String, Object> producerConfigs() {
Map<String, Object> props = new HashMap<>(16);
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
//acks=0 : 生产者在成功写入消息之前不会等待任何来自服务器的响应。
//acks=1 : 只要集群的首领节点收到消息,生产者就会收到一个来自服务器成功响应。
//acks=all :只有当所有参与复制的节点全部收到消息时,生产者才会收到一个来自服务器的成功响应。
//开启事务必须设为all
props.put(ProducerConfig.ACKS_CONFIG, acks);
//发生错误后,消息重发的次数,开启事务必须大于0
props.put(ProducerConfig.RETRIES_CONFIG, retries);
//当多个消息发送到相同分区时,生产者会将消息打包到一起,以减少请求交互. 而不是一条条发送
//批次的大小可以通过batch.size 参数设置.默认是16KB
//较小的批次大小有可能降低吞吐量(批次大小为0则完全禁用批处理)。
//比如说,kafka里的消息5秒钟Batch才凑满了16KB,才能发送出去。那这些消息的延迟就是5秒钟
//实测batchSize这个参数没有用
props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
//有的时刻消息比较少,过了很久,比如5min也没有凑够16KB,这样延时就很大,所以需要一个参数. 再设置一个时间,到了这个时间,
//即使数据没达到16KB,也将这个批次发送出去
props.put(ProducerConfig.LINGER_MS_CONFIG, "5000");
//生产者内存缓冲区的大小
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
//反序列化,和生产者的序列化方式对应
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
props.put(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG,securityProtocol);
props.put(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG,keystoreLocation);
props.put(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG,keystorePassword);
props.put(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG,truststoreLocation);
props.put(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG,truststorePassword);
props.put(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG,"JKS");
props.put(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG,"JKS");
props.put(SslConfigs.SSL_KEY_PASSWORD_CONFIG,keyPassword);
props.put(SslConfigs.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG,endpointIdentificationAlgorithm);
props.put(SaslConfigs.SASL_MECHANISM, saslMechanism);
props.put(SaslConfigs.SASL_JAAS_CONFIG,jaasConfig);
return props;
}
@Bean
public ProducerFactory<Object, Object> producerFactory() {
DefaultKafkaProducerFactory<Object, Object> factory = new DefaultKafkaProducerFactory<>(producerConfigs());
//开启事务,会导致 LINGER_MS_CONFIG 配置失效
factory.setTransactionIdPrefix(transactionIdPrefix);
return factory;
}
@Bean
public KafkaTransactionManager<Object, Object> kafkaTransactionManager(ProducerFactory<Object, Object> producerFactory) {
return new KafkaTransactionManager<>(producerFactory);
}
@Bean
public KafkaTemplate<Object, Object> kafkaTemplate() {
return new KafkaTemplate<>(producerFactory());
}
}
3.消费者 application.yml 配置
spring:
kafka:
consumer:
topic: yykj-topic
# Kafka服务器
bootstrap-servers: node1:8066
group-id: firstGroup
# 自动提交的时间间隔 在spring boot 2.X 版本中这里采用的是值的类型为Duration 需要符合特定的格式,如1S,1M,2H,5D
#auto-commit-interval: 2s
# 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理:
# earliest:当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,从头开始消费分区的记录
# latest:当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,消费新产生的该分区下的数据(在消费者启动之后生成的记录)
# none:当各分区都存在已提交的offset时,从提交的offset开始消费;只要有一个分区不存在已提交的offset,则抛出异常
auto-offset-reset: latest
# 是否自动提交偏移量,默认值是true,为了避免出现重复数据和数据丢失,可以把它设置为false,然后手动提交偏移量
enable-auto-commit: false
# 键的反序列化方式
# key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
# value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
key-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
# 值的反序列化方式(建议使用Json,这种序列化方式可以无需额外配置传输实体类)
value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
# key-serializer: org.springframework.kafka.support.serializer.JsonSerializer
# # 值的序列化方式(建议使用Json,这种序列化方式可以无需额外配置传输实体类)
# value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
# 配置消费者的 Json 反序列化的可信赖包,反序列化实体类需要
properties:
spring:
json:
trusted:
packages: "*"
# 这个参数定义了poll方法最多可以拉取多少条消息,默认值为500。如果在拉取消息的时候新消息不足500条,那有多少返回多少;如果超过500条,每次只返回500。
# 这个默认值在有些场景下太大,有些场景很难保证能够在5min内处理完500条消息,
# 如果消费者无法在5分钟内处理完500条消息的话就会触发reBalance,
# 然后这批消息会被分配到另一个消费者中,还是会处理不完,这样这批消息就永远也处理不完。
# 要避免出现上述问题,提前评估好处理一条消息最长需要多少时间,然后覆盖默认的max.poll.records参数
# 注:需要开启BatchListener批量监听才会生效,如果不开启BatchListener则不会出现reBalance情况
max-poll-records: 3
properties:
# 两次poll之间的最大间隔,默认值为5分钟。如果超过这个间隔会触发reBalance
max:
poll:
interval:
ms: 600000
# 当broker多久没有收到consumer的心跳请求后就触发reBalance,默认值是10s
session:
timeout:
ms: 10000
listener:
# 在侦听器容器中运行的线程数,一般设置为 机器数*分区数
concurrency: 4
# 自动提交关闭,需要设置手动消息确认
ack-mode: manual_immediate
# 消费监听接口监听的主题不存在时,默认会报错,所以设置为false忽略错误
missing-topics-fatal: false
# 两次poll之间的最大间隔,默认值为5分钟。如果超过这个间隔会触发reBalance
poll-timeout: 600000
security.protocol: SASL_SSL
ssl.keystore.location: /你的路径/ssl/kafka.keystore
ssl.keystore.password: yourpassword
ssl.truststore.location: /你的路径/ssl/kafka.truststore
ssl.truststore.password: yourpassword
ssl.endpoint.identification.algorithm:
ssl.key.password: yourpassword
sasl.mechanism: PLAIN
sasl.jaas.config: org.apache.kafka.common.security.scram.ScramLoginModule required username="yykj" password="123456";
4.消费者配置文件 KafkaConsumerConfig.java
import org.apache.kafka.clients.CommonClientConfigs;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.config.SaslConfigs;
import org.apache.kafka.common.config.SslConfigs;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
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.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.listener.ContainerProperties;
import org.springframework.kafka.support.serializer.JsonDeserializer;
import java.util.HashMap;
import java.util.Map;
@SpringBootConfiguration
public class KafkaConsumerConfig {
@Value("${spring.kafka.consumer.bootstrap-servers}")
private String bootstrapServers;
@Value("${spring.kafka.consumer.group-id}")
private String groupId;
@Value("${spring.kafka.consumer.enable-auto-commit}")
private boolean enableAutoCommit;
@Value("${spring.kafka.properties.session.timeout.ms}")
private String sessionTimeout;
@Value("${spring.kafka.properties.max.poll.interval.ms}")
private String maxPollIntervalTime;
@Value("${spring.kafka.consumer.max-poll-records}")
private String maxPollRecords;
@Value("${spring.kafka.consumer.auto-offset-reset}")
private String autoOffsetReset;
@Value("${spring.kafka.listener.concurrency}")
private Integer concurrency;
@Value("${spring.kafka.listener.missing-topics-fatal}")
private boolean missingTopicsFatal;
@Value("${spring.kafka.listener.poll-timeout}")
private long pollTimeout;
@Value("${spring.kafka.security.protocol}")
private String securityProtocol;
@Value("${spring.kafka.ssl.keystore.location}")
private String keystoreLocation;
@Value("${spring.kafka.ssl.keystore.password}")
private String keystorePassword;
@Value("${spring.kafka.ssl.truststore.location}")
private String truststoreLocation;
@Value("${spring.kafka.ssl.truststore.password}")
private String truststorePassword;
@Value("${spring.kafka.ssl.endpoint.identification.algorithm}")
private String endpointIdentificationAlgorithm;
@Value("${spring.kafka.ssl.key.password}")
private String keyPassword;
@Value("${spring.kafka.sasl.mechanism}")
private String saslMechanism;
@Value("${spring.kafka.sasl.jaas.config}")
private String jaasConfig;
@Bean
public Map<String, Object> consumerConfigs() {
Map<String, Object> props = new HashMap<>(16);
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
//是否自动提交偏移量,默认值是true,为了避免出现重复数据和数据丢失,可以把它设置为false,然后手动提交偏移量
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
//自动提交的时间间隔,自动提交开启时生效
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "2000");
//该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理:
//earliest:当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,从头开始消费分区的记录
//latest:当各分区下有已提交的offset时,从提交的offset开始消费;无提交的offset时,消费新产生的该分区下的数据(在消费者启动之后生成的记录)
//none:当各分区都存在已提交的offset时,从提交的offset开始消费;只要有一个分区不存在已提交的offset,则抛出异常
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
//两次poll之间的最大间隔,默认值为5分钟。如果超过这个间隔会触发reBalance
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, maxPollIntervalTime);
//这个参数定义了poll方法最多可以拉取多少条消息,默认值为500。如果在拉取消息的时候新消息不足500条,那有多少返回多少;如果超过500条,每次只返回500。
//这个默认值在有些场景下太大,有些场景很难保证能够在5min内处理完500条消息,
//如果消费者无法在5分钟内处理完500条消息的话就会触发reBalance,
//然后这批消息会被分配到另一个消费者中,还是会处理不完,这样这批消息就永远也处理不完。
//要避免出现上述问题,提前评估好处理一条消息最长需要多少时间,然后覆盖默认的max.poll.records参数
//注:需要开启BatchListener批量监听才会生效,如果不开启BatchListener则不会出现reBalance情况
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);
//当broker多久没有收到consumer的心跳请求后就触发reBalance,默认值是10s
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
//序列化(建议使用Json,这种序列化方式可以无需额外配置传输实体类)
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
props.put(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG,securityProtocol);
props.put(SslConfigs.SSL_KEYSTORE_LOCATION_CONFIG,keystoreLocation);
props.put(SslConfigs.SSL_KEYSTORE_PASSWORD_CONFIG,keystorePassword);
props.put(SslConfigs.SSL_TRUSTSTORE_LOCATION_CONFIG,truststoreLocation);
props.put(SslConfigs.SSL_TRUSTSTORE_PASSWORD_CONFIG,truststorePassword);
props.put(SslConfigs.SSL_KEYSTORE_TYPE_CONFIG,"JKS");
props.put(SslConfigs.SSL_TRUSTSTORE_TYPE_CONFIG,"JKS");
props.put(SslConfigs.SSL_KEY_PASSWORD_CONFIG,keyPassword);
props.put(SslConfigs.SSL_ENDPOINT_IDENTIFICATION_ALGORITHM_CONFIG,endpointIdentificationAlgorithm);
props.put(SaslConfigs.SASL_MECHANISM, saslMechanism);
props.put(SaslConfigs.SASL_JAAS_CONFIG,jaasConfig);
return props;
}
@Bean
public ConsumerFactory<Object, Object> consumerFactory() {
//配置消费者的 Json 反序列化的可信赖包,反序列化实体类需要
try(JsonDeserializer<Object> deserializer = new JsonDeserializer<>()) {
deserializer.trustedPackages("*");
return new DefaultKafkaConsumerFactory<>(consumerConfigs(), new JsonDeserializer<>(), deserializer);
}
}
@Bean(name="containerFactory1")
public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Object, Object>> kafkaListenerContainerFactory() {
ConcurrentKafkaListenerContainerFactory<Object, Object> factory = new ConcurrentKafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
//在侦听器容器中运行的线程数,一般设置为 机器数*分区数
factory.setConcurrency(concurrency);
//消费监听接口监听的主题不存在时,默认会报错,所以设置为false忽略错误
factory.setMissingTopicsFatal(missingTopicsFatal);
//自动提交关闭,需要设置手动消息确认
factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
factory.getContainerProperties().setPollTimeout(pollTimeout);
//设置为批量监听,需要用List接收
//factory.setBatchListener(true);
return factory;
}
}
二、springboot项目订阅主题、产生消息、消费消息
1.生产者发送消息结果处理
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.springframework.kafka.support.ProducerListener;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
@Component
public class KafkaSendResultHandler implements ProducerListener<Object, Object> {
@Override
public void onSuccess(ProducerRecord producerRecord, RecordMetadata recordMetadata) {
System.out.println("消息发送成功:" + producerRecord.toString());
}
@Override
public void onError(ProducerRecord producerRecord, @Nullable RecordMetadata recordMetadata, Exception exception) {
System.out.println("消息发送失败:" + producerRecord.toString() + exception.getMessage());
}
}
2.生产者发送消息到主题 yykjTopic
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/kafka")
//这个注解代表这个类开启Springboot事务,因为我们在Kafka的配置文件开启了Kafka事务,不然会报错
@Transactional(rollbackFor = RuntimeException.class)
public class KafkaController {
@Autowired
private KafkaTemplate<Object, Object> kafkaTemplate;
@RequestMapping("/sendMultiple")
public void sendMultiple() {
String message = "发送到Kafka的消息";
for (int i = 0;i < 10;i++) {
kafkaTemplate.send("yykjTopic", "发给 yykj " + (i+1));
System.out.println(message + i);
}
}
@RequestMapping("/send")
public String send() {
//这个User的代码我没放出来,自己随便写一个实体类,实体类一定要 implements Serializable
kafkaTemplate.send("yykjTopic", "发给 yykj 0");
return "send ok";
}
}
3.消费者订阅主题 yykjTopic
import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Slf4j
public class KafkaHandler {
// 主题名称最好不要带 "-" 否则 消费解析异常
@KafkaListener(groupId = "yykj-id", topics = "yykjTopic")
public void listen(String message) {
log.info("收到消息: "+message);
}
}
4.消费者kafka错误处理
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.Consumer;
import org.springframework.kafka.listener.KafkaListenerErrorHandler;
import org.springframework.kafka.listener.ListenerExecutionFailedException;
import org.springframework.lang.NonNull;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class KafkaErrorHandler implements KafkaListenerErrorHandler {
@Override
@NonNull
public Object handleError(@NonNull Message<?> message, @NonNull ListenerExecutionFailedException exception) {
return new Object();
}
@Override
@NonNull
public Object handleError(@NonNull Message<?> message, @NonNull ListenerExecutionFailedException exception, Consumer<?, ?> consumer) {
log.info("消息详情:" + message);
log.info("异常信息::" + exception);
log.info("消费者详情::" + consumer.groupMetadata());
log.info("监听主题::" + consumer.listTopics());
return KafkaListenerErrorHandler.super.handleError(message, exception, consumer);
}
}
三、开始测试
1.启动生产者
2.启动消费者
3.调用生产者接口 kafka/send
类:KafkaController 方法:send
GET http://localhost:8077/kafka/send
4.消费者收到消息
至此,springboot项目引入kafka订阅主题、产生消息、消费消息完成!!
上一章 基于 kafka+单节点+ssl 的基础上增加 sasl 配置