1、kafka是什么

  • Apache Kafka是一个开源消息系统，由Scala写成

  • Kafka最初是由LinkedIn开发，并于2011年初开源

  • Kafka是一个分布式消息队列：生产者消费者的功能。它提供了类似于JMS的特性，但是在设计实现上完全不同，此外它并不是JMS规范的实现

  • Kafka对消息保存时根据Topic进行分类，发送消息者称为producer，消息接受者称为Consumer，此外Kafka集群有多个Kafka实例组成，每个实例称为broker

  • 无论是Kafka集群还是producer和consumer都依赖于zookeeper集群保存一些meta信息，来保证系统的可用性


JMS：jms是Java提供的一套技术规范。

    可以用来异构系统集成通信，缓解系统瓶颈，提高系统的伸缩性增强系统用户体验，使得系统模块化和组件化变得可行并更加灵活。


类JMS消息队列，结合JMS中的两种模式，可以有多个消费者主动拉取数据，在JMS中只有点对点模式才有消费者主动拉取数据。

kafka_第1张图片


kafka是一个生产-消费模型。

    01.Producer：生产者

        只负责数据生产，生产者的代码可以集成到任务系统中。 数据的分发策略由producer决定，默认是defaultPartition  Utils.abs(key.hashCode) % numPartitions

    02.Broker：

        当前服务器上的Kafka进程,俗称拉皮条。只管数据存储，不管是谁生产，不管是谁消费。在集群中每个broker都有一个唯一brokerid，不得重复。

    03.Topic:

        目标发送的目的地，这是一个逻辑上的概念，落到磁盘上是一个partition的目录。partition的目录中有多个segment组合(index,log)

        一个Topic对应多个partition[0,1,2,3]，一个partition对应多个segment组合。一个segment有默认的大小是1G。

        每个partition可以设置多个副本(replication-factor 1),会从所有的副本中选取一个leader出来。所有读写操作都是通过leader来进行的。

        特别强调，和mysql中主从有区别，mysql做主从是为了读写分离，在kafka中读写操作都是leader。

    04.ConsumerGroup：

        数据消费者组，ConsumerGroup可以有多个，每个ConsumerGroup消费的数据都是一样的。

        可以把多个consumer线程划分为一个组，组里面所有成员共同消费一个topic的数据，组员之间不能重复消费。

        （在下面代码配置文件中，可以设置groupID和读取的位置）

    05.zookeeper

        依赖集群保存meta信息（每次读取到哪的信息）。


    kafka_第2张图片

2、kafka生产数据时的分组策略

    默认是defaultPartition  Utils.abs(key.hashCode) % numPartitions

    上文中的key是producer在发送数据时传入的，produer.send(KeyedMessage(topic,myPartitionKey,messageContent))


3、kafka如何保证数据的完全生产

    ack机制：broker表示发来的数据已确认接收无误，表示数据已经保存到磁盘。

    0：不等待broker返回确认消息

    1：等待topic中某个partition leader保存成功的状态反馈

    -1：等待topic中某个partition 所有副本都保存成功的状态反馈

4、broker如何保存数据

    在理论环境下，broker按照顺序读写的机制，可以每秒保存600M的数据。主要通过pagecache机制，尽可能的利用当前物理机器上的空闲内存来做缓存。

    当前topic所属的broker，必定有一个该topic的partition，partition是一个磁盘目录。partition的目录中有多个segment组合(index,log)


5、partition如何分布在不同的broker上

    int i = 0

    list{kafka01,kafka02,kafka03}

    

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

        brIndex = i%broker;

        hostName = list.get(brIndex)

    }

6、consumerGroup的组员和partition之间如何做负载均衡

    最好是一一对应，一个partition对应一个consumer。

    如果consumer的数量过多，必然有空闲的consumer。

    

    算法：

        假如topic1,具有如下partitions: P0,P1,P2,P3

        加入group中,有如下consumer: C1,C2

        首先根据partition索引号对partitions排序: P0,P1,P2,P3

        根据consumer.id排序: C0,C1

        计算倍数: M = [P0,P1,P2,P3].size / [C0,C1].size,本例值M=2(向上取整)

        然后依次分配partitions: C0 = [P0,P1],C1=[P2,P3],即Ci = [P(i * M),P((i + 1) * M -1)]


7、如何保证kafka消费者消费数据是全局有序的

    伪命题

    如果要全局有序的，必须保证生产有序，存储有序，消费有序。

    由于生产可以做集群，存储可以分片，消费可以设置为一个consumerGroup，要保证全局有序，就需要保证每个环节都有序。

    只有一个可能，就是一个生产者，一个partition，一个消费者。这种场景和大数据应用场景相悖。

8.kafka生产数据

import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;

import java.util.Properties;
import java.util.UUID;

/**
 * 这是一个简单的Kafka producer代码
 * 包含两个功能:
 * 1、数据发送
 * 2、数据按照自定义的partition策略进行发送
 * KafkaSpout的类
 */
public class KafkaProducerSimple {
    public static void main(String[] args) {

		//1、指定当前kafka producer生产的数据的目的地
		//创建topic可以输入以下命令，在kafka集群的任一节点进行创建。
		//bin/kafka-topics.sh --create --zookeeper zk01:2181 --replication-factor 1 --partitions 1 --topic test
        String TOPIC = "orderMq";

        //2、读取配置文件
        Properties props = new Properties();

        //key.serializer.class默认为serializer.class
        props.put("serializer.class", "kafka.serializer.StringEncoder");

		//kafka broker对应的主机，格式为host1:port1,host2:port2
        props.put("metadata.broker.list", "kafka01:9092,kafka02:9092,kafka03:9092");
        
//      request.required.acks,设置发送数据是否需要服务端的反馈,有三个值0,1,-1
//		0，意味着producer永远不会等待一个来自broker的ack，这就是0.7版本的行为。这个选项提供了最低的延迟，但是持久化的保证是最弱的，当server挂掉的时候会丢失一些数据。
//		1，意味着在leader replica已经接收到数据后，producer会得到一个ack。这个选项提供了更好的持久性，因为在server确认请求成功处理后，client才会返回。如果刚写到leader上，还没来得及复制leader就挂了，那么消息才可能会丢失。
//		-1，意味着在所有的ISR都接收到数据后，producer才得到一个ack。这个选项提供了最好的持久性，只要还有一个replica存活，那么数据就不会丢失

        props.put("request.required.acks", "1");

//		可选配置，如果不配置，则使用默认的partitioner partitioner.class
//		默认值：kafka.producer.DefaultPartitioner
//		用来把消息分到各个partition中，默认行为是对key进行hash。
        props.put("partitioner.class", "cn.my.storm.kafka.MyLogPartitioner");
//      props.put("partitioner.class", "kafka.producer.DefaultPartitioner");

        //3、通过配置文件，创建生产者
        Producer producer = new Producer(new ProducerConfig(props));

        //4、通过for循环生产数据
        for (int messageNo = 1; messageNo < 100000; messageNo++) {
//            String messageStr = new String(messageNo + "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发" +
//                    "用来配合自定义的MyLogPartitioner进行数据分发");

//            5、调用producer的send方法发送数据
//            注意：这里需要指定 partitionKey，用来配合自定义的MyLogPartitioner进行数据分发
            producer.send(new KeyedMessage(TOPIC, messageNo + "", "appid" + UUID.randomUUID() + "itcast"));
        }
    }
}
import kafka.producer.Partitioner;
import kafka.utils.VerifiableProperties;
import org.apache.log4j.Logger;

public class MyLogPartitioner implements Partitioner {
    private static Logger logger = Logger.getLogger(MyLogPartitioner.class);

    public MyLogPartitioner(VerifiableProperties props) {
    }

    public int partition(Object obj, int numPartitions) {
        return Integer.parseInt(obj.toString())%numPartitions;
//        return 1;
    }

}

9.kafka消费数据（低阶）

import kafka.consumer.Consumer;
import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;
import kafka.message.MessageAndMetadata;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class KafkaConsumerSimple implements Runnable {
    public String title;
    public KafkaStream stream;
    public KafkaConsumerSimple(String title, KafkaStream stream) {
        this.title = title;
        this.stream = stream;
    }
    @Override
    public void run() {
        System.out.println("开始运行 " + title);
        ConsumerIterator it = stream.iterator();
        /**
         * 不停地从stream读取新到来的消息，在等待新的消息时，hasNext()会阻塞
         * 如果调用 `ConsumerConnector#shutdown`，那么`hasNext`会返回false
         * */
        while (it.hasNext()) {
            MessageAndMetadata data = it.next();
            String topic = data.topic();
            int partition = data.partition();
            long offset = data.offset();
            String msg = new String(data.message());
            System.out.println(String.format(
                    "Consumer: [%s],  Topic: [%s],  PartitionId: [%d], Offset: [%d], msg: [%s]",
                    title, topic, partition, offset, msg));
        }
        System.out.println(String.format("Consumer: [%s] exiting ...", title));
    }

    public static void main(String[] args) throws Exception{
        Properties props = new Properties();
        props.put("group.id", "dashujujiagoushi");
        props.put("zookeeper.connect", "zk01:2181,zk02:2181,zk03:2181");
        props.put("auto.offset.reset", "largest");
        props.put("auto.commit.interval.ms", "1000");
        props.put("partition.assignment.strategy", "roundrobin");
        ConsumerConfig config = new ConsumerConfig(props);
        String topic1 = "orderMq";
        String topic2 = "paymentMq";
        
        //只要ConsumerConnector还在的话，consumer会一直等待新消息，不会自己退出
        ConsumerConnector consumerConn = Consumer.createJavaConsumerConnector(config);
        
        //定义一个map
        Map topicCountMap = new HashMap<>();
        topicCountMap.put(topic1, 3);
        
        //Map> 中String是topic， List是对应的流
        Map>> topicStreamsMap = consumerConn.createMessageStreams(topicCountMap);
        
        //取出 `kafkaTest` 对应的 streams
        List> streams = topicStreamsMap.get(topic1);
        
        //创建一个容量为4的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        //创建20个consumer threads
        for (int i = 0; i < streams.size(); i++)
            executor.execute(new KafkaConsumerSimple("消费者" + (i + 1), streams.get(i)));
    }
}


10.kafka和zookeeper使用JavaAPI能够拉取到数据（高阶消费）

properties配置文件

###zookeeper\u548ckafka\u914d\u7f6e\u5730\u5740
zk.connect=xxxxx
#zk.connect=xxxxx
###kafka\u6d88\u8d39\u7684group\u5fc5\u987b\u8c03\u6574\u4e3a\u72ec\u5360
adinfo.log.group.name=qinbin_ad_interfaceLog_20171218
###kafka\u7684topic.\u9700\u8981\u548cadstat\u6a21\u5757\u7684kafka topic\u4e00\u81f4
adinfo.log.topic.name=ad_interfaceLog
adinfo.log.queue.max=10000
adinfo.log.list.size=1
###\u4e2d\u95f4\u7ed3\u679c\u4fdd\u5b58\u65e5\u5fd7
adinfo.log.pathFile=E:/opt/realtime/avro/file/

 
###\u9ed8\u8ba4\u4e0d\u8981\u52a8
adinfo.statistics.time=120000
adinfo.statistics.commitSize=3000

kafka配置文件（注意groupID）




    
        
    
    
	
		
	

	
		
			
				smallest
				314572 
				26214
				104857
				5000
				2000
				5000
				5

然后在spring配置文件中import kafka的配置文件


Java接收：

import java.io.UnsupportedEncodingException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

import javax.annotation.Resource;

import org.apache.avro.io.DatumReader;
import org.apache.avro.specific.SpecificDatumReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.integration.channel.QueueChannel;
import org.springframework.messaging.Message;

import com.ElasticSearchServiceImpl;
import com.IElasticSearchService;
import com.AdInfoRealTimeThread;
import com.ConfigUtil;
import com.AdInfo;

public class AdInfoConsumer {
	// DatumReader adInfoDatumReader = new
	// SpecificDatumReader(AdInfoOld.getClassSchema(),AdInfo.getClassSchema());
	DatumReader adInfoDatumReader = new SpecificDatumReader(AdInfo.class);
	private Logger logger = LoggerFactory.getLogger(AdInfoConsumer.class);
	@Resource(type = ElasticSearchServiceImpl.class)
	private IElasticSearchService elasticSearchServiceImpl;
	@Resource(type = ConfigUtil.class)
	private ConfigUtil configUtil;

	private QueueChannel queueChannel;
	public QueueChannel getQueueChannel() {
		return queueChannel;
	}
	public void setQueueChannel(QueueChannel queueChannel) {
		this.queueChannel = queueChannel;
	}

	private AdInfoRealTimeThread adInfoRealTimeThread;
	public AdInfoRealTimeThread getAdInfoRealTimeThread() {
		return adInfoRealTimeThread;
	}
	public void setAdInfoRealTimeThread(AdInfoRealTimeThread adInfoRealTimeThread) {
		this.adInfoRealTimeThread = adInfoRealTimeThread;
	}

	public void consumerLog() throws UnsupportedEncodingException {

		@SuppressWarnings("rawtypes")
		Message msg;
		while ((msg = queueChannel.receive()) != null) {
			// msg = queueChannel.receive();
			try {
				Map map = (Map) msg.getPayload();
				Set> set = map.entrySet();
				for (Map.Entry entry : set) {
					String topic = entry.getKey();
					ConcurrentHashMap> messages = (ConcurrentHashMap>) entry
							.getValue();
					Collection> values = messages.values();
					for (Iterator> iterator = values.iterator(); iterator.hasNext();) {
						List list = iterator.next();
						for (byte[] object : list) {
							String message = new String(object, "UTF-8");
							StringBuilder megJson = new StringBuilder(message);
							megJson.delete(0, megJson.indexOf("=") + 1);
							// logger.info("json:"+megJson.toString());
							// adinfoToSaveES.saveAdLogToEs(megJson.toString());
							elasticSearchServiceImpl.executeSearch(configUtil.clusterName,megJson.toString());
							//System.out.println(megJson.toString());

						}
					}
				}
			} catch (Exception ex) {
				logger.error("===AdInfoConsumer consumer is exception", ex);
			}
		}

		logger.error("====AdInfoConsumer receive is interrupted====");
	}

	/*
	 * public void consumerLog() throws UnsupportedEncodingException {
	 * 
	 * @SuppressWarnings("rawtypes") Message msg; while ((msg =
	 * queueChannel.receive()) != null) {
	 * 
	 * try {
	 * 
	 * Map map = (Map) msg.getPayload();
	 * Set> set = map.entrySet(); for (Map.Entry entry : set) { // String topic = entry.getKey();
	 * ConcurrentHashMap> messages =
	 * (ConcurrentHashMap>) entry .getValue();
	 * Collection> values = messages.values(); for
	 * (Iterator> iterator = values.iterator(); iterator.hasNext();) {
	 * List list = iterator.next(); for (byte[] object : list) {
	 * 
	 * try { Decoder decoder = DecoderFactory.get().binaryDecoder(object, null);
	 * 
	 * AdInfo adInfo = adInfoDatumReader.read(null, decoder);
	 * 
	 * String json=adInfo.toString(); System.out.println("*************"+json);
	 * //logger.info("json:"+json); //adInfoRealTimeThread.statistics(json);
	 * 
	 * } catch (Exception e) {
	 * logger.error("===AdInfoConsumer consumer one is exception", e); }
	 * 
	 * 
	 * } } } } catch (Exception ex) {
	 * logger.error("===AdInfoConsumer consumer is exception", ex); } }
	 * 
	 * logger.error("====AdInfoConsumer receive is interrupted===="); }
	 */
}