Kafka消息队列组件

        消息队列的本质是缓冲数据。之所以称之为消息队列系统或者消息队列组件，是因为往往消息队列提供了消息（数据）的管理功能。比如：记录上次读数据的偏移量、消息读取后是否删除、消息的备份和安全等机制。

        主流消息队列组件有：ActiveMQ、RabbitMQ、RocketMQ、kafka等，大数据领域主要用kafka。

        （1）点对点模式（一对一，消费者主动拉取数据，消息收到后消息清除）

        点对点模型通常是一个基于拉取和轮训的消息传达模型，这种模型从队列中请求消息，而不是将消息推送到客户端，这种模型的特点是发送到队列的消息被一个且仅有一个接收者接收处理，即使有多个消息监听者也是如此。

        （2）发布/订阅模式（一对多，数据生产后，推送给订阅者）

        发布订阅模型是一个基于推送的消息传送模型。发布订阅模型可以有多种不同的订阅者，临时订阅者只有在主动监听主题时才接收消息，持久订阅者监听主题的所有消息，即使当前订阅者不可用，处于离线状态。

1）解耦：允许你独立的扩展或修改两边的处理过程，只要确保它们同样遵守接口约束。

2）冗余：消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失的风险。许多消息队列所采用的“插入-获取-删除”范式中，在把一个消息从消息队列删除之前，需要你的处理系统明确的指出该消息已经被处理完毕，从而确保你的数据被安全的保存直到你使用完毕。

3）扩展性：因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的，只要另外增加处理过程即可。

4）灵活性&峰值处理能力：在访问量剧增的情况下，应用仍然需要继续发挥作用，但是这样的突发流量并不常见。如果以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费，使用消息队列能够使关键组件顶住突发的访问压力，而不会因为突发的超负荷的请求而完全崩溃。

5）可恢复性：系统的一部分组件失效时，不会影响整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入消息队列中的消息仍然可以在系统恢复后被处理。

6）顺序保证：在大多使用场景下，数据处理的顺序都很重要。大部分消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理（kafka保证一个partition内消息的有序性）。

7）缓冲：有助于控制和优化数据流经过系统的速度，解决生产消息和消费消息的处理速度不一致的情况。

8）异步通信：很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，语序用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放入多少，等需要处理的时候再去处理它。

        在流式计算中，kafka一般用来缓存数据，storm或者spark通过消费kafka数据进行计算。

1）kafka是由scala语言写的开源系统；

2）kafka是个分布式消息队列。kafka对消息保存时根据topic进行归类，发送消息者称producer，消息接收者为consumer，kafka集群由多个kafka实例组成，每个实例（server）称为broker。

3）无论是kafka集群还是consumer都依赖于zookeeper集群保存一些meta信息，用来保证系统可用性。

1）kafka整体架构图

 2）kafka详细架构图

1)   Producer：消息生产者，就是向kafka broker发消息的客户端；

2） Consumer：消息消费者，从kafkabroker取消息的客户端；

3） Topic：可以理解为一个队列（就是同一个业务的数据放在同一个topic下）；

4）  Consumer Group（CG）：这是kafka用来实现一个topic消息的广播（发给所有的consumer）和单播（发送给任意一个consumer）的手段。一个topic可以有多个consumer group。topic的消息会复制（不是真的复制，是概念上的复制）到所有的CG，但是每个partition只会把消息发给该CG中的一个consumer。如果需要实现广播，只要每个consumer有一个独立的CG就可以了。  要实现单播只要所有的consumer在同一个CG。用CG还可以将consumer进行自由的分组而不需要多次发送消息到不同的topic。

5） Broker：一台kafka服务器就是一个broker。一个集群由多个broker组成。一个broker可以容纳多个topic；

6） Partition：为了实现扩展性，一个非常大的topic可以分布到多个broker（即服务器）上，一个topic可以分为多个partition，每个partition是一个有序的队列。partition中的每条消息都会被分配一个有序的id（offset）。kafka只保证按一个partition中的顺序将消息发给consumer，不保证一个topic的整体（多个partition间）的顺序；

7） Offset：偏移量。

hadoop101，hadoop102，hadoop103：zookeeper、kafka。

Apache Kafka

3.3集群部署安装

1）解压安装包

[root@hadoop101 software]$ tar -zxvf kafka_2.11-0.11.0.0.tgz -C /opt/module/

2）修改解压后的文件名称

[root@hadoop101 module]$ mv kafka_2.11-0.11.0.0/ kafka

3）在/opt/module/kafka目录下创建logs文件夹

[root@hadoop101 kafka]$ mkdir logs

4）修改配置文件

[root@hadoop101 kafka]$ cd config/

[root@hadoop101 config]$ vim server.properties

输入以下内容：

#broker的全局唯一编号，不能重复

broker.id=1

#删除topic功能使能

delete.topic.enable=true

#处理网络请求的线程数量

num.network.threads=3

#用来处理磁盘IO的线程数量

num.io.threads=8

#发送套接字的缓冲区大小

socket.send.buffer.bytes=102400

#接收套接字的缓冲区大小

socket.receive.buffer.bytes=102400

#请求套接字的缓冲区大小

socket.request.max.bytes=104857600

#kafka运行日志存放的路径

log.dirs=/opt/module/kafka/logs

#topic在当前broker上的分区个数

num.partitions=1

#用来恢复和清理data下数据的线程数量

num.recovery.threads.per.data.dir=1

#segment文件保留的最长时间，超时将被删除

log.retention.hours=168

#配置连接Zookeeper集群地址

zookeeper.connect=hadoop101:2181,hadoop102:2181,hadoop103:2181

1. 分发安装包

scp -r /opt/module/kafka/ hadoop102:/opt/module/

scp -r /opt/module/kafka/ hadoop103:/opt/module/

7）分别在hadoop102和hadoop103上修改配置文件/opt/module/kafka/config/server.properties中的broker.id=2、broker.id=3

注：broker.id不得重复

8）启动集群

依次在hadoop101、hadoop102、hadoop103节点上启动kafka

[root@hadoop101 kafka]$ nohup bin/kafka-server-start.sh config/server.properties &

[root@hadoop102 kafka]$ nohup bin/kafka-server-start.sh config/server.properties &

[root@hadoop103 kafka]$ nohup bin/kafka-server-start.sh config/server.properties &

9）关闭集群

[root@hadoop101 kafka]$ bin/kafka-server-stop.sh stop

[root@hadoop102 kafka]$ bin/kafka-server-stop.sh stop

[root@hadoop103 kafka]$ bin/kafka-server-stop.sh stop

3.4 kafka命令行操作

1）查看当前服务器中的所有topic

[root@hadoop101 kafka]$ bin/kafka-topics.sh --zookeeper hadoop101:2181 --list

2）创建topic

[root@hadoop101 kafka]$ bin/kafka-topics.sh --zookeeper hadoop101:2181

--create --replication-factor 3 --partitions 1 --topic first

选项说明：

--topic 定义topic名

--replication-factor  定义副本数

--partitions  定义分区数

3）删除topic

[root@hadoop101 kafka]$ bin/kafka-topics.sh --zookeeper hadoop101:2181

--delete --topic first

需要server.properties中设置delete.topic.enable=true否则只是标记删除或者直接重启。

4）发送消息

创建second主题

bin/kafka-topics.sh --zookeeper hadoop101:2181

--create --replication-factor 3 --partitions 3 --topic second

[root@hadoop101 kafka]$ bin/kafka-console-producer.sh

--broker-list hadoop101:9092 --topic second

>hello world

>bigdata  bigdata

5）消费消息

[root@hadoop102 kafka]$ bin/kafka-console-consumer.sh

--zookeeper hadoop101:2181 --from-beginning --topic second

--from-beginning：会把first主题中以往所有的数据都读取出来。根据业务场景选择是否增加该配置。

6）查看某个Topic的详情

[root@hadoop101 kafka]$ bin/kafka-topics.sh --zookeeper hadoop101:2181

--describe --topic second

四、kafka工作机制剖析

4.1 Kafka写入流程 4.1.1 写入方式

        Producer（生产者）采用推（push）模式将消息发布到broker，每条消息都被追加（append）到分区（partition）中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障kafka吞吐率）。

4.1.2 分区（Partition）

        消息发送时都被发送到一个topic，其本质就是一个目录，而topic是由一些Partition Logs（分区日志）组成，其组织结构如下图：

         每个partition中的消息都是有序的，生产的消息被不断追加到partition log上，其中的每个消息都被赋予了一个唯一的offset值。

1）分区原因：

        （1）方便在集群中扩展，每个partition可以通过调整以适应它所在的机器，而一个topic又可以有多个partition组成，因此整个集群就可以适应任意大小的数据了；

        （2）可以提高并发，因为可以以partition为单位读写。

2）分区的原则：

        （1）指定了partition，则直接使用；

        （2）未指定partition但指定key，通过对key的值进行hash出一个partition；

        （3）partition和key都未指定，使用轮询选出一个partition。

4.1.3 副本（Replication）

        同一个partition可能会有多个replication（对应 server.properties配置中的num.partitions=N）。没有replication的情况下，一旦broker宕机，其上所有partition的数据都不可被消费，同时producer也不能再将数据存于其上的partition。引入replication之后，同一个partition可能会有多个replication，而这时需要在这些replication之间选出一个leader，producer和consumer只与这个leader交互，其它replication作为follower从leader中复制数据。

 4.1.4 写入流程

1）producer先从zookeeper的“/brokers/.../state”节点找到该partition的leader；

2）producer将消息发送到该leader；

3）leader将消息写入本地log；

4）followers从leader pull消息，写入本地log后向leader发送ACK；

5）leader收到所有ISR中的replication的ack后向producer发送ack。

4.2 Broker保存消息 4.2.1 存储方式

        物理上把topic分成一个或多个partition（对应server.properties中的num.partitions=3配置），每个partition物理上对应一个文件夹（该文件夹存储该partition的所有消息和索引文件），如下：

[root@hadoop101 logs]$ ll
drwxrwxr-x. 2 root root 4096 8月   6 14:37 first-0
drwxrwxr-x. 2 root root 4096 8月   6 14:35 first-1
drwxrwxr-x. 2 root root 8月   6 14:37 first-2
[root@hadoop101 logs]$ cd first-0
[root@hadoop101 first-0]$ ll
-rw-rw-r--. 1 root root 10485760 8月   6 14:33 00000000000000000000.index
-rw-rw-r--. 1 root root 219 8月   6 15:07 00000000000000000000.log
-rw-rw-r--. 1 root root 10485756 8月   6 14:33 00000000000000000000.timeindex
-rw-rw-r--. 1 root root 8 8月   6 14:37 leader-epoch-checkpoint

4.2.2 存储策略（消息删除策略）

        无论消息是否被消费，kafka都会保留所有消息。有两种策略可以删除旧数据；

        1）基于时间：log.retention.hours=168

        2）基于大小：log.retention.bytes=1073741824

        需要注意的是，因为kafka读取待定消息的时间复杂度为O（1），即与文件大小无关，所以这里删除过期文件与提高kafka的效率无关。

4.3 kafka消费过程分析 4.3.1 高级API

1）高级API优点

1. 高级API 写起来简单
2. 不需要自行去管理offset，系统通过zookeeper自行管理。
3. 不需要管理分区，副本等情况，系统自动管理。
4. 消费者断线会自动根据上一次记录在zookeeper中的offset去接着获取数据（默认设置1分钟更新一下zookeeper中存的offset）。
5. 可以使用group来区分对同一个topic 的不同程序访问分离开来（不同的group记录不同的offset，这样不同程序读取同一个topic才不会因为offset互相影响）。

2）高级API缺点

1. 不能自行控制offset（对于某些特殊需求来说）；
2. 不能细化控制如分区、副本、zk等。

4.3.2 消费者组

         消费者是以consumer group消费者组的方式工作，由一个或者多个消费者组成一个组，共同消费一个topic。每个分区在同一时间只能由group中的消费者读取，但是多个group可以同时消费这个partition。在图中，有一个由三个消费者组成的group，有一个消费者读取主题中的两个分区，另外两个分别读取一个分区。某个消费者读取某个分区，也可以叫做某个消费者，也可以叫做某个消费者是某个分区的拥有者。

        在这种情况下，消费者可以通过水平扩展的方式同时读取大量的消息。另外，如果一个消费者失败了，那么其他的group成员会自动负载均衡读取之前失败的消费者读取的分区。

4.3.3 消费方式

        consumer采用pull（拉）模式从broker中读取数据。

        push（推）模式很难适应消费速率不同的消费者，因为消息发送的速率是由broker决定的。它的目标是尽可能以最快速度传递消息，但是这样很容易造成consumer来不及处理消息，典型的表现就是拒绝服务以及网络拥塞。而pull模式则可以根据consumer消费能力以适当的速率消费消息。

        对于kafka而言，pull模式更适合，它可简化broker的设计，consumer可自主控制消费消息的速率，同时consumer可以自己控制消费方式。

        pull模式不足之处是，如果kafka没有数据，消费者可能会陷入循环中，一直等待数据到达。

4.3.5 消费者组案例

1）需求：测试同一个消费者组中的消费者，同一时刻只能有一个消费者消费。

2）案例实操

        （1）在hadoop102、hadoop103上修改/opt/module/kafka/config/consumer.properties配置文件中的group.id属性为任意组名。

[root@hadoop102 config]$ vim consumer.properties
group.id=hadoop_kafka

        （2）在hadoop102、hadoop103上分别启动消费者

[root@hadoop102 kafka]$ bin/kafka-console-consumer.sh 
--zookeeper hadoop101:2181 --topic second --consumer.config config/consumer.properties
[root@hadoop103 kafka]$ bin/kafka-console-consumer.sh --zookeeper hadoop101:2181 --topic second --consumer.config config/consumer.properties

        （3）在hadoop101上启动生产者

[root@hadoop101 kafka]$ bin/kafka-console-producer.sh 
--broker-list hadoop101:9092 --topic second
>hello world

        （4）查看hadoop102和hadoop103的接收者。同一时刻只有一个消费者接收到消息。

五、Java API操作kafka 5.1 环境准备

1）启动zk和Kafka集群，在Kafka集群中打开一个消费者

[bigdata@hadoop101 kafka]$ bin/kafka-console-consumer.sh 
--zookeeper hadoop101:2181 --topic second

2）导入pom依赖

    
    
        org.apache.kafka
        kafka-clients
        0.11.0.0
    
    
    
        org.apache.kafka
        kafka_2.12
        0.11.0.0
    

5.2 kafka生产者Java API 5.2.1 创建生产者

package com.bigdata.kafka;
import java.util.Properties;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

public class NewProducer {

	public static void main(String[] args) {
		
		Properties props = new Properties();
		// Kafka服务端的主机名和端口号
		props.put("bootstrap.servers", "hadoop103:9092");
		// 等待所有副本节点的应答
		props.put("acks", "all");
		// 消息发送最大尝试次数
		props.put("retries", 0);
		// 发送缓存区内存大小
		props.put("buffer.memory", 33554432);
		// key序列化
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		// value序列化
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

		Producer producer = new KafkaProducer<>(props);
		for (int i = 0; i < 50; i++) {
			producer.send(new ProducerRecord("second", Integer.toString(i), "hello world-" + i));
		}
//ProducerRecord：发送给broker的k，v对，包含【 ProducerRecord(topic, key, value)】
		producer.close();
	}
}

5.2.2 创建生产者带回调函数

package com.bigdata.kafka;
import java.util.Properties;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.Recordmetadata;

public class CallBackProducer {

	public static void main(String[] args) {

Properties props = new Properties();
		// Kafka服务端的主机名和端口号
		props.put("bootstrap.servers", "hadoop103:9092");
		// 等待所有副本节点的应答
		props.put("acks", "all");
		// 消息发送最大尝试次数
		props.put("retries", 0);
// 发送缓存区内存大小
		props.put("buffer.memory", 33554432);
		// key序列化
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		// value序列化
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

		Producer kafkaProducer = new KafkaProducer<>(props);

		for (int i = 0; i < 50; i++) {

			kafkaProducer.send(new ProducerRecord("second", "hello" + i), new Callback() {

				@Override
				public void onCompletion(Recordmetadata metadata, Exception exception) {

					if (metadata != null) {

						System.err.println(metadata.partition() + "---" + metadata.offset());
					}}});}

		kafkaProducer.close();
	}
}

5.2.3 自定义分区生产者

1）需求：将所有数据存储到topic的第0号分区上

2）自定义分区

package com.bigdata.kafka;
import java.util.Map;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

public class CustomPartitioner implements Partitioner {

	@Override
	public void configure(Map configs) {
		
	}

	@Override
	public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 控制分区
		return 0;
	}

	@Override
	public void close() {
		
	}
}

3）代码调用

package com.bigdata.kafka;
import java.util.Properties;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

public class PartitionerProducer {

	public static void main(String[] args) {
		
		Properties props = new Properties();
		// Kafka服务端的主机名和端口号
		props.put("bootstrap.servers", "hadoop103:9092");
		// 等待所有副本节点的应答
		props.put("acks", "all");
		// 消息发送最大尝试次数
		props.put("retries", 0);
		// 发送缓存区内存大小
		props.put("buffer.memory", 33554432);
		// key序列化
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		// value序列化
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		// 自定义分区
		props.put("partitioner.class", "com.bigdata.kafka.CustomPartitioner");

		Producer producer = new KafkaProducer<>(props);
		producer.send(new ProducerRecord("second", "1", "bigdata"));

		producer.close();
	}
}

4）测试

（1）在hadoop101上监控/opt/module/kafka/logs/目录下first主题3个分区的log日志动态变化情况。

[root@hadoop101 second-0]$ tail -f 00000000000000000000.log
[root@hadoop101 second-1]$ tail -f 00000000000000000000.log
[root@hadoop101 second-2]$ tail -f 00000000000000000000.log

（2）发现数据都存储到指定的分区了。

5.3 kafka消费者API 5.3.1 高级API

1）在控制台创建发送者

[root@hadoop101 kafka]$ bin/kafka-console-producer.sh 
--broker-list hadoop101:9092 --topic second
>hello world

2）官方提供案例（自动维护消费情况）

package com.bigdata.kafka.consume;
import java.util.Arrays;
import java.util.Properties;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

public class CustomNewConsumer {

	public static void main(String[] args) {

		Properties props = new Properties();
		// 定义kakfa 服务的地址，不需要将所有broker指定上 
		props.put("bootstrap.servers", "hadoop101:9092");
		// 制定consumer group 
		props.put("group.id", "test");
		// 是否自动确认offset 
		props.put("enable.auto.commit", "true");
		// 自动确认offset的时间间隔 
		props.put("auto.commit.interval.ms", "1000");
		// key的序列化类
		props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		// value的序列化类 
		props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		// 定义consumer 
		KafkaConsumer consumer = new KafkaConsumer<>(props);
		
		// 消费者订阅的topic, 可同时订阅多个 
		consumer.subscribe(Arrays.asList("first", "second","third"));

		while (true) {
			// 读取数据，读取超时时间为100ms 
			ConsumerRecords records = consumer.poll(100);
			
			for (ConsumerRecord record : records)
				System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
		}
	}
}

六、kafka拦截器 6.1 拦截器（Interceptor）原理

        Producer拦截器（interceptor）是在Kafka 0.10版本被引入的，主要用于实现clients端的定制化控制逻辑。

        对于producer而言，interceptor使得用户在消息发送前以及producer回调逻辑前有机会对消息做一些定制化需求，比如修改信息等。同时，producer允许客户指定多个interceptor按序作用于同一条消息从而形成一个拦截链（interceptor chain）。interceptor的实现接口是org.apache.kafka.clients.producer.ProducerInterceptor，其定义的方法包括：

（1）configure（configs）

        获取配置信息和初始化数据时调用。

（2）onSend（ProducerRecord）：

        该方法封装进kafkaproducer.send方法中，即它运行在用户主线程中。Producer确保在消息被序列化以及计算分区前调用该方法。用户可以在该方法中对消息做任何操作，但最好保证不要修改消息所属的topic和分区，否则会影响目标分区的计算。

（3）onAcknowledgement(Recordmetadata, Exception)：

        该方法会在消息被应答或消息发送失败时调用，并且通常都是在producer回调逻辑触发之前。onAcknowledgement运行在producer的IO线程中，因此不要在该方法中放入很重的逻辑，否则会拖慢producer的消息发送效率。

（4）close：

        关闭interceptor，主要用于执行一些资源清理工作。

        如前所述，interceptor可能被运行在多个线程中，因此在具体实现时用户需要自行确保线程安全另外倘若指定了多个interceptor，则producer将按照指定顺序调用它们，并仅仅是捕获每个interceptor可能抛出的异常记录到错误日志中而非在向上传递。

6.2 interceptor拦截器案例

（1）需求：

        实现一个简单的双interceptor组成的拦截链。第一个interceptor会在消息发送前将时间戳信息加到消息value的最前部；第二个interceptor会在消息发送后更新成功发送消息数或失败发送消息数。

2）案例实操

（1）增加时间戳拦截器

package com.bigdata.kafka.interceptor;
import java.util.Map;
import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.Recordmetadata;

public class TimeInterceptor implements ProducerInterceptor {

	@Override
	public void configure(Map configs) {

	}

	@Override
	public ProducerRecord onSend(ProducerRecord record) {
		// 创建一个新的record，把时间戳写入消息体的最前部
		return new ProducerRecord(record.topic(), record.partition(), record.timestamp(), record.key(),
				System.currentTimeMillis() + "," + record.value().toString());
	}

	@Override
	public void onAcknowledgement(Recordmetadata metadata, Exception exception) {

	}

	@Override
	public void close() {

	}
}

 （2）统计发送消息成功和发送失败消息数，并在producer关闭时打印这两个计数器

package com.bigdata.kafka.interceptor;
import java.util.Map;
import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.Recordmetadata;

public class CounterInterceptor implements ProducerInterceptor{
    private int errorCounter = 0;
    private int successCounter = 0;

	@Override
	public void configure(Map configs) {
		
	}

	@Override
	public ProducerRecord onSend(ProducerRecord record) {
		 return record;
	}

	@Override
	public void onAcknowledgement(Recordmetadata metadata, Exception exception) {
		// 统计成功和失败的次数
        if (exception == null) {
            successCounter++;
        } else {
            errorCounter++;
        }
	}

	@Override
	public void close() {
        // 保存结果
        System.out.println("Successful sent: " + successCounter);
        System.out.println("Failed sent: " + errorCounter);
	}
}

（3）producer主程序

package com.bigdata.kafka.interceptor;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

public class InterceptorProducer {

	public static void main(String[] args) throws Exception {
		// 1 设置配置信息
		Properties props = new Properties();
		props.put("bootstrap.servers", "hadoop101:9092");
		props.put("acks", "all");
		props.put("retries", 0);
		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");
		
		// 2 构建拦截链
		List interceptors = new ArrayList<>();
		interceptors.add("com.bigdata.kafka.interceptor.TimeInterceptor"); 	interceptors.add("com.bigdata.kafka.interceptor.CounterInterceptor"); 
		props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);
		 
		String topic = "second";
		Producer producer = new KafkaProducer<>(props);
		
		// 3 发送消息
		for (int i = 0; i < 10; i++) {
			
		    ProducerRecord record = new ProducerRecord<>(topic, "message" + i);
		    producer.send(record);
		}
		 
		// 4 一定要关闭producer，这样才会调用interceptor的close方法
		producer.close();
	}
}

3）测试

（1）在Kafka上启动消费者，然后运行客户端Java程序。

[root@hadoop101 kafka]$ bin/kafka-console-consumer.sh 
--zookeeper hadoop101:2181 --from-beginning --topic second

1501904047034,message0
1501904047225,message1
1501904047230,message2
1501904047234,message3
1501904047236,message4
1501904047240,message5
1501904047243,message6
1501904047246,message7
1501904047249,message8
1501904047252,message9

（2）观察Java平台控制台输出数据如下

Successful sent: 10
Failed sent: 0

七、kafka与flume集成

1）Flume配置文件内容 (flume-kafka.conf)

# define
a1.sources = r1
a1.sinks = k1
a1.channels = c1

# source
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F  /opt/module/datas/flume.log
a1.sources.r1.shell = /bin/bash -c

# sink
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.kafka.bootstrap.servers = hadoop101:9092,hadoop102:9092,hadoop103:9092
a1.sinks.k1.kafka.topic = second
a1.sinks.k1.kafka.flumeBatchSize = 20
a1.sinks.k1.kafka.producer.acks = -1


# channel
a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000
a1.channels.c1.transactionCapacity = 100

# bind
a1.sources.r1.channels = c1
a1.sinks.k1.channel = c1

2） 启动kafkaIDEA消费者

3） 进入flume根目录下，启动flume

$ bin/flume-ng agent -c conf/ -n a1 -f job/flume-kafka.conf

4） 向 /opt/module/datas/flume.log里追加数据，查看Kafka消费者消费情况

$ echo hello > /opt/module/datas/flume.log