当前位置:   article > 正文

从Kafka系统中读取消息数据——消费

从Kafka系统中读取消息数据——消费

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

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

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

消费 Kafka 集群中的主题消息

检查消费者是不是单线程

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

/**设置轻量级所来阻止多线程并发访问 */
private void acquire(){
	// 检测当前消费者对象是否关闭
	ensureNotClosed();
	//获取当前消费者程序线程 ID
	long 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();	
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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;
	}

	/** 实现一个单线程消费者. */
	@Override
	public 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();
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49

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;
	}

	/** 实现一个单线程消费者程序. */
	@Override
	public 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
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

反序列化主题消息

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

  • 序列化:将对象转换为字节序列,然后在网络上传输或者存储在文件中;
  • 反序列化:将网络或者文件中读取的字节序列数据恢复成对象。
  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());// 打印异常信息
		}
	}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

演示 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;
	}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
(2)编写自定义反序列化逻辑代码;
/**
 * 实现自定义反序列化.
 * 
 * @author smartloli.
 *
 *         Created by May 6, 2018
 */
public class JSalaryDeserializer implements Deserializer<Object> {

	@Override
	public void configure(Map<String, ?> configs, boolean isKey) {

	}

	/** 自定义反序列逻辑. */
	@Override
	public Object deserialize(String topic, byte[] data) {
		return SerializeUtils.deserialize(data);
	}

	@Override
	public void close() {

	}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
(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;
	}

	/** 实现一个单线程消费者. */
	@Override
	public 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();
	}

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
(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;
		}

		@Override
		public 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();
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92

在这里插入图片描述

配置消费者的属性

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

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/78048
推荐阅读
相关标签
  

闽ICP备14008679号