SpringBoot 2.x 集成 kafka

缺乏、安全感 2022-12-10 14:31 199阅读 0赞

## 搭建kafka运行环境 ##

[kafka安装教程（windows版）][kafka_windows]

## 版本 ##

**springboot版本**

2.1.12.RELEASE

**springCloud版本**

Greenwich.SR6

**kafka maven依赖**

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

## kafka配置 ##

spring:
      kafka:
        bootstrap-servers: 127.0.0.1:9092
        producer:
          # 发生错误后，消息重发的次数。
          retries: 0
          #当有多个消息需要被发送到同一个分区时，生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算。
          batch-size: 16384
          # 设置生产者内存缓冲区的大小。
          buffer-memory: 33554432
          # 键的序列化方式
          key-serializer: org.apache.kafka.common.serialization.StringSerializer
          # 值的序列化方式
          value-serializer: org.apache.kafka.common.serialization.StringSerializer
          # acks=0 ： 生产者在成功写入消息之前不会等待任何来自服务器的响应。
          # acks=1 ： 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
          # acks=all ：只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。
          acks: 1
        consumer:
          # 自动提交的时间间隔 在spring boot 2.X 版本中这里采用的是值的类型为Duration 需要符合特定的格式，如1S,1M,2H,5D
          auto-commit-interval: 1S
          # 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理：
          # latest（默认值）在偏移量无效的情况下，消费者将从最新的记录开始读取数据（在消费者启动之后生成的记录）
          # earliest ：在偏移量无效的情况下，消费者将从起始位置读取分区的记录
          auto-offset-reset: earliest
          # 是否自动提交偏移量，默认值是true,为了避免出现重复数据和数据丢失，可以把它设置为false,然后手动提交偏移量
          enable-auto-commit: false
          # 键的反序列化方式
          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

## topic初始化 ##

import org.apache.kafka.clients.admin.NewTopic;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /** * topic初始化 * @ClassName: KafkaConfig * @author Riyue * @Date 2020/8/29 20:20 * @version V1.0.0 **/
    @Configuration
    public class KafkaConfig { 
    
        /** * 创建一个名为topic.test的Topic并设置分区数为8，分区副本数为2 * @Author Riyue * @Date 20:20 2020/8/29 * @param * @return org.apache.kafka.clients.admin.NewTopic **/
        @Bean
        public NewTopic initialTopic() { 
            return new NewTopic("topic.test",8, (short) 2 );
        }
    
        // 如果要修改分区数，只需修改配置值重启项目即可
        // 修改分区数并不会导致数据的丢失，但是分区数只能增大不能减小
        /*@Bean public NewTopic updateTopic() { return new NewTopic("topic.test",10, (short) 2 ); }*/
    
    }

/** * * @ClassName: KafkaConstant * @author Riyue * @Date 2020/8/29 20:15 * @version V1.0.0 **/
    public interface KafkaConstant { 
    
        String TOPIC_TEST = "topic.test";
    
        String TOPIC_GROUP1 = "topic.group1";
    
        String TOPIC_GROUP2 = "topic.group2";
    }

## 消息发送端 ##

import com.alibaba.fastjson.JSONObject;
    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.ListenableFutureCallback;
    
    /** * 消息发送端 * @ClassName: KafkaProducer * @author Riyue * @Date 2020/8/29 20:12 * @version V1.0.0 **/
    @Component
    @Slf4j
    public class KafkaProducer { 
    
        @Autowired
        private KafkaTemplate<String, Object> kafkaTemplate;
    
        public void send(Object obj) { 
            String obj2String = JSONObject.toJSONString(obj);
            // 发送消息
            kafkaTemplate.send(KafkaConstant.TOPIC_TEST, obj).addCallback(new ListenableFutureCallback<SendResult<String, Object>>() { 
                @Override
                public void onFailure(Throwable throwable) { 
                    // 发送失败的处理
                    log.info("topic[{}] 生产者 发送消息失败[{}]", KafkaConstant.TOPIC_TEST, throwable.getMessage());
                }
    
                @Override
                public void onSuccess(SendResult<String, Object> stringObjectSendResult) { 
                    // 成功的处理
                    log.info("topic[{}] 生产者 发送消息成功[{}]", KafkaConstant.TOPIC_TEST, stringObjectSendResult.getProducerRecord().value());
                }
            });
        }
    }

## 消息接收端 ##

import lombok.extern.slf4j.Slf4j;
    import org.apache.kafka.clients.consumer.ConsumerRecord;
    import org.springframework.kafka.annotation.KafkaListener;
    import org.springframework.kafka.support.Acknowledgment;
    import org.springframework.kafka.support.KafkaHeaders;
    import org.springframework.messaging.handler.annotation.Header;
    import org.springframework.stereotype.Component;
    
    import java.util.Optional;
    
    /** * 消息接收端-支持多端消费 * @ClassName: KafkaConsumer * @author Riyue * @Date 2020/8/29 20:12 * @version V1.0.0 **/
    @Component
    @Slf4j
    public class KafkaConsumer { 
    
        @KafkaListener(topics = KafkaConstant.TOPIC_TEST, groupId = KafkaConstant.TOPIC_GROUP1)
        public void topicTest(ConsumerRecord<?, ?> record, Acknowledgment ack, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) { 
    
            Optional message = Optional.ofNullable(record.value());
            if (message.isPresent()) { 
                Object msg = message.get();
                log.info("客户端 A 消费了： Topic[{}] Message[{}]", topic, msg);
                ack.acknowledge();
            }
        }
    
        @KafkaListener(topics = KafkaConstant.TOPIC_TEST, groupId = KafkaConstant.TOPIC_GROUP2)
        public void topicTest1(ConsumerRecord<?, ?> record, Acknowledgment ack, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) { 
    
            Optional message = Optional.ofNullable(record.value());
            if (message.isPresent()) { 
                Object msg = message.get();
                log.info("客户端 B 消费了： Topic[{}] Message[{}]", topic, msg);
                ack.acknowledge();
            }
        }
    }

## 测试接口 ##

import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiImplicitParam;
    import io.swagger.annotations.ApiOperation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    import springfox.documentation.annotations.ApiIgnore;
    
    /** * * @ClassName: KafkaController * @author Riyue * @Date 2020/8/29 13:54 * @version V1.0.0 **/
    @RestController
    @RequestMapping(value="/kafka")
    @Api(tags = "kafka消息发送测试")
    public class KafkaController { 
    
        @Autowired
        private KafkaProducer kafkaProducer;
    
        @GetMapping("/sendMsg")
        @ApiOperation(value = "消息发送")
        @ApiImplicitParam(name = "content", value = "内容", paramType = "query", dataType="String")
        public Result sendMsg(@ApiIgnore @RequestParam String content) { 
            kafkaProducer.send(content);
            return new Result().ok("SUCCESS");
        }
    }

OK，所有的代码我都贴出来了，大家复制到自己的项目中调试就可以了，有问题欢迎留言讨论。如果该文章对您有帮助，那就留言点个赞吧！

[kafka_windows]: https://blog.csdn.net/weixin_40623736/article/details/108692442