超简单的Windows下Kafka的安装部署实例 + Springboot下Kafka的两种集成实例（生产者/消费者实例）

简单说明什么是kafka

Apache kafka是消息中间件的一种，我发现很多人不知道消息中间件是什么，在开始学习之前，我这边就先简单的解释一下什么是消息中间件，只是粗略的讲解，目前kafka已经可以做更多的事情。

举个例子，生产者消费者，生产者生产鸡蛋，消费者消费鸡蛋，生产者生产一个鸡蛋，消费者就消费一个鸡蛋，假设消费者消费鸡蛋的时候噎住了（系统宕机了），生产者还在生产鸡蛋，那新生产的鸡蛋就丢失了。再比如生产者很强劲（大交易量的情况），生产者1秒钟生产100个鸡蛋，消费者1秒钟只能吃50个鸡蛋，那要不了一会，消费者就吃不消了（消息堵塞，最终导致系统超时），消费者拒绝再吃了，”鸡蛋“又丢失了，这个时候我们放个篮子在它们中间，生产出来的鸡蛋都放到篮子里，消费者去篮子里拿鸡蛋，这样鸡蛋就不会丢失了，都在篮子里，而这个篮子就是”kafka“。
鸡蛋其实就是“数据流”，系统之间的交互都是通过“数据流”来传输的（就是tcp、https什么的），也称为报文，也叫“消息”。
消息队列满了，其实就是篮子满了，”鸡蛋“ 放不下了，那赶紧多放几个篮子，其实就是kafka的扩容。
各位现在知道kafka是干什么的了吧，它就是那个"篮子"。

kafka名词解释

后面大家会看到一些关于kafka的名词，比如topic、producer、consumer、broker，我这边来简单说明一下。

producer：生产者，就是它来生产“鸡蛋”的。

consumer：消费者，生出的“鸡蛋”它来消费。

topic：你把它理解为标签，生产者每生产出来一个鸡蛋就贴上一个标签（topic），消费者可不是谁生产的“鸡蛋”都吃的，这样不同的生产者生产出来的“鸡蛋”，消费者就可以选择性的“吃”了。

broker：就是篮子了。

大家一定要学会抽象的去思考，上面只是属于业务的角度，如果从技术角度，topic标签实际就是队列，生产者把所有“鸡蛋（消息）”都放到对应的队列里了，消费者到指定的队列里取。

作者：半兽人
链接：https://www.orchome.com/kafka/index
来源：OrcHome

上面是OrcHome的Kafka中文教程介绍，我觉得非常形象，比一些专业的术语要容易理解得多，适合入门学习。

一.Windows下Kafka的安装部署实例

1.首先下载Apache Kafka

http://kafka.apache.org/downloads

注意是下面的链接

2.解压压缩包

3.然后进入到  kafka_2.12-2.3.0\bin\windows 文件夹下。并在地址栏输入cmd回车打开命令行

PS：后面的5个命令每个都要打开一个新的cmd来执行，并且不要关闭（除了创建topic命令可以关）

4.首先启动开zookeeper ，输入命令：.\zookeeper-server-start.bat ..\..\config\zookeeper.properties

启动Kafka，输入命令： .\kafka-server-start.bat ..\..\config\server.properties

然后创建一个topic，命名为test（这里我已经建过了，图就用别的topic的），输入命令：.\kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

然后创建一个或多个生产者，将topic设置为test，输入命令：.\kafka-console-producer.bat --broker-list localhost:9092 --topic test

最后创建一个或多个消费者，将topic设置为test，输入命令：.\kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic test --from-beginning

在生存者上发送的消息，同一topic下的消费者就能接收到啦。恭喜你已经完成简单的Kafka生产者/消费者实例。

接下来将实现两种简单的SpringBoot集成Kafka的生产者/消费者实例。

二.Springboot下Kafka的集成实例

首先介绍第一种，引入依赖是 org.apache.kafka 的。这种方法是kafka官方文档上有的方法，代码比较复杂。

先说说我先前遇到的问题，贼SB的，之前我以为引入依赖后就不用自行启动Kafka了，所以一直没有启动Kafka，导致一直不成功。事实上需要先启动Kafka，下面的代码只是创建消费者和生存者的实例，并不包含Kafka启动。

zookeeper的默认端口：2181

Kafka的默认端口：9092

1.首先在 pom.xml 中引入 org.apache.kafka 的依赖

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.12</artifactId>
            <version>1.1.0</version>
        </dependency>

这里要注意，不同版本的依赖的Producer API 和Consumer API 实现可能稍有不同，我这里springboot的版本是1.5.10.RELEASE，可以在官网链接http://kafka.apache.org/documentation/查看不同版本的API实例。

2.开始实现生产者实例

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 15:23
 */
public class MyKafkaProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092"); //kafka端口
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); //key值序列化配置
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); //value值序列化配置

        Producer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<>("test", "hello to MykafkaComsumer")); //topic和对应消息

        producer.close();
    }
}

运行main函数即可向名为test的topic生产一条信息

3.开始实现消费者实例

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 15:48
 */
public class MyKafkaConsumer {
    public static void main(String[] args) {

        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "myGroup"); 分组名
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms", "1000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("test")); //这边是消费者的topic订阅，可订阅多个
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100); //循环拉取消息
            for (ConsumerRecord<String, String> record : records)
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
}

运行main函数即可循环监听订阅的topic

 

接着是第二种，要引入依赖 spring.kafka 的，这种方法代码很简单，通过@kafkalistener就可以进行消费者的监听。

1.首先在 pom.xml 中引入 org.springframework.kafka 的依赖

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

2.在 application.properties 文件里添加Kafka配置

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=myGroup

3.开始实现生产者实例

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 11:09
 */
@Service
public class KafkaProducer2 {
    @Autowired
    KafkaTemplate kafkaTemplate;

    public void sender(String topic,String value){
        kafkaTemplate.send(topic,value);
    }
}

生产者通过KafkaTemplate类来发送消息

4.开始实现消费者实例

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 11:32
 */
@Service
public class KafkaConsumer2 {
    @KafkaListener(topics = "test")
    public void consumer(String message){
        System.out.println(message);
    }
}

这里的@KafkaListener注解能够对topic进行监听

5.创建一个test类，将生产者和消费者的类注入

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

    @Autowired
    private KafkaProducer2 kafkaProducer2; //注入生产者
    @Autowired
    private KafkaConsumer2 kafkaConsumer2; //注入消费者，注入后即可监听

    @Test
    public void sender() {
        try { 
            Thread.sleep(3000); //这里sleep保证消费者开始监听后才发送消息
            kafkaProducer2.sender("test","8888----7777");//生产者发送消息
            Thread.sleep(80000000); //sleep方便消费者监听
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

以上三个实例的生产者和消费者都可以互通消息，可以同时打开多个实例测试。这些是我学习完多个博客后的整合，适合入门者理解和快速实现Kafka的实例。