springBoot kafka简单使用

导入依赖

    <!-- 继承Spring boot工程 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!-- kafkfa -->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>
    </dependencies>

springBoot配置文件

spring:
  kafka:
    bootstrap-servers: 192.168.200.130:9092 #集群地址
    producer:
      retries: 1 #重试次数
      # acks=0 ： 生产者在成功写入消息之前不会等待任何来自服务器的响应。
      # acks=1 ： 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
      # acks=all ：只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。
      #该参数指定了一个批次可以使用的内存大小，按照字节数计算。
      batch-size: 16368
      # 设置生产者内存缓冲区的大小。
      buffer-memory: 33554432
      # Kafka提供的序列化和反序列化类
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
#      transaction-id-prefix: tx- #开启事务，事务前缀
    consumer:
      # 默认的消费组ID
      group-id: test-hello-group
      # 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理：
      # latest（默认值）在偏移量无效的情况下，消费者将从最新的记录开始读取数据（在消费者启动之后生成的记录）
      # earliest ：在偏移量无效的情况下，消费者将从起始位置读取分区的记录
      auto-offset-reset: earliest
      # 是否自动提交偏移量，默认值是true,为了避免出现重复数据和数据丢失，可以把它设置为false,然后手动提交偏移量
      enable-auto-commit: true
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

    listener:
      # 在侦听器容器中运行的线程数。
      concurrency: 5
      #listner负责ack，每调用一次，就立即commit
#      ack-mode: manual_immediate
#      missing-topics-fatal: false

生产者

    @Autowired
    private KafkaTemplate<String,String> kafkaTemplate;

    @GetMapping("/kafka")
    public void send() {
        //简单发送
        kafkaTemplate.send("topic1","你好");

        //带回调的发送
//        kafkaTemplate.send("topic1", "你好").addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
//            @Override
//            public void onFailure(Throwable throwable) {
//                System.out.println(throwable.getStackTrace());
//            }
//
//            @Override
//            public void onSuccess(SendResult<String, String> stringStringSendResult) {
//                System.out.println(stringStringSendResult.getProducerRecord());
//                System.out.println(stringStringSendResult.getRecordMetadata());
//            }
//        });

        //事务
//        kafkaTemplate.executeInTransaction(new KafkaOperations.OperationsCallback<String, String, String>() {
//            @Override
//            public String doInOperations(KafkaOperations<String, String> kafkaOperations) {
//                ListenableFuture<SendResult<String, String>> send = kafkaOperations.send("topic1", "你好");
                throw new RuntimeException("fail");
//                return "aa";
//            }
//        });
    }

消费者

@Component
public class receive {
    //partitions 分区
    @KafkaListener(topics = {"topic1"})
    public void Receive(ConsumerRecord<?,?> record){
        System.out.println(record.toString());
        System.out.println("消费者1："+record.value());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    @KafkaListener(topics = {"topic1"})
    public void Receive1(ConsumerRecord<?,?> record){
        System.out.println(record.toString());
        System.out.println("消费者2："+record.value());
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}