转自《 Kafka并不难学！入门、进阶、商业实战》

消费者是读取kafka分区中信息的一个实例

注意：
一个消费者可以读取多个分区
一个分区不能被多个消费者读取

消费 Kafka 集群中的主题消息

检查消费者是不是单线程

Kafka 系统的消费者接口是向下兼容的，即，在新版 Kafka 系统中老版的消费者接口仍可以使用。在新版本的 Kafka 系统中，消费者程序代码被重构了–通过 Java 语言对消费者KafkaConsumer 类进行了重新编码。
KafkaConsumer 是非多线程并发安全的:如果多个线程公用一个 KafkaConsumer 实例，则抛出异常错误信息。KafkaConsumer 类中判断是否为单线程的内容见代码 5-2。

/**设置轻量级所来阻止多线程并发访问 */
private void acquire(){// 检测当前消费者对象是否关闭ensureNotClosed();//获取当前消费者程序线程 IDlong threadId = Thread.currentThread().getId();// 判断是否主为单线程if (threadld != currentThread.get()&& !currentThread.compareAndSet(NO CURRENT THREAD, threadId))throw new ConcurrentModificationException("KafkaConsumer is not safe formulti-threaded access");refcount.incrementAndGet();	
}

KafkaConsumer 类通过 acquire()函数来监控访问的请求是否存在并发多线程操作。如果存在，则抛出一个 ConcurrentModificationException 异常

主题如何自动获取分区和手动分配分区

阅读 KafkaConsumer 类的实现代码可以发现，该类实现了org.apache.kafka.clients.consumer.Consumer 接口。该接口提供了用户访问 Kafka 集群主题的应用接口，主要包含以下两种。

• subscribe:订阅指定的主题列表，来获取自动分配的分区;
• assign:手动向主题分配分区列表，指定需要“消费”的分区。

1. 自动获取分区
   如果调用 subscribeO函数订阅主题，则消费者组中的消费者程序会被动态分配到分区，同时被指定一个 org.apache.kafka.clients.consumer.ConsumerRebalanceListener 接口。当用户分配给消费者程序的分区集合发生变化时，可以通过回调函数的接口来触发自定义操作。
   使用 subscribe0函数订阅主题时，有三个重载函数可供选择。
   (1)subscribe(Collectiontopics):指定订阅主题集合:
   (2)subscribe(Collection topics, ConsumerRebalanceListener callback):分区发生变化时，通过回调函数来进行自动分区操作;
   (3)subscribe(Pattern pattern, ConsumerRebalanceListener callback):使用正则表达式来订阅主题，当主题或者主题分区发生变化时，通过回调函数来进行自动分区操作。
2. 手动分配分区
   手动分配分区的方式可以通过调用 assignO函数来实现。assignO)函数与 subscribeO)函数的底层实现逻辑类似，也是先做一系列的检查工作，比如，是否含有并发操作、请求的参数是否合法(分区是否为空)等。

subscribe实现订阅（自动获取分区）

/*** 实现一个消费者实例代码.* * @author smartloli.**         Created by May 6, 2018*/
public class JConsumerSubscribe extends Thread {public static void main(String[] args) {JConsumerSubscribe jconsumer = new JConsumerSubscribe();jconsumer.start();}/** 初始化Kafka集群信息. */private Properties configure() {Properties props = new Properties();props.put("bootstrap.servers", "dn1:9092,dn2:9092,dn3:9092");// 指定Kafka集群地址props.put("group.id", "ke");// 指定消费者组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");return props;}/** 实现一个单线程消费者. */@Overridepublic void run() {// 创建一个消费者实例对象KafkaConsumer<String, String> consumer = new KafkaConsumer<>(configure());// 订阅消费主题集合consumer.subscribe(Arrays.asList("ip_login_rt"));// 实时消费标识boolean flag = true;while (flag) {// 获取主题消息数据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.commitAsync();
//		consumer.commitSync();consumer.close();}
}

assign（手动分配分区）

/*** 实现一个手动分配分区的消费者实例.* * @author smartloli.**         Created by May 6, 2018*/
public class JConsumerAssign extends Thread {public static void main(String[] args) {JConsumerAssign jconsumer = new JConsumerAssign();jconsumer.start();}/** 初始化Kafka集群信息. */private Properties configure() {Properties props = new Properties();props.put("bootstrap.servers", "dn1:9092,dn2:9092,dn3:9092");// 指定Kafka集群地址props.put("group.id", "ke");// 指定消费者组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");return props;}/** 实现一个单线程消费者程序. */@Overridepublic void run() {// 创建一个消费者实例对象KafkaConsumer<String, String> consumer = new KafkaConsumer<>(configure());// 设置自定义分区TopicPartition tp = new TopicPartition("test_kafka_game_x", 0);// 手动分配consumer.assign(Collections.singleton(tp));// 实时消费标识boolean flag = true;while (flag) {// 获取主题消息数据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.close();}
}

反序列化主题消息

在分布式环境下，有序列化和反序列化两个概念

• 序列化:将对象转换为字节序列，然后在网络上传输或者存储在文件中;
• 反序列化:将网络或者文件中读取的字节序列数据恢复成对象。

1. 为什么需要实现反序列
   在传统企业应用中，不同的组件分布在不同的系统和网络中，通过序列化协议实现对象的传输，保证了两个组件之间的通信安全。经过序列化后的消息数据会转换成二进制。
   如果需要将这些二进制进行业务逻辑处理，则需要将这些二进制数据进行反序列化，将其还原成对象。
2. 反序列一个对象
   为了反序列化一个对象，用户必须保证序列化对象和反序列化对象一致下面以 Java 语言为例，实现一个反序列化类。

反序列化一个类.

/*** 反序列化一个类.* * @author smartloli.**         Created by May 6, 2018*/
public class JObjectDeserialize {/** 创建一个日志对象实例. */private static Logger LOG = LoggerFactory.getLogger(JObjectSerial.class);/** 实例化入口函数. */@SuppressWarnings("resource")public static void main(String[] args) {try {FileInputStream fis = new FileInputStream("/tmp/salary.out"); // 实例化一个输入流对象JObjectSerial jos = (JObjectSerial) new ObjectInputStream(fis).readObject();// 反序列化还原对象LOG.info("ID : " + jos.id + " , Money : " + jos.money);// 打印反序列化还原后的对象属性} catch (Exception e) {LOG.error("Deserial has error, msg is " + e.getMessage());// 打印异常信息}}}

演示 Kafka 自定义反序列化代码

Kafka 系统中提供了反序列化的接口，以方便用户调用。用户可以通过自定义反序列化的
方式来还原对象。
下面通过实例演示 Kafka 白定义反序列化具体操作。

(1)编写一个反序列化工具类;

/*** 封装一个序列化的工具类.* * @author smartloli.**         Created by Apr 30, 2018*/
public class SerializeUtils {/** 实现序列化. */public static byte[] serialize(Object object) {try {return object.toString().getBytes("UTF8");// 返回字节数组} catch (Exception e) {e.printStackTrace(); // 抛出异常信息}return null;}/** 实现反序列化. */public static <T> Object deserialize(byte[] bytes) {try {return new String(bytes, "UTF8");// 反序列化} catch (Exception e) {e.printStackTrace();}return null;}}

(2)编写自定义反序列化逻辑代码;

/*** 实现自定义反序列化.* * @author smartloli.**         Created by May 6, 2018*/
public class JSalaryDeserializer implements Deserializer<Object> {@Overridepublic void configure(Map<String, ?> configs, boolean isKey) {}/** 自定义反序列逻辑. */@Overridepublic Object deserialize(String topic, byte[] data) {return SerializeUtils.deserialize(data);}@Overridepublic void close() {}}

(3)编写一个消费者应用程序;

/*** 实现一个消费者实例代码.* * @author smartloli.**         Created by May 6, 2018*/
public class JConsumerDeserialize extends Thread {/** 自定义序列化消费者实例入口. */public static void main(String[] args) {JConsumerDeserialize jconsumer = new JConsumerDeserialize();jconsumer.start();}/** 初始化Kafka集群信息. */private Properties configure() {Properties props = new Properties();props.put("bootstrap.servers", "dn1:9092,dn2:9092,dn3:9092");// 指定Kafka集群地址props.put("group.id", "ke");// 指定消费者组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.smartloli.kafka.game.x.book_5.deserialize.JSalaryDeserializer");return props;}/** 实现一个单线程消费者. */@Overridepublic void run() {// 创建一个消费者实例对象KafkaConsumer<String, String> consumer = new KafkaConsumer<>(configure());// 订阅消费主题集合consumer.subscribe(Arrays.asList("test_topic_ser_des"));// 实时消费标识boolean flag = true;while (flag) {// 获取主题消息数据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.close();}}

(4)执行整个自定义反序列化代码，输出结果如图5-19 所示。

如何提交消息的偏移量

Kafka 0.10.0x 版本之前的消费者程序会将“消费”的偏移量(Ofsets)提交到 Zookeeper系统的/consumers 目录。
例如，消费者组名为 test topic gl，主题名为 test topic，分区数为1，那么运行老版本消费者程序后,在 Zookeeper 系统中,偏移量提交的路径是/consumers/test topic_gl/ofisets/test topic/0Zookeeper 系统并不适合频繁地进行读写操作，因为 Zookeeper 系统性能降低会严重影响Kafka 集群的吞吐量。所以，在 Kafka 新版本消费者程序中，对偏移量的提交进行了重构，将其保存到 Kafka 系统内部主题中,消费者程序产生的偏移量会持续追加到该内部主题的分区中。Kafka系统提供了两种方式来提交偏移量，它们分别是自动提交和手动提交。

1. 自动提交
   使用 KafkaConsumer 自动提交偏移量时，需要在配置属性中将“enable.auto.commit”设置为 true，另外可以设置“auto.commit.interval.ms”属性来控制自动提交的时间间隔。Kafka 系统自动提交偏移量的底层实现调用了 ConsumerCoordinator 的 commitOffsetsSync()函数来进行同步提交，或者 commitOfsetsAsync()函数来进行异步提交。自动提交的流程如图5-20 所示。
   
2. 手动提交
   在编写消费者程序代码时，将配置属性“enable.auto.commit”的值设为“false”，则可以通过手动模式来提交偏移量。
   KafkaConsumer消费者程序类提供了两种手动提交偏移量的方式–同步提交commitSync()函数和异步提交 commitAsync()函数。
   阅读这两种提交方式的源代码可以发现，它们的底层分别由消费者协调器ConsumerCoordinator 的同步提交偏移量 commitOfsetsSync()函数和异步提交偏移量commitOffsetsAsync()函数来实现。
   消费者应用程序通过 ConsumerCoordinator 来发送 OfsetCommitRequest 请求，Kafka 服务器端接收到请求后，由组协调器 GroupCoordinator 进行处理，然后将偏移量信息追加到 Kafka系统内部主题中。

使用多线程消费多个分区的主题

在分布式应用场景中，Kafka 系统为了保证集群的可扩展性,对主题添加了多分区的概念而在实际消费者程序中，随着主题数据量的增加，可能一个消费者程序难以满足要求。下面通过实例来演示多线程消费多分区主题。

/*** 多线程消费者实例.* * @author smartloli.**         Created by May 6, 2018*/
public class JConsumerMutil {// 创建一个日志对象private final static Logger LOG = LoggerFactory.getLogger(JConsumerMutil.class);private final KafkaConsumer<String, String> consumer; // 声明一个消费者实例private ExecutorService executorService; // 声明一个线程池接口public JConsumerMutil() {Properties props = new Properties();props.put("bootstrap.servers", "dn1:9095,dn2:9094,dn3:9092");// 指定Kafka集群地址props.put("group.id", "ke");// 指定消费者组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");// 反序列化消费记录consumer = new KafkaConsumer<String, String>(props);// 实例化消费者对象consumer.subscribe(Arrays.asList("kv3_topic"));// 订阅消费者主题}/** 执行多线程消费者实例. */public void execute() {// 初始化线程池executorService = Executors.newFixedThreadPool(6);while (true) {// 拉取Kafka主题消息数据ConsumerRecords<String, String> records = consumer.poll(100);if (null != records) {executorService.submit(new KafkaConsumerThread(records, consumer));}}}/** 关闭消费者实例对象和线程池 */public void shutdown() {try {if (consumer != null) {consumer.close();}if (executorService != null) {executorService.shutdown();}if (!executorService.awaitTermination(10, TimeUnit.SECONDS)) {LOG.error("Shutdown kafka consumer thread timeout.");}} catch (InterruptedException ignored) {Thread.currentThread().interrupt();}}/** 消费者线程实例. */class KafkaConsumerThread implements Runnable {private ConsumerRecords<String, String> records;public KafkaConsumerThread(ConsumerRecords<String, String> records, KafkaConsumer<String, String> consumer) {this.records = records;}@Overridepublic void run() {for (TopicPartition partition : records.partitions()) {// 获取消费记录数据集List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);LOG.info("Thread id : "+Thread.currentThread().getId());// 打印消费记录for (ConsumerRecord<String, String> record : partitionRecords) {System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());}}}}/** 多线程消费者实例入口. */public static void main(String[] args) {JConsumerMutil consumer = new JConsumerMutil();try {consumer.execute();} catch (Exception e) {LOG.error("Mutil consumer from kafka has error,msg is " + e.getMessage());consumer.shutdown();}}
}

配置消费者的属性

新版 Kanka 系统引入了新的消费者属性。在使用 Java 语言编写消费者应用程序时，可以按需添加一些属性来控制消息数据的读取。具体属性见表 5-2。