Kafka学习笔记之扫盲

本文使用的Kafka版本0.11

先思考些问题:

我想分析一下用户行为（pageviews），以便我能设计出更好的广告位
我想对用户的搜索关键词进行统计，分析出当前的流行趋势。这个很有意思，在经济学上有个长裙理论，就是说，如果长裙的销量高了，说明经济不景气了，因为姑娘们没钱买各种丝袜了。
有些数据，我觉得存数据库浪费，直接存硬盘又怕到时候操作效率低。

这个时候，我们就可以用到分布式消息系统了。虽然上面的描述更偏向于一个日志系统，但确实kafka在实际应用中被大量的用于日志系统。
这些场景都有一个共同点：数据是由上游模块产生，上游模块，使用上游模块的数据计算、统计、分析，这个时候就可以使用消息系统，尤其是分布式消息系统！

Kafka是一个分布式消息系统，由linkedin使用scala编写. Kafka的动态扩容是通过Zookeeper来实现的。
Zookeeper是一种在分布式系统中被广泛用来作为：分布式状态管理、分布式协调管理、分布式配置管理、和分布式锁服务的集群。kafka增加和减少服务器都会在Zookeeper节点上触发相应的事件。

编程

APIDOC:http://kafka.apache.org/0110/...
官方github例子： https://github.com/apache/kaf...

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>0.11.0.0</version>
</dependency>

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
    <version>0.11.0.0</version>
</dependency>

首先贴一下官方例子：

Producer:

public class MyKafkaProducer {

    public static void main(String[] args) {
        /**
         * 这个例子中，每次调用都会创建一个Producer实例，但此处只是为了演示方便，实际使用中，请将Producer作为单例使用，它是线程安全的。

         * 从Kafka 0.11 开始，KafkaProducer支持两种额外的模式：幂等(idempotent)与事务(transactional)。幂等使得之前的at least once变成exactly once传送
         * 幂等Producer的重试不再会导致重复消息。事务允许应用程序以原子方式将消息发送到多个分区（和主题！）

         * 开启idempotence幂等:props.put("enable.idempotence", true);设置之后retries属性自动被设为Integer.MAX_VALUE;;acks属性自动设为all;;max.inflight.requests.per.connection属性自动设为1.其余一样。

         * 开启事务性： props.put("transactional.id", "my-transactional-id");一旦这个属性被设置，那么幂等也会自动开启。然后使用事务API操作即可
         */
    }
    private static void send(){
        Properties props = new Properties();
         props.put("bootstrap.servers", "localhost:9092");
         props.put("enable.idempotence", true);//开启idempotence幂等 extract-once
//         props.put("acks", "all");//acks配置控制请求被认为完成的条件
//         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");
         props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

         Producer<String, String> producer = new KafkaProducer<>(props);
         for (int i = 0; i < 100; i++)
             producer.send(new ProducerRecord<String, String>("my-topic", Integer.toString(i), Integer.toString(i)));

         producer.close();
    }
    private static void sendInTx(){
         Properties props = new Properties();
         props.put("bootstrap.servers", "localhost:9092");
         props.put("transactional.id", "my-transactional-id");//要启用事务，必须配置一个唯一的事务id

         /**
          * http://kafka.apache.org/0110/javadoc/index.html?org/apache/kafka/clients/producer/KafkaProducer.html
          * KafkaProducer类是线程安全的，可以在多线程之间共享。
          */
         Producer<String, String> producer = new KafkaProducer<>(props, new StringSerializer(), new StringSerializer());

         producer.initTransactions();

         try {
             producer.beginTransaction();
             for (int i = 0; i < 100; i++){
                 // send()是异步的，会立即返回，内部是缓存到producer的buffer中，以便于生产者可以批量提交， 你也可以传递一个回调send(ProducerRecord<K,V> record, Callback callback)
                 producer.send(new ProducerRecord<>("my-topic", Integer.toString(i), Integer.toString(i)));
             }
             producer.commitTransaction();
         } catch (ProducerFencedException | OutOfOrderSequenceException | AuthorizationException e) {
             //无法恢复的异常，我们只能关闭producer 
             producer.close();
         } catch (KafkaException e) {
             // 可恢复的异常，终止事务然后重试即可。
             producer.abortTransaction();
         }
         producer.close();
    }
}

发送完之后，我们可以用bin目录下的kafka-console-consumer来看发送的结果（当然现在用的topic是test）。可以用命令：

./kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

Consumer:

/**
 *与producer不同，Kafka consumer不是线程安全的。
 */
public class MyKafkaConsumer {
    /**
     * 通过配置enable.auto.commit,auto.commit.interval.ms来定期自动提交消费的偏移量
     */
    private  void recieveByAutoCommitOffset(){
        Properties props = new Properties();
         props.put("bootstrap.servers", "localhost:9092");
         props.put("group.id", "test");
         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("foo", "bar"));
         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());
         }
//         consumer.wakeup();
    }
    /**
     * 手动提交消费的偏移量,这样用户可以控制记录何时被视为已消费，从而提交其偏移量。 当消息的消耗与一些处理逻辑相结合时，这是有用的，因为在完成处理之前不应将消息视为已消费。
     */
    private void recieveByManualCommitOffset(){
        Properties props = new Properties();
         props.put("bootstrap.servers", "localhost:9092");
         props.put("group.id", "test");
         props.put("enable.auto.commit", "false");//手动提交offset
         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("foo", "bar"));
         final int minBatchSize = 200;
         List<ConsumerRecord<String, String>> buffer = new ArrayList<>();
         while (true) {
             ConsumerRecords<String, String> records = consumer.poll(100);
             for (ConsumerRecord<String, String> record : records) {
                 buffer.add(record);
             }
             if (buffer.size() >= minBatchSize) {
//                 insertIntoDb(buffer); 执行相关逻辑
                 consumer.commitSync();//提交offset
                 buffer.clear();
             }
         }
    }
}

Streams:

public class MyKafkaStreams {
    public void test(){
        Map<String, Object> props = new HashMap<>();
         props.put(StreamsConfig.APPLICATION_ID_CONFIG, "my-stream-processing-application");
         props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
         props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
         props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
         StreamsConfig config = new StreamsConfig(props);

         KStreamBuilder builder = new KStreamBuilder();
         builder.stream("my-input-topic").mapValues(value -> value.toString()+"!!!").to("my-output-topic");

         KafkaStreams streams = new KafkaStreams(builder, config);
         streams.start();
    }
}

注意点：

将producer写成单例模式，有助于减少zookeeper端占用的资源。Producer自身是线程安全的类，只要封装得当就能最恰当的发挥好producer的作用。(ZkClient去连接zookeeper的server时候都会创建sendThread和eventThread两个线程，其中sendThread主要用于client与server端之间的网络连接，真正的处理线程由eventThread来执行。Zookeeper是一个分布式的协调框架，而分布式应用中经常会出现动态的增加或删除节点的操作，所以为了实时了解分布式整个节点的数量和基本信息，就有必要维护一个长连接的线程与服务端保持连接。另外zookeeper连接时占用的时间也比较长，如果每次生产数据时都连接发起一次连接势必造成了大量时间的耗费。)
kafka是将消息按照topic的形式存储，一个topic会按照partition存在同一个文件夹下，目录在config/server.properties中指定：

# The directory under which to store log files
log.dir=/tmp/kafka-logs

在消息系统中都会有这样一个问题存在，数据消费状态这个信息到底存哪里。是存在consumer端，还是存在broker端。对于这样的争论，一般会出现三种情况：

At most once ：消息一旦发出就立马标记已消费，不会再有第二发生即使失败了，缺点是容易丢失消息。
At least once ：消息至少发送一次,如果消息未能接受成功,可能会重发,直到接收成功.
Exactly once ：每个消息仅发生一次，而且一次就能确保到达。这是理想状态。(kafka0.11支持幂等之后，在开启幂等的情况下，就是这种模式)

at most once: 消费者fetch消息,然后保存offset,然后处理消息;当client保存offset之后,但是在消息处理过程中出现了异常,导致部分消息未能继续处理.那么此后"未处理"的消息将不能被fetch到,这就是"atmost once".

at least once: 消费者fetch消息,然后处理消息,然后保存offset.如果消息处理成功之后,但是在保存offset阶段zookeeper异常导致保存操作未能执行成功,这就导致接下来再次fetch时可能获得上次已经处理过的消息,这就是"at least once"，原因offset没有及时的提交给zookeeper，zookeeper恢复正常还是之前offset状态.

logback-kafka集成例子

https://github.com/xbynet/log...

参考：

http://kafka.apache.org/docum...
http://kafka.apache.org/intro...
https://my.oschina.net/ielts0...
http://blog.csdn.net/my_bai/a...
http://www.infoq.com/cn/artic...
http://www.cnblogs.com/likehu...
http://www.cnblogs.com/likehu...
https://www.iteblog.com/archi...

Kafka学习笔记之扫盲

相关概念

Kafka架构

配置项：

编程

logback-kafka集成例子

参考：

xbynet

引用和评论

Java9模块化学习笔记三之迁移到Java9

在Java程序中监听mysql的binlog

Jerry和您聊聊Chrome开发者工具

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊

Just for fun——迅速写完快速排序

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

💢线上高延迟请求排查

Kafka学习笔记之扫盲

相关概念

Kafka架构

配置项：

编程

logback-kafka集成例子

参考：

xbynet

引用和评论

Java9模块化学习笔记三之迁移到Java9

在Java程序中监听mysql的binlog

Jerry和您聊聊Chrome开发者工具

Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

Just for fun——迅速写完快速排序

Spring 实现 3 种异步流式接口，干掉接口超时烦恼

💢线上高延迟请求排查

Bitmap 和布隆过滤器傻傻分不清？你这不应该啊