Kafka(下)

四、Kafka API实战

1、环境准备

1）在idea中创建一个maven工程
2）在pom文件中添加依赖：

	<name>kafka</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>0.11.0.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-streams -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
            <version>0.11.0.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

[1@hadoop1 kafka_2.11-0.11.0.0]$ bin/kafka-console-consumer.sh --zookeeper hadoop1:2181 --topic first

2、Kafka生产者Java API

<1>、创建生产者

package kafka_syllabus;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class CustomerProducer {

    public static void main(String[] args) {

        Properties prop = new Properties();
        //kafka服务端的主机名和端口号
        prop.put("bootstrap.servers","hadoop1:9092");
        //等待所有副本节点的应答
        prop.put("acks","all");
        //消息发送最大尝试次数
        prop.put("retries","0");
        //一批消息处理的大小
        prop.put("batch.size","16384");
        //请求延时
        prop.put("linger.ms","5");
        //发送缓存区内存大小
        prop.put("buffer.memory","33554432");
        //key序列化
        prop.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        //value序列化
        prop.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String,String> producer = new KafkaProducer<String, String>(prop);
        for (int i=0;i<50;i++){
            producer.send(new ProducerRecord<String, String>("test2","zpw"+i));
        }
        producer.close();
    }
}

<2>、创建生产者带回调函数

package kafka_syllabus;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Properties;

public class CustomerProducer2 {
    public static void main(String[] args) {

        Properties prop = new Properties();
        //kafka服务端的主机名和端口号
        prop.put("bootstrap.servers", "hadoop1:9092");
        //等待所有副本节点的应答
        prop.put("acks", "all");
        //消息发送最大尝试次数
        prop.put("retries", "0");
        //一批消息处理的大小
        prop.put("batch.size", "16384");
        //请求延时
        prop.put("linger.ms", "5");
        //发送缓存区内存大小
        prop.put("buffer.memory", "33554432");
        //key序列化
        prop.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //value序列化
        prop.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(prop);
        for (int i = 0; i < 50; i++) {
            //调用producer的send方法，进行消息的发送，每条待发送的消息，都必须封装为一个Record对象，接口回调
            producer.send(new ProducerRecord<String, String>("test2", "zpw" + i), new Callback() {

                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (metadata != null){
                        System.out.println(metadata.offset()+"----"+metadata.partition());
                    }

                }
            });
        }
        //关闭释放资源
        producer.close();
    }
}

<3>、自定义分区生产者

自定义分区

package partitioner;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

public class CustomerPartitioner1 implements Partitioner {

    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        return 1;
    }

    public void close() {

    }

    public void configure(Map<String, ?> configs) {

    }
}

在代码中调用

		//设置分区
        prop.put("partitioner.class","partitioner.CustomerPartitioner1");

3、Kafka消费者Java API

package consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

public class CustomerConsumer1 {

    public static void main(String[] args) {

        //1配置消费者属性
        Properties prop = new Properties();
        //kafka服务端的主机名和端口号
        prop.put("bootstrap.servers","hadoop1:9092");
        //设置消费组
        prop.put("group.id","g1");
        //是否自动确认offset
        prop.put("enable.auto.commit",true);
        //key的反序列化
        prop.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
        //value的反序列化
        prop.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");

        //2创建消费者实例
        final KafkaConsumer<String,String> consumer = new KafkaConsumer<String, String>(prop);

        //4关闭资源
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            public void run() {
                if (consumer != null){
                    consumer.close();
                }
            }
        }));

        //3订阅消息主题
        consumer.subscribe(Arrays.asList("test2"));

        //拉信息
        while (true){
            //读取数据，读取超时时间是100毫秒
            ConsumerRecords<String,String> records = consumer.poll(100);
            for ( ConsumerRecord<String, String> record:records){
                System.out.println(record.offset()+"---"+record.partition());
            }
        }
    }
}

五、Kafka Producer拦截器

1、拦截器原理

Producer拦截器(interceptor)是在Kafka 0.10版本被引入的，主要用于实现clients端的定制化控制逻辑。
对于producer而言，interceptor使得用户在消息发送前以及producer回调逻辑前有机会对消息做一些定制化需求，比如修改消息等。同时，producer允许用户指定多个interceptor按序作用于同一条消息从而形成一个拦截链(interceptor chain)。Intercetpor的实现接口是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可能抛出的异常记录到错误日志中而非在向上传递。这在使用过程中要特别留意。

2、拦截器案例

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

1、编写时间拦截器

package interceptor;

import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Map;

/**
 * 时间拦截器
 */

public class TimeInterceptor implements ProducerInterceptor<String,String> {

    //未进入到kafka进群之前调用
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
        return new ProducerRecord<String, String>("test2",record.partition(),record.key(),
                System.currentTimeMillis()+","+record.value());
    }

    //在消息被应答或消息发送失败的时候调用
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

    }

    //释放资源
    public void close() {

    }

    //初始化
    public void configure(Map<String, ?> configs) {

    }
}

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

package interceptor;

import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Map;

/**
 * 发送成功和失败次数拦截器
 */

public class CounterInterceptor implements ProducerInterceptor<String,String> {
    private long successCount = 0;
    private long errorCount = 0;

    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> record) {
        return record;
    }

    //应答或发送失败的时候会被调用
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        if (exception == null){
            successCount ++;
        }else {
            errorCount ++;
        }
    }

    //释放资源
    public void close() {
        System.out.println("成功的次数" + successCount);
        System.out.println("失败的次数" + errorCount);
    }

    public void configure(Map<String, ?> configs) {

    }
}

3、producer主程序

package kafka_syllabus;

import org.apache.kafka.clients.producer.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class CustomerProducer3 {

    public static void main(String[] args) {

        Properties prop = new Properties();
        //kafka服务端的主机名和端口
        prop.put("bootstrap.servers","hadoop1:9092");
        //等待所有副本节点的应答
        prop.put("acks","all");
        //消息发送最大尝试数
        prop.put("retries",0);
        //一批消息处理的大小
        prop.put("batch.size","16384");
        //请求延时
        prop.put("linger.ms",5);
        //发送缓存区内存大小
        prop.put("buffer.memory","33554432");
        //key的序列化
        prop.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        //value序列化
        prop.put("value.serializer","\"org.apache.kafka.common.serialization.StringSerializer");
        //设置分区
        prop.put("partitioner.class","partitioner.CustomerPartitioner1");
        //注册拦截器
        List<String> list = new ArrayList<String>();
        list.add("interceptor.TimeInterceptor");
        list.add("interceptor.CounterInterceptor");
        prop.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,list);

        KafkaProducer<String,String> producer = new KafkaProducer<String, String>(prop);
        for (int i=0;i<50;i++) {
            producer.send(new ProducerRecord<String, String>("test2", "zpw" + i), new Callback() {
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (metadata != null){
                        System.out.println(metadata.offset()+"---"+metadata.partition());
                    }
                }
            });
        }
        //释放资源
        producer.close();
    }
}

六、Kafka Streams

1、概述

Kafka Streams。Apache Kafka开源项目的一个组成部分。是一个功能强大，易于使用的库。用于在Kafka上构建高可分布式、拓展性，容错的应用程序。

2、特点

• 功能强大：高扩展性，弹性，容错
• 轻量级：无需专门的集群；是一个库，而不是一个框架
• 完全集成：100%的Kafka0.10.0版本兼容；易于集成到现有的应用程序
• 实时性：毫秒级延迟；并非微批处理；窗口允许乱序数据；允许迟到数据

3、为什么要有Kafka Streams

第一，Spark和Storm都是流式处理框架，而Kafka Stream提供的是一个基于Kafka的流式处理类库。框架要求开发者按照特定的方式去开发逻辑部分，供框架调用。开发者很难了解框架的具体运行方式，从而使得调试成本高，并且使用受限。而Kafka Stream作为流式处理类库，直接提供具体的类给开发者调用，整个应用的运行方式主要由开发者控制，方便使用和调试。

第二，虽然Cloudera与Hortonworks方便了Storm和Spark的部署，但是这些框架的部署仍然相对复杂。而Kafka Stream作为类库，可以非常方便的嵌入应用程序中，它对应用的打包和部署基本没有任何要求。
第三，就流式处理系统而言，基本都支持Kafka作为数据源。例如Storm具有专门的kafka-spout，而Spark也提供专门的spark-streaming-kafka模块。事实上，Kafka基本上是主流的流式处理系统的标准数据源。换言之，大部分流式系统中都已部署了Kafka，此时使用Kafka Stream的成本非常低。
第四，使用Storm或Spark Streaming时，需要为框架本身的进程预留资源，如Storm的supervisor和Spark on YARN的node manager。即使对于应用实例而言，框架本身也会占用部分资源，如Spark Streaming需要为shuffle和storage预留内存。但是Kafka作为类库不占用系统资源。
第五，由于Kafka本身提供数据持久化，因此Kafka Stream提供滚动部署和滚动升级以及重新计算的能力。
第六，由于Kafka Consumer Rebalance机制，Kafka Stream可以在线动态调整并行度。

4、Kafka Streams数据清洗案例

需求：实时处理单词带有“>>>”前缀的内容。例如输入”atguigu>>>ximenqing”，最终处理成“ximenqing”
需求分析：

具体业务处理：

package stream;

import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorContext;

public class LogProcessor implements Processor<byte[],byte[]> {
    private ProcessorContext processorContext;
    //初始化
    public void init(ProcessorContext processorContext) {
        this.processorContext = processorContext;
    }

    //每条数据都会调用该方法
    public void process(byte[] bytes, byte[] bytes2) {
        String inputOri = new String(bytes2);
        //如果数据中有">>>"则删除
        if (inputOri.contains(">>>")){
            inputOri = inputOri.split(">>>")[1];
        }
        processorContext.forward(bytes,inputOri.getBytes());
    }

    //周期性调用该方法
    public void punctuate(long l) {

    }

    //释放资源
    public void close() {

    }
}

主类：

package stream;

import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsConfig;
import org.apache.kafka.streams.processor.Processor;
import org.apache.kafka.streams.processor.ProcessorSupplier;
import org.apache.kafka.streams.processor.TopologyBuilder;

import java.util.Properties;

public class App {

    public static void main(String[] args) {
        String fromTopic = "test2";
        String toTopic = "test3";

        Properties prop = new Properties();
        prop.put(StreamsConfig.APPLICATION_ID_CONFIG,"logProcessor");
        prop.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop1:9092,hadoop2:9092,hadoop3:9092");

        //实例化StreamsConfig
        StreamsConfig streamsConfig = new StreamsConfig(prop);

        //构建拓扑
        TopologyBuilder topologyBuilder = new TopologyBuilder();
        topologyBuilder.addSource("SOURCE",fromTopic).addProcessor("PROCESSOR", new ProcessorSupplier<byte[],byte[]>() {
            public Processor<byte[], byte[]> get() {
                return new LogProcessor();
            }
        },"SOURCE").addSink("SINK",toTopic,"PROCESSOR");

        //根据"StreamsConfig对象"以及用于构建拓扑的Builder对象"实例化Kafka streams
        KafkaStreams kafkaStreams = new KafkaStreams(topologyBuilder,streamsConfig);
        kafkaStreams.start();
    }
}