Kafka Producer API

//定义数据源的产生方式：首先定义一个长度为24的字符数组。创建三个线程，每个线程通过随机函数指定发生多少条keyMessage，keyedMessage包含key,value,topicName三个参数。value由不定数量的单词组成，每个单词的长度通过随机函数决定，单词的每个字符通过随机函数确定下标从字符数组中取得。

//实现过程分为三步：

第一步：构建Producer对象（创建Properties对象,传入kafka路径信息等等，创建ProducerConfig对象）

第二步：产生数据源，并且放到KeyedMessage<K,V>对象中，通过Producer对象发送出去

第三步：关闭生产者链接。使用jvm钩子，避免连接断开的时候，有线程还没执行结束。

package com.ibeifeng.spark.kafka;


import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;
import java.util.Properties;
import java.util.Random;


/**
 * Created by haojin on 4/25/2018.
 */
public class producerDemo {
    public static void main(String[] args) {


        final char[] chars = "qwasfrevhfsirtucvmklgfaq".toCharArray();
        final int charsLength = chars.length;
        final String topicName = "beifeng0";
        //1.创建producer对象
        //1.1 构建Properties对象，并且给定kafka连接的相关参数
        Properties prop = new Properties();
        //a.给定kafka的路径信息
        prop.put("metadata.broker.list","spark.ibeifng.com:9092,spark.ibeifeng.com:9093,spark.ibeifeng.com:9094,spark.ibeifeng.com:9095");
        //b.给定数据发送是否等待broker返回，0表示不返回
        prop.put("request.required.acks","0");
        //c.给定发送的方式，默认hi同步
        prop.put("producer.type","sync");
        //g给定消费者系列化为byte数组的方式
        prop.put("serializer.class","kafka.serializer.StringEncoder");
        //e.给定数据的分区器，决定数据发送到那个分区上
        prop.put("partitioner.class","com.ibeifeng.spark.kafka.PartitionDemo");


        //1.2 构建ProducerConfig对象
        ProducerConfig config = new ProducerConfig(prop);
        //1.3 构建Producer对象
        final Producer<String,String> producer = new Producer<String,String>(config);


        //2.以多线程的形式去发送数据
        final Random random = new Random(System.currentTimeMillis());
        for(int i = 0; i<3 ; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //初始化一个发送keyMessage数据条数的值
                    int events = random.nextInt(1000) + 100;
                    String threadname = Thread.currentThread().getName();
                    for(int j = 0; j < events; j++){
                        if(j != 0 && j % 100 ==0){
                            System.out.println("线程["+ threadname + "]已经发送"+j+"条数据！");
                        }
                        //1.构建发送的KeyMessage对象
                        String key = "key" + random.nextInt(100);
                        //假设value是有24个字母组成的单词，单词的长度范围是[1,10]
                        StringBuilder sb = new StringBuilder();
                        int wordNums  = random.nextInt(10) + 1;  //1-10
                        for(int k = 0; k < wordNums;k++){
                            StringBuilder sb2 = new StringBuilder();
                            int chasrNums = random.nextInt(4) + 2;
                            for(int l = 0; l < chasrNums; l++){
                                sb2.append(chars[random.nextInt(charsLength)]);
                            }
                            sb.append(sb2.toString().trim());
                        }
                        String value = sb.toString().trim();
                        KeyedMessage<String,String> message  = new KeyedMessage<String,String>(topicName,key,value);
                    //2.发送消息
                        producer.send(message);


                        //3.发送一会休息一下
                        try {
                            Thread.sleep(random.nextInt(50) + 10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程[" + threadname +"]已经发送完了，总共"+ events+"条数据");


                }
            },"Thread-"+i).start();
        }


        //3.关闭生产者连接
        //jvm钩子
        Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
            @Override
            public void run() {
                producer.close();
            }
        }));

    }
}