概要在这里插入代码片
spring结合kafka使用
包括：
1、kafaka的安装和本机调试；
2、消息生产端发送；
3、消息消费端接受；
安装和调试
方法一：官网下载，解压就行
方法二：使用命令行
下载：
cd ~ && mkdir -p kafka && cd kafka && curl -O https://archive.apache.org/dist/kafka/2.8.1/kafka_2.13-2.8.1.tgz
解压
cd ~/kafka && tar -xzf kafka_2.13-2.8.1.tgz && rm kafka_2.13-2.8.1.tgz && mv kafka_2.13-2.8.1 kafka-2.8.1
配置环境变量
echo '
# Kafka Environment Variables
export KAFKA_HOME=$HOME/kafka/kafka-2.8.1
export PATH=$PATH:$KAFKA_HOME/bin' >> ~/.zshrc && source ~/.zshrc
启动zookeeper
cd ~/kafka/kafka-2.8.1
bin/zookeeper-server-start.sh config/zookeeper.properties
启动kafka
cd ~/kafka/kafka-2.8.1
bin/kafka-server-start.sh config/server.properties
基本命令：
##创建主题
bin/kafka-topics.sh --create --topic test-topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1
##查看主题
bin/kafka-topics.sh --list --bootstrap-server localhost:9092
##发送消息
bin/kafka-console-producer.sh --topic test-topic --bootstrap-server localhost:9092
##接受消息
bin/kafka-console-consumer.sh --topic test-topic --from-beginning --bootstrap-server localhost:9092
##删除全部消息
bin/kafka-configs.sh --alter --entity-type topics --entity-name test-topic --add-config retention.bytes=0 --zookeeper localhost:9092
##查看偏移的消息内容，比如63
bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic topic1 --partition 0 --offset 63
生产端
server.port=8088
spring.application.name=producer
spring.kafka.producer.bootstrap-servers=localhost:9092
spring.kafka.producer.retries=3
spring.kafka.producer.acks=all
spring.kafka.producer.batch-size=16384
spring.kafka.producer.buffer-memory=1024000
spring.kafka.producer.key-serializer=org.springframework.kafka.support.serializer.JsonSerializer
spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer
/**
* @date 2022/10/31 18:05
* kafka配置，也可以写在yml，这个文件会覆盖yml
*/
@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;
@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);
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());
}
}
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;
/**
* @date 2022/10/31 15:41
* kafka消息发送回调
*/
@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());
}
}
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.MessageHeaders;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
* @date 2022/10/31 14:05
* kafka发送消息
*/
@RestController
@RequestMapping("/provider")
//这个注解代表这个类开启Springboot事务，因为我们在Kafka的配置文件开启了Kafka事务，不然会报错
//@Transactional(rollbackFor = RuntimeException.class)
public class KafkaController {
private final KafkaTemplate<Object, Object> kafkaTemplate;
public KafkaController(KafkaTemplate<Object, Object> kafkaTemplate, KafkaSendResultHandler kafkaSendResultHandler) {
this.kafkaTemplate = kafkaTemplate;
//回调方法、异常处理
this.kafkaTemplate.setProducerListener(kafkaSendResultHandler);
}
@RequestMapping("/sendMultiple")
public void sendMultiple() {
String message = "发送到Kafka的消息";
for (int i = 0;i < 10;i++) {
kafkaTemplate.send("topic1", "发送到Kafka的消息" + i);
System.out.println(message + i);
}
}
@RequestMapping("/send")
public void send() {
//这个User的代码我没放出来，自己随便写一个实体类，实体类一定要 implements Serializable
User user = new User(1, "徐一杰");
kafkaTemplate.send("topic1", user);
kafkaTemplate.send("topic2", "发给topic2");
try{
sendDemo();
}catch (Exception e){
System.out.println(e);
}
}
/**
* Kafka提供了多种构建消息的方式
* @throws ExecutionException
* @throws InterruptedException
* @throws TimeoutException
*/
public void sendDemo() throws ExecutionException, InterruptedException, TimeoutException {
//使用ProducerRecord发送消息
ProducerRecord<Object, Object> producerRecord = new ProducerRecord<>("topic1", "use ProducerRecord to send message");
kafkaTemplate.send(producerRecord);
//使用Message发送消息
Map<String, Object> map = new HashMap<>();
map.put(KafkaHeaders.TOPIC, "topic1");
map.put(KafkaHeaders.PARTITION_ID, 0);
map.put(KafkaHeaders.MESSAGE_KEY, 0);
GenericMessage<Object> message = new GenericMessage<>("use Message to send message", new MessageHeaders(map));
kafkaTemplate.send(message);
//后面的get代表同步发送，括号内时间可选，代表超过这个时间会抛出超时异常，但是仍会发送成功
kafkaTemplate.send("topic1", "发给topic1").get(1, TimeUnit.MILLISECONDS);
}
消费端
spring.application.name=demo
server.port: 8087
spring.kafka.consumer.bootstrap-servers= localhost:9092
spring.kafka.consumer.group-id= firstGroup
spring.kafka.consumer.auto-offset-reset= latest
spring.kafka.consumer.enable-auto-commit= false
spring.kafka.consumer.key-deserializer= org.springframework.kafka.support.serializer.JsonDeserializer
spring.kafka.consumer.value-deserializer=org.springframework.kafka.support.serializer.JsonDeserializer
spring.kafka.consumer.max-poll-records= 3
/**
* kafka配置，也可以写在yml，这个文件会覆盖yml
*/
@Configuration
@EnableKafka
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;
@Bean
public Map<String, Object> consumerConfigs() {
Map<String, Object> propsMap = new HashMap<>(16);
propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
//是否自动提交偏移量，默认值是true，为了避免出现重复数据和数据丢失，可以把它设置为false，然后手动提交偏移量
propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
//自动提交的时间间隔，自动提交开启时生效
propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "2000");
//该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理：
//earliest：当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费分区的记录
//latest：当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据（在消费者启动之后生成的记录）
//none：当各分区都存在已提交的offset时，从提交的offset开始消费；只要有一个分区不存在已提交的offset，则抛出异常
propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
//两次poll之间的最大间隔，默认值为5分钟。如果超过这个间隔会触发reBalance
// propsMap.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, maxPollIntervalTime);
//这个参数定义了poll方法最多可以拉取多少条消息，默认值为500。如果在拉取消息的时候新消息不足500条，那有多少返回多少；如果超过500条，每次只返回500。
//这个默认值在有些场景下太大，有些场景很难保证能够在5min内处理完500条消息，
//如果消费者无法在5分钟内处理完500条消息的话就会触发reBalance,
//然后这批消息会被分配到另一个消费者中，还是会处理不完，这样这批消息就永远也处理不完。
//要避免出现上述问题，提前评估好处理一条消息最长需要多少时间，然后覆盖默认的max.poll.records参数
//注：需要开启BatchListener批量监听才会生效，如果不开启BatchListener则不会出现reBalance情况
propsMap.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);
//当broker多久没有收到consumer的心跳请求后就触发reBalance，默认值是10s
// propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
//序列化（建议使用Json，这种序列化方式可以无需额外配置传输实体类）
propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, JsonDeserializer.class);
return propsMap;
}
@Bean
public ConsumerFactory<Object, Object> consumerFactory() {
//配置消费者的 Json 反序列化的可信赖包，反序列化实体类需要
try(JsonDeserializer<Object> deserializer = new JsonDeserializer<>()) {
deserializer.trustedPackages("*");
deserializer.setRemoveTypeHeaders(false); // 确保不会删除类型头
return new DefaultKafkaConsumerFactory<>(consumerConfigs(), new JsonDeserializer<>(), deserializer);
}
}
@Bean
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;
}
}
/**
* @date 2022/10/31 15:27
* 异常处理
*/
@Component
public class MyKafkaListenerErrorHandler 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) {
System.out.println("消息详情：" + message);
System.out.println("异常信息：：" + exception);
System.out.println("消费者详情：：" + consumer.groupMetadata());
System.out.println("监听主题：：" + consumer.listTopics());
return KafkaListenerErrorHandler.super.handleError(message, exception, consumer);
}
}
import com.alibaba.fastjson.JSON;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.listener.SeekToCurrentErrorHandler;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.util.backoff.FixedBackOff;
import org.springframework.web.bind.annotation.RestController;
/**
* @date 2022/10/31 14:04
* kafka监听消息
*/
@RestController
public class KafkaHandler {
@Bean
public SeekToCurrentErrorHandler errorHandler() {
return new SeekToCurrentErrorHandler((rec, ex) -> {
System.out.println("Deserialization error at offset " + rec.offset());
}, new FixedBackOff(0,2));
}
/**
* 监听kafka消息
*
* @param consumerRecord kafka的消息，用consumerRecord可以接收到更详细的信息，也可以用String message只接收消息
* @param ack kafka的消息确认
* 使用autoStartup = "false"必须指定id
*/
@KafkaListener(topics = {"topic1", "topic2"}, errorHandler = "myKafkaListenerErrorHandler")
// @KafkaListener(id = "${spring.kafka.consumer.group-id}", topics = {"topic1", "topic2"}, autoStartup = "false")
public void listen1(ConsumerRecord<Object, Object> consumerRecord, Acknowledgment ack) {
try {
//用于测试异常处理
//int i = 1 / 0;
System.out.println(JSON.toJSONString(consumerRecord.value()));
//手动确认
ack.acknowledge();
} catch (Exception e) {
System.out.println("消费失败：" + e);
}
}
}
小结
提示：这里可以添加总结
例如：
提供先进的推理，复杂的指令，更多的创造力。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
