SpringBoot集成kafka

创建SpringBoot项目

pom文件

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

yml文件配置

spring:
  kafka:
    # 修改成自己的kafka地址，多个逗号分隔
    bootstrap-servers: 192.168.22.10:9092
    producer:
      # 消息的序列化配置
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
      #发送消息失败时的一个重试的次数
      retries: 0
      # 批量发送数据的配置
      batch-size: 16384
      # 设置kafka生产者内存缓存区的大小（32M 推荐）
      buffer-memory: 33554432
      ## 生产端最重要的选项
      # acks=0：生产者在成功写入消息之前不会等待任何来自服务器的响应
      # acks=1: 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应
      # acks=-1：表示分区leader必须等待消息被成功写入所有的ISR副本（同步副本）中才认为produce是请求成功的。这种方案提供了最高的消息持久性保证，但是理论上也是吞吐率最差的
      acks: 1
    consumer:
      # 消息的签收机制：手工签收
      enable-auto-commit: false
      # 序列化配置
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      # 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理
      # latest(默认值) 在偏移量无效的情况下，消费者将从最新的记录开始读取数据（消费者启动之后产生的数据）
      # earliest: 在偏移量无效的情况下，消费者将从起始位置读取分区的记录
      auto-offset-reset: earliest
    listener:
      ack-mode: manual
      # 线程数
      concurrency: 5

创建生产者

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Slf4j
@Component
public class KafkaProducerService {

    @Autowired
    private KafkaTemplate<String,Object> kafkaTemplate;

    public void sendMessage(String topic,Object object){
        ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send(topic, object);
        future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
            // 消息发送成功处理
            @Override
            public void onFailure(Throwable throwable) {
                log.info("发送消息失败：" + throwable.getMessage());
            }
            // 消息发送失败处理
            @Override
            public void onSuccess(SendResult<String, Object> stringObjectSendResult) {
                log.info("发送消息成功：" + stringObjectSendResult.toString());
            }
        });
    }
}

创建消费者

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class KafkaConsumerService {

    //监听多个topic    topics= {"topic02","topic03"}
    @KafkaListener(groupId = "group02", topics = "topic02")
    public void onMessage(ConsumerRecord<String,Object> record, Acknowledgment acknowledgment, Consumer<?,?> consumer) {
        log.info("消息端接收消息：{}",record.value());
        // 手工签收机制
        acknowledgment.acknowledge();
    }
}

注意事项：

• 测试时，topic要提前使用命令行创建好

常用命令

## 简单操作：
#（1）创建topic主题命令：（创建名为test的topic， 1个分区分别存放数据，数据备份总共1份）
kafka-topics.sh --zookeeper 192.168.22.10:2181 --create --topic topic1 --partitions 1  --replication-factor 1  
## --zookeeper 为zk服务列表
## --create 命令后 --topic 为创建topic 并指定 topic name
## --partitions 为指定分区数量
## --replication-factor 为指定副本集数量

#（2）查看topic列表命令：
kafka-topics.sh --zookeeper 192.168.22.10:2181 --list

#（3）kafka命令发送数据：（然后我们就可以编写数据发送出去了）
kafka-console-producer.sh --broker-list 192.168.22.10:9092 --topic topic1

#（4）kafka命令接受数据：（然后我们就可以看到消费的信息了）
kafka-console-consumer.sh --bootstrap-server 192.168.22.10 --topic topic1 --from-beginning


#（5）删除topic命令：
kafka-topics.sh --zookeeper 192.168.22.10 --delete --topic topic1

#（6）kafka查看消费进度：（当我们需要查看一个消费者组的消费进度时，则使用下面的命令）
kafka-consumer-groups.sh --bootstrap-server 192.168.22.10 --describe --group group1
## --describe --group 为订阅组， 后面指定 group name

转存失败重新上传取消