实战和理论结合

题目 一个项目，使用kafka来处理任意一种消息。订单，日志……，你会使用什么机制，（从生产者，消费者，kafka本身来说），说明一下为什么这么使用？

kafka集群

个人环境。一台虚拟机zookeeper，目前暂时用单机zookeeper，3台虚拟经济，每个虚拟机都装一个kafka，组成一个集群，将kafka安装好之后，加入zookeeper中

参考文章：blog.csdn.net/zhanglong_4…

1.修改配置文件中的brokerId,值分别为1、2、3

2.zookeeper.connect：zk1:2181/kafka1 如果我们采取zookeeper集群那么这个地方写zookeeper.connect：zk1:2181 ,zk2:2181,zk3:2181/kafka1

3.log.dirs ,最后各种实际的数据文件呆的地方

4.CONTROLLER: //localhost:9092 各主机之间因为在内网中，明文通信。

5.auto.create.topics.enable：是否允许自动创建 Topic。 推荐 false

6.堆内存设置和 GC的设置

堆内存设置：将JVM 堆大小设置成 6GB , 目前业界比较公认的一个合理值.默认的 1GB 有点小，毕竟 Kafka Broker 在与客户端进行交互时会在 JVM 堆上创建大量的 ByteBuffer 实例，Heap Size 不能太小。

GC的设置：推荐使用 G1 收集器. 其次 CMS

这两个参数

KAFKA_HEAP_OPTS ：6GB 指定堆大小。

KAFKA_JVM_PERFORMANCE_OPTS ：G1 指定 GC 参数

$> export KAFKA_HEAP_OPTS=--Xms6g  --Xmx6g
$> export KAFKA_JVM_PERFORMANCE_OPTS= -server -XX:+UseG1GC -XX:MaxGCPauseMillis=20 -XX:InitiatingHeapOccupancyPercent=35 -XX:+ExplicitGCInvokesConcurrent -Djava.awt.headless=true
$> bin/kafka-server-start.sh config/server.properties

我在项目中处理购物网站的订单消息的时候，会采用kafka的机制。

前端用户将订单数据包含用户id以及付款数据等等，包装成一个json消息体发送到后台中，后台接受订单的接口会@autoware这个kafak生产者类，然后将数据发送到kafka中，然后消费者会处理该topic，下面为一个简单地流程的代码段

实际的生产者消费者（一个案例的形式）

pom文件

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

application.properties

#zookeeper连接地址
kafka.consumer.zookeeper.connect=192.168.16.23:8082
#消费者集群地址ip+port，可以是多个，逗号分隔
kafka.consumer.servers=192.168.16.22:8083
#是否自动提交
kafka.consumer.enable.auto.commit=true
#连接超时时间
kafka.consumer.session.timeout=6000
#刷新间隔时间，负值失败时候刷新，0每次发送后刷新
kafka.consumer.auto.commit.interval=100
#latest-各分区有提交的offset从提交地方消费，没有实时生成实时消费，不会从头消费
#earliest-各分区有提交的offset从提交的地方开始消费，没有提交的从头开始消费
#none-各分区都有提交的offset从提交的地方开始消费，有一个分区没有提交的抛出异常
kafka.consumer.auto.offset.reset=latest
#消费topic
kafka.consumer.topic=topic1
#消费组id
kafka.consumer.group.id=group1
#消费线程数
kafka.consumer.concurrency=10
 
#生产者集群地址ip+port，可以是多个，逗号分隔
kafka.producer.servers=15.128.16.232:8083
#重试次数，默认为0不重试
kafka.producer.retries=0
#批处理字节数，默认16384（16K）
kafka.producer.batch.size=4096
#逗留时间，延时作用，默认为0立即发送
kafka.producer.linger=1
#内存大小，默认33554432（32M），当生成速度大于接收速度，用于缓存消息
kafka.producer.buffer.memory=40960
#消息topic
kafka.topic.default=topic1

生产者配置

package com.xuexi.kafka.config;
 
import java.util.HashMap;
import java.util.Map;
 
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.support.serializer.JsonDeserializer;
import org.springframework.kafka.support.serializer.JsonSerializer;
 
@Configuration
@EnableKafka
public class KafkaProducerConfig {
 
    @Value("${kafka.producer.servers}")
    private String servers;
    @Value("${kafka.producer.retries}")
    private int retries;
    @Value("${kafka.producer.batch.size}")
    private int batchSize;
    @Value("${kafka.producer.linger}")
    private int linger;
    @Value("${kafka.producer.buffer.memory}")
    private int bufferMemory;
 
 
    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        props.put(ProducerConfig.RETRIES_CONFIG, retries);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
        props.put(ProducerConfig.LINGER_MS_CONFIG, linger);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }
 
    public ProducerFactory<String, String> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigs());
    }
 
    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}

消费者配置

package com.xuexi.kafka.config;
 
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.support.serializer.JsonDeserializer;
 
import java.util.HashMap;
import java.util.Map;
 
@Configuration
@EnableKafka
public class KafkaConsumerConfig {
 
    @Value("${kafka.consumer.servers}")
    private String servers;
    @Value("${kafka.consumer.enable.auto.commit}")
    private boolean enableAutoCommit;
    @Value("${kafka.consumer.session.timeout}")
    private String sessionTimeout;
    @Value("${kafka.consumer.auto.commit.interval}")
    private String autoCommitInterval;
    @Value("${kafka.consumer.group.id}")
    private String groupId;
    @Value("${kafka.consumer.auto.offset.reset}")
    private String autoOffsetReset;
    @Value("${kafka.consumer.concurrency}")
    private int concurrency;
 
    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setConcurrency(concurrency);
        factory.getContainerProperties().setPollTimeout(1500);
        return factory;
    }
 
    private ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(
                consumerConfigs(),
                new StringDeserializer(),
                new StringDeserializer()
        );
    }
 
    private Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap<>();
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        return propsMap;
    }
}

生产者

package com.xuexi.kafka.producer;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;
 
@Component
public class SimpleProducer {
 
    @Autowired
    @Qualifier("kafkaTemplate")
    private KafkaTemplate kafkaTemplate;
 
    public void send(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

消费者

package com.xuexi.kafka.consumer;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
 
@Slf4j
@Component
public class SimpleConsumer {
 
    @KafkaListener(topics = "${kafka.topic.default}", containerFactory = "kafkaListenerContainerFactory")
    public void receive(String message) {
 
        if(message.contains("key")){
            //dosomething
            log.info(message);
        }
    }
}

前端调用的生产者接口

package com.xuexi.kafka.controller;
 
import com.xuexi.common.JSONResult;
import com.xuexi.kafka.producer.SimpleProducer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
 
 
@Slf4j
@RestController
@RequestMapping("/kafka")
public class ProduceController {
    @Autowired
    private SimpleProducer simpleProducer;
 
    @Value("${kafka.topic.default}")
    private String topic;
 
    @RequestMapping(value = "/sendKafka", method = RequestMethod.GET, produces = {"application/json"})
    public JSONResult sendKafka() {
		SimpleProducer.send(topic, "测试")；
        return JSONResult.ok();
    }
}

可靠生产者和可靠消费者中的关键配置：

可靠生产者

  Map<String, Object> props = new HashMap<>();
        // 指定多个kafka集群多个地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, KafkaConstants.bootstrapServers);

        // 重试次数，0为不启用重试机制
        props.put(ProducerConfig.RETRIES_CONFIG, 0);
        //同步到副本, 默认为1
        // acks=0 把消息发送到kafka就认为发送成功
        // acks=1 把消息发送到kafka leader分区，并且写入磁盘就认为发送成功
        // acks=all 把消息发送到kafka leader分区，并且leader分区的副本follower对消息进行了同步就任务发送成功
        props.put(ProducerConfig.ACKS_CONFIG, 1);

        // 生产者空间不足时，send()被阻塞的时间，默认60s
        props.put(ProducerConfig.MAX_BLOCK_MS_CONFIG, 6000);
        // 控制批处理大小，单位为字节
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 4096);
        // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 40960);
        // 消息的最大大小限制,也就是说send的消息大小不能超过这个限制, 默认1048576(1MB)
        props.put(ProducerConfig.MAX_REQUEST_SIZE_CONFIG,1048576);
        // 键的序列化方式
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 值的序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 压缩消息，支持四种类型，分别为：none、lz4、gzip、snappy，默认为none。
        // 消费者默认支持解压，所以压缩设置在生产者，消费者无需设置。
        props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"none");
        return props;

可靠消费者

 // 指定多个kafka集群多个地址
       props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, KafkaConstants.bootstrapServers);

       //幂等性
       props.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);
       // 重试次数，0为不启用重试机制，幂等性的时候必须大于0
       props.put(ProducerConfig.RETRIES_CONFIG, 1);
       //同步到副本,
       // 当幂等性 enable.idempotence 为 true，这里默认为 all
       // acks=0 把消息发送到kafka就认为发送成功
       // acks=1 把消息发送到kafka leader分区，并且写入磁盘就认为发送成功
       // acks=all 把消息发送到kafka leader分区，并且leader分区的副本follower对消息进行了同步就任务发送成功
       props.put(ProducerConfig.ACKS_CONFIG, "all");

       // 生产者空间不足时，send()被阻塞的时间，默认60s
       props.put(ProducerConfig.MAX_BLOCK_MS_CONFIG, 6000);
       // 控制批处理大小，单位为字节
       props.put(ProducerConfig.BATCH_SIZE_CONFIG, 4096);
       // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
       props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
       // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
       props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 40960);
       // 消息的最大大小限制,也就是说send的消息大小不能超过这个限制, 默认1048576(1MB)
       props.put(ProducerConfig.MAX_REQUEST_SIZE_CONFIG,1048576);
       // 键的序列化方式
       props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
       // 值的序列化方式
       props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
       // 压缩消息，支持四种类型，分别为：none、lz4、gzip、snappy，默认为none。
       // 消费者默认支持解压，所以压缩设置在生产者，消费者无需设置。
       props.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"none");

这篇文章值得看一下：www.jianshu.com/p/92487ba90…