カフカの生産ニュース、ストリーミング消費

パッケージcom.bd.useranalysis.spark.streaming.kafka2es。

輸入com.alibaba.fastjson.JSON。
輸入com.bd.useranalysis.common.config.ConfigUtil。
輸入com.bd.useranalysis.common.project.datatype.DataTypeProperties。
輸入org.apache.kafka.clients.consumer.ConsumerRecord; 
輸入org.apache.kafka.clients.producer.ProducerConfig; 
輸入org.apache.kafka.common.serialization.StringDeserializer。
輸入org.apache.spark.SparkConf。
輸入org.apache.spark.api.java.JavaRDD; 
輸入org.apache.spark.api.java.JavaSparkContext; 
輸入org.apache.spark.api.java.function.Function。
輸入org.apache.spark.api.java.function.VoidFunction。
輸入org.apache.spark.streaming.Durations。
輸入org.apache.spark.streaming.api.java.JavaDStream。
輸入org.apache.spark.streaming.api.java.JavaInputDStream。
輸入org.apache.spark.streaming.api.java.JavaStreamingContext; 
輸入org.apache.spark.streaming.kafka010 *。; 

輸入java.utilの。*; 

パブリッククラスKafka2EsJava { 

    プロパティのプロパティ= ConfigUtil.getInstance（）のgetProperties（ "カフカ/ kafka-server-config.properties"）。

    静的セットの<string>のdataType = DataTypeProperties.dataTypeMap.keySet（）。

    公共の静的な無効メイン（文字列[]引数）例外：InterruptedExceptionをスロー{ 

        SparkConf sparkConf =新しいSparkConf（）setAppName（ "sparkstreaming_kafka2es"）setMaster（ "[2]ローカル"）。
        JavaSparkContext JSC =新しいJavaSparkContext（sparkConf）。
        jsc.setLogLevel（ "WARN"）; 
        JavaStreamingContext JSS =新しいJavaStreamingContext（JSC、持続時間。

        地図<文字列、オブジェクト> kafkaParams =新しいHashMapの<>（）; 
        kafkaParams.put（ "bootstrap.servers"、 "quyf：9092"）; 
        kafkaParams.put（ "key.deserializer"、StringDeserializer.class）。
        kafkaParams.put（ "value.deserializer"、StringDeserializer.class）。
        kafkaParams.put（ "group.id"、 "test_20190815"）; 
        kafkaParams.put（ "auto.offset.reset"、 "最新"）; 
        kafkaParams.put（ "enable.auto.commit"、真の）; 
        リストの<string> topicList =は、Arrays.asList（ "テスト"、 "TEST2"）。
        JavaInputDStream <ConsumerRecord <文字列、文字列>>ストリーム= KafkaUtils。

        JavaDStream <HashMapの<文字列、文字列>> recordDS = stream.map（新しい機能<ConsumerRecord <文字列、文字列>、HashMapの<文字列、文字列>>（）{ 

            @Override 
            公共のHashMap <文字列、文字列>コール（ConsumerRecord <文字列文字列>の記録）は例外{スロー
                //System.out.println("consumer ==> "+ record.valueを（））; 
                JSON.parseObject（record.value（）、HashMap.class）を返します; 
            } 
        }）。

        {：（dataTypeは文字列型）用
            recordDS.filter（新機能<HashMapの<文字列、文字列>、ブール>（）{  
                @Override
                パブリックブールコール（HashMapの<文字列、文字列>
                } 
            }）。foreachRDD（新しいVoidFunction <JavaRDD <HashMapの<文字列、文字列>>>（）{ 
                @Override 
                公共ボイドコール（JavaRDD <HashMapの<文字列、文字列>> mapJavaRDD）は例外{スロー
                   mapJavaRDD.foreach（新しいVoidFunction <HashMapを<文字列、文字列>>（）{ 
                       @Override 
                       公共ボイドコール（HashMapの<文字列、文字列> stringStringHashMap）は例外{スロー
                           するSystem.out.println（stringStringHashMap.toString（））と、
                   }）; 
                } 
            }）。
        } 

        jss.start（）。
        jss.awaitTermination（）; 

    } 
}

　　

パブリッククラスGenKafkaData { 

    公共の静的な無効メイン（文字列[]引数）例外{スロー
        リストの<string>行= IOUtils.readLines（新規FileReader（
                新しいファイル（ "E：\\微信\\ wechat_source1_1111153.txt"）））を、

        プロデューサー<文字列、文字列>プロデューサー= getProducer（）。

        ArrayList <ストリング>列= DataTypeProperties.dataTypeMap.get（ "微信"）。
        地図<文字列、文字列> DATAMAP =新しいHashMapの<>（）; 
        dataMap.put（ "テーブル"、 "微信"）。
        （文字列ライン：ライン）のための{ 
            文字列[]フィールド= line.split（ "\ tの"）; 
            以下のために（INT i = 0; iはfields.length <; iは++）{ 
                dataMap.put（columns.get（I）、
            }
            int型のインデックス= 0; 
                ストリングlineRecord = JSON.toJSONString（データマップ）。
                producer.send（新しいProducerRecord <>（ "TEST2"、ヌル、lineRecord））; 
                Thread.sleep（1000）; 
                インデックス++; 
                System.out.println（ "送信- >" + lineRecord）。
                （インデックス== 10）{もし
                    破ります。
                } 
            } 
            //System.out.println("send->"+lineRecord）。
            //StringProducer.producer("test」、lineRecord）。
        } 
    } 

    パブリック静的プロデューサー<文字列、文字列> getProducer（）{
        プロデューサー<文字列、文字列>プロデューサー=新しいKafkaProducer <文字列、文字列>（createProducerProperties（））。
        プロデューサーを返します。
    } 

    プライベート静的プロパティcreateProducerProperties（）{ 
        プロパティ小道具=新しいプロパティ（）; 
// props.put（ "key.serializer"、 "org.apache.kafka.common.serialization.StringSerializer"）; 
// props.put（ "value.serializer"、 "org.apache.kafka.common.serialization.StringSerializer"）; 
        props.put（ "key.serializer"、StringSerializer.class）。
        props.put（ "value.serializer"、StringSerializer.class）。
        props.put（ "bootstrap.servers"、 "quyf：9092"）; 
        props.put（「リンガー。
        小道具を返します。
    } 
}