Windows11环境下使用docker配置kafka的学习记录

 小白学习笔记。

一个分布式抽奖秒杀项目的消息队列需要用到kafka，之前没接触过，边学边弄踩了很多坑，配置了好几天一直都是docker terminal处可以正常运行到了spring boot那里就连接不上kafka服务，为了防止重复踩坑，故写个帖子记录下学习过程，有理解不对的地方希望大家批评指正。

由于wurstmeister/zookeeper以及wurstmeister/kafka使用人数较多，使用范围较广，本次使用wurstmeister/kafka来搭建。

拉取镜像

首先在cmd中拉取wurstmeister/zookeeper和wurstmeister/kafka镜像，速度由网络状况决定（如果在docker search中找得到也可以直接在那边拉取，反正我搜了是没有）。

# 拉取zookeeper镜像
docker pull wurstmeister/zookeeper

# 拉取kafka镜像
docker pull wurstmeister/kafka

成功后在docker的image界面显示：

启动服务：

# 启动zookeeper服务，将container名称设为zookeeper，端口号设置为2181。
docker run -d --name zookeeper -p 2181:2181 wurstmeister/zookeeper:latest

# 启动kafka服务，将container名称设为kafka，端口号设置为9092
docker run -d --name kafka -p 9092:9092 -e KAFKA_BROKER_ID=0 -e KAFKA_ZOOKEEPER_CONNECT=zookeeperip:2181/kafka -e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://本地ip:9092 -e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 wurstmeister/kafka:latest

parameterList：

KAFKA_BROKER_ID：用于标识不同的kafka服务节点，不同的节点可以根据这东西来区分，Kafka启动时还会在zookeeper中创建一个与当前broker_id同名的虚节点，用于kafka健康检查等（单个节点挂了可以，但不能卡死）关于该参数需要注意InconsistentBrokerIdException异常，注意meta.properties、server.proterties以及该参数一致。

KAFKA_ZOOKEEPER_CONNECT：ZOOKEEPER集群的地址，多个的话用，分隔。由于zookeeper负责协调任务、存储元数据以及服务发现，所以spring boot连接kafka时其实连接的是这个socket（不确定，自己的推测）？

KAFKA_LISTENER： kafka服务器的监听地址，前面跟着协议类型，默认PLAINTEXT，明文传输，还有些加密协议例如SSL，SASL等。

记录一些坑：

1、若出现zookeeper拒绝连接的问题，有可能是因为KAFKA_ZOOKEEPER_CONNECT参数设置为了localhost，由于这两个东西不在一个container里面，所以不能使用localhost配置，要写ip。具体可以看这位老哥的文章：记一次docker安装kafka，zookeeper拒绝连接的问题_kafka_zookeeper_connect_Rivers-King的博客-CSDN博客

2、KAFKA_ADVERTISED_LISTENERS应与spring那边配置一样，上一次搞得一边连的上一边连不上可能就是因为这个。

测试连接：

# 进入运行脚本目录
cd /opt/kafka_2.13-2.8.1/bin

# 生产消息
./kafka-console-producer.sh --broker-list localhost:9092 --topic hellotest
> hello kafka!

# 消费消息
./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic hellotest --from-beginning

运行结果：

 红框为发送的消息，蓝框为接收到的消息。

Spring Boot测试：

生产：

package cn.itedus.lottery.application.mq.producer;

import cn.itedus.lottery.domain.activity.model.vo.InvoiceVO;
import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

import javax.annotation.Resource;

@Component
public class KafkaProducer {

    private Logger logger = LoggerFactory.getLogger(KafkaProducer.class);

    @Resource
    private KafkaTemplate<String, Object> kafkaTemplate;

    public static final String TOPIC_TEST = "Hello-Kafka";

    public static final String TOPIC_GROUP = "test-consumer-group";

    public void sent(Object object) {
        String Object2String = JSON.toJSONString(object);
        logger.info("准备发送的消息为：{}", Object2String);
        System.out.println("准备发送的消息为：" + Object2String);

        // 发送消息。
        ListenableFuture<SendResult<String, Object>> sent = kafkaTemplate.send(TOPIC_TEST, Object2String);
        System.out.println(sent);
        sent.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
            @Override
            public void onFailure(Throwable throwable) {
                logger.info(TOPIC_TEST + "，发送消息失败" + throwable.getMessage());
                System.out.println(TOPIC_TEST + "发送消息失败" + throwable.getMessage());
            }

            @Override
            public void onSuccess(SendResult<String, Object> stringObjectSendResult) {
                logger.info(TOPIC_TEST + "，发送消息成功");
                System.out.println(TOPIC_TEST + "发送消息成功" + stringObjectSendResult.toString());
            }
        });
    }
}

消费：

package cn.itedus.lottery.application.mq.consumer;

import cn.itedus.lottery.application.mq.producer.KafkaProducer;
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;

@Component
public class KafkaConsumer {

    private Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);

    @KafkaListener(topics=KafkaProducer.TOPIC_TEST, groupId=KafkaProducer.TOPIC_GROUP)
    public void topicTest(ConsumerRecord<?, ?> record, Acknowledgment ack, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        Optional<?> optional = Optional.ofNullable(record.value());
        if(optional.isPresent()) {
            Object message = optional.get();
            logger.info("topic_test 消费了： Topic:" + topic + ",Message:" + message);
            System.out.println("topic_test 消费了： Topic:" + topic + ",Message:" + message);
            ack.acknowledge();
        }
    }
}

测试：

package cn.itedus.lottery.test.domain;

import cn.itedus.lottery.application.mq.consumer.KafkaConsumer;
import cn.itedus.lottery.application.mq.producer.KafkaProducer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

@RunWith(SpringRunner.class)
@SpringBootTest
public class KafkaTest {

    @Resource
    private KafkaProducer kafkaProducer;

    @Resource
    private KafkaConsumer kafkaConsumer;

    @Test
    public void test_send() throws InterruptedException {
        kafkaProducer.sent(new String("你好，Kafka"));
        // Thread.sleep(3500);
    }
}

结果：

应该是成功了。