kafka环境搭建-springboot集成kafka

一、使用docker搭建kafka环境

1：下载wurstmeister/kafka和wurstmeister/zookeeper镜像

docker pull wurstmeister/zookeeper

docker pull wurstmeister/kafka

2：启动zookeeper容器

docker run -d --name zookeeper -p 2181:2181 -t wurstmeister/zookeeper

3：启动kafka容器

docker run -d --name kafka --publish 9092:9092 --link zookeeper --env KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 --env KAFKA_ADVERTISED_HOST_NAME=192.168.9.49 --env KAFKA_ADVERTISED_PORT=9092 --volume /etc/localtime:/etc/localtime wurstmeister/kafka:latest

其中KAFKA_ADVERTISED_HOST_NAME这个参数最好设置成宿主机的ip方便其它机器访问

4：docker下kafka环境的搭建完成

二、开始使用spring-boot集成kafka

该工程需要的pom文件的依赖

    org.apache.kafka
    kafka-clients
    0.11.0.0


    org.springframework.boot
    spring-boot-starter-web
    2.0.7.RELEASE


    org.springframework.boot
    spring-boot-starter-test
    2.0.7.RELEASE


    org.springframework.kafka
    spring-kafka
    2.1.11.RELEASE
    
        
            org.apache.kafka
            kafka-clients
        
    

 

application.yml文件中的配置

spring:
  kafka:
    bootstrap-servers: localhost:9092
    producer:
      acks: 1
      batch-size: 16384
      retries: 0
      buffer-memory: 33554432
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      enable-auto-commit: true
      group-id: lk
      auto-commit-interval: 100
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
server:
  port: 8087

 

创建生产者

@RestController
public class SpringKafkaProducer {

    private static Logger log = LoggerFactory.getLogger(SpringKafkaProducer.class);

    @Autowired
    private KafkaTemplate kafkaTemplate;

    private static final String topic = "kafka-boot";

    @GetMapping("/sync")
    public void syncSendMessage(){
        for(int i=0; i<100; i++){
            try {
                kafkaTemplate.send(topic, "sync" +i).get();
            } catch (InterruptedException e) {
                log.error("sync send message fail [{}]", e.getMessage());
            } catch (ExecutionException e) {
                log.error("sync send message fail [{}]", e.getMessage());
            }
        }
    }

    @GetMapping("/async")
    public void asyncSendMessage(){
        for(int i=0; i<100; i++){
            ListenableFuture> send = kafkaTemplate.send(topic, "async" +i);
            send.addCallback(new ListenableFutureCallback>() {
                @Override
                public void onSuccess(SendResult result) {
                    log.info("async send message success partition [{}]", result.getRecordMetadata().partition());
                    log.info("async send message success offest[{}]", result.getRecordMetadata().offset());
                }
                @Override
                public void onFailure(Throwable ex) {
                    log.error("async send message fail [{}]", ex.getMessage());
                }
            });
        }
    }

 

生产者生产的两种模式，第一种是同步生产，第二种是异步生产。具体根据自己项目的需求选择使用。

 

创建消费者

@Component
public class SpringKafkaConsumer {

    private static Logger log = LoggerFactory.getLogger(SpringKafkaConsumer.class);

    @KafkaListener(id = "foo", topics = {"kafka-boot"})
    public void consumer(String foo){
        log.info("message value [{}]", foo);
    }
}

三、最后附上直接使用kafka-client操作kafka的代码以及各个配置项的详解

生产者：

public class Produce {
    public static void main(String[] args){
        Properties properties = new Properties();
        //broker的地址清单，建议至少填写两个，避免宕机
        properties.put("bootstrap.servers", "localhost:9092");
        //acks指定必须有多少个分区副本接收消息，生产者才认为消息写入成功，用户检测数据丢失的可能性
        //acks=0：生产者在成功写入消息之前不会等待任何来自服务器的响应。无法监控数据是否发送成功，但可以以网络能够支持的最大速度发送消息，达到很高的吞吐量。
        //acks=1：只要集群的首领节点收到消息，生产者就会收到来自服务器的成功响应。
        //acks=all：只有所有参与复制的节点全部收到消息时，生产者才会收到来自服务器的成功响应。这种模式是最安全的，
        properties.put("acks", "all");
        //retries：生产者从服务器收到的错误有可能是临时性的错误的次数
        properties.put("retries", 0);
        //batch.size：该参数指定了一个批次可以使用的内存大小，按照字节数计算（而不是消息个数)。
        properties.put("batch.size", 16384);
        //linger.ms：该参数指定了生产者在发送批次之前等待更多消息加入批次的时间，增加延迟，提高吞吐量
        properties.put("linger.ms", 1);
        //buffer.memory该参数用来设置生产者内存缓冲区的大小，生产者用它缓冲要发送到服务器的消息。
        properties.put("buffer.memory", 33554432);
        //compression.type:数据压缩格式，有snappy、gzip和lz4，snappy算法比较均衡，gzip会消耗更高的cpu，但压缩比更高
        //key和value的序列化
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //client.id：该参数可以是任意的字符串，服务器会用它来识别消息的来源。
        //max.in.flight.requests.per.connection：生产者在收到服务器晌应之前可以发送多少个消息。越大越占用内存，但会提高吞吐量
        //timeout.ms：指定了broker等待同步副本返回消息确认的时间
        //request.timeout.ms：生产者在发送数据后等待服务器返回响应的时间
        //metadata.fetch.timeout.ms：生产者在获取元数据（比如目标分区的首领是谁）时等待服务器返回响应的时间。
        // max.block.ms：该参数指定了在调用 send（）方法或使用 partitionsFor（）方法获取元数据时生产者阻塞时间
        // max.request.size：该参数用于控制生产者发送的请求大小。
        //receive.buffer.bytes和send.buffer.bytes：指定了 TCP socket 接收和发送数据包的缓冲区大小，默认值为-1
        Producer producer = null;
        try {
            producer = new KafkaProducer<>(properties);
            for (int i = 0; i < 50; i++) {
                String msg = "test message" + i;
                producer.send(new ProducerRecord("test-kafka-client", msg));
                Thread.sleep(500);
                System.out.println("Sent:" + msg);
            }
        } catch (Exception e) {
            e.printStackTrace();

        } finally {
            producer.close();
        }

    }
}

消费者：

public class Customer {

    public static void main(String[] args) throws InterruptedException {
        Properties properties = new Properties();
        properties.put("bootstrap.servers", "localhost:9092");
        properties.put("group.id", "group-2");
        //session.timeout.ms：消费者在被认为死亡之前可以与服务器断开连接的时间，默认是3s 。
        properties.put("session.timeout.ms", "30000");
        //消费者是否自动提交偏移量，默认值是true,避免出现重复数据和数据丢失，可以把它设为 false。
        properties.put("enable.auto.commit", "false");
        properties.put("auto.commit.interval.ms", "1000");
        //auto.offset.reset:消费者在读取一个没有偏移量的分区或者偏移量无效的情况下的处理
        //earliest：在偏移量无效的情况下，消费者将从起始位置读取分区的记录。
        //latest：在偏移量无效的情况下，消费者将从最新位置读取分区的记录
        properties.put("auto.offset.reset", "earliest");
        properties.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        properties.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        // max.partition.fetch.bytes：服务器从每个分区里返回给消费者的最大字节数
        //fetch.max.wait.ms:消费者等待时间，默认是500。
        // fetch.min.bytes:消费者从服务器获取记录的最小字节数。
        // client.id：该参数可以是任意的字符串，服务器会用它来识别消息的来源。
        // max.poll.records:用于控制单次调用 call （） 方住能够返回的记录数量
        //receive.buffer.bytes和send.buffer.bytes：指定了 TCP socket 接收和发送数据包的缓冲区大小，默认值为-1

        KafkaConsumer kafkaConsumer = new KafkaConsumer<>(properties);
        kafkaConsumer.subscribe(Arrays.asList("kafka-boot"));
        while (true) {
            ConsumerRecords records = kafkaConsumer.poll(100);
            for (ConsumerRecord record : records) {
                System.out.printf("offset = %d, value = %s", record.offset(), record.value());
                System.out.println("=====================>");
            }
        }

    }
}

注：在搭建过程中由于docker中之前安装过kafka，所以出现了如下的问题：

卡在AbstractCoordinator类中ensureCoordinatorReady方法这块了，老是进行循环，打印log.debug("Coordinator discovery failed, refreshing metadata")。

这是由于之前的脏数据造成的，解决办法如下：

1、进入zookeeper 运行zkCli.sh 。

2、运行ls /brokers/topics 查看主题

3、然后运行 rmr /brokers/topics/consumer_offsets 删除consumer_offsets_主题

4、然后重启kafka集群就好了。

 

附：进入docker容器的命令 docker exec -it 容器id /bin/bash

 

本篇只是对spring-boot集成kafka的一个探索，后续为了更好的使用kafka可以对其进行二次封装，封装为类似RedisUti的工具类方便使用。