docker部署kafka并使用SpringBoot集成kafka

前言

不熟悉 docker 的可以先去自行熟悉一下基本命令。


找个时间我写个docker基础趴!

1、docker部署kafka

1. 部署kafka需要用到Zookeeper，所以先下载Zookeeper和kafka：

docker pull wurstmeister/zookeeper
docker pull wurstmeister/kafka

2. 启动Zookeeper，kafka

注意：启动kafka时要修改的内容：

• KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181   zookeeper修改成你的IP地址
• 192.168.1.60   修改成你的IP地址

# 启动 Zookeeper
docker run -d --name zookeeper -p 2181:2181  wurstmeister/zookeeper

# 启动 kafka
docker run -d --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181 --link zookeeper -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://192.168.1.60(机器IP):9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 -t wurstmeister/kafka

3. 进入kafka 交互：

docker exec -it kafka /bin/bash

4. 进入到kafka/bin目录下启动：

注意的是：kafka_2.13-2.8.1   根据你那边的目录选择你的就行，这个是可变的！

# 进入 kafka 
cd opt/kafka_2.13-2.8.1/bin

# 启动 topic
./kafka-console-producer.sh --broker-list localhost:9092 --topic vipsoft_kafka

5. 启动另一个SSH，并进入kafka交互：

# 进入 kafka 
cd opt/kafka_2.13-2.8.1/bin

# 启动 topic
 ./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic vipsoft_kafka --from-beginning

6. 测试发送消息–任意：

在第一个窗口输入：

{“datas”:[{“channel”:"",“metric”:“temperature”,“producer”:“ijinus”,“sn”:“IJA0101-00002245”,“time”:“1543207156000”,“value”:“80”}],“ver”:“1.0”}

在第二个窗口就能查看到 topic 发送的消息：

2、Java连接kafka

1. 加入kafka依赖：

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

2. 资源配置application.yml：

 kafka:
    bootstrap-servers: xxx:9092  # kafka 服务器地址 :端口
    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

3. 编写生产者：（以下的Logger用不习惯或者没用过的，可以使用System.out.println输出）

import com.github.chenlijia1111.utils.common.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @Description kafka 生产者
 */
@Component
public class KafkaProducer {
    private static final Logger log = LoggerFactory.getLogger(KafkaProducer.class);
/*
	// 注入KafkaTemplate的方式一
    private final KafkaTemplate kafkaTemplate;
    
    //构造器方式注入 kafkaTemplate
    public KafkaProducer(KafkaTemplate kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }
    */

	// 注入KafkaTemplate的方式二
    @Resource
    private KafkaTemplate<String, Object> kafkaTemplate;

    public Result send(String msg){
        return Result.success(kafkaTemplate.send("test",msg));
    }

}

4. 编写消费者

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

/**
 * @Description 消费者
 */
@Component
public class KafkaConsumer {
    private static final Logger log = LoggerFactory.getLogger(KafkaConsumer.class);

    @KafkaListener(groupId = "3", topics = "test")
    public void listen(String msg){
        System.err.println("=====================接收的消息：" + msg);
        log.error("接收的消息：" + msg);
    }

    @KafkaListener(topics = "test", groupId = "1")
    public void topic_test(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("topic_test 消费了： Topic： " + topic + "，Message：" + msg);
            ack.acknowledge();
        }
    }

}

5. 编写controller

import com.github.chenlijia1111.utils.common.Result;
import com.gzlskj.common.component.kafka.KafkaProducer;
import io.swagger.annotations.Api;
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.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description
 */
@Api(tags = "kafka消息队列")
@RestController
public class KafkaController {

    @Autowired
    private KafkaProducer kafkaProducer;

    @ApiOperation(value = "发布消息")
    @GetMapping("sendMessage/{msg}")
    public Result sendMessage(@PathVariable("msg") String msg){
        return kafkaProducer.send(msg);
    }
}

到这里完成啦，可以去测试了!