Spark Programming Guide

java

^ wordcount

 package streaming.java;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.storage.StorageLevel;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaPairDStream;
import org.apache.spark.streaming.api.java.JavaReceiverInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import scala.Tuple2;

import java.util.Arrays;
import java.util.Iterator;

/**
 *  java版本wordcount程序
 */
public class UpdateStateByKeyWordCount {

    public static void main(String[] args) throws Exception{
        SparkConf conf = new SparkConf()
                .setMaster("local[2]")
                .setAppName("wc");

        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(1));

        // 第一點，如果要使用 updateStateByKe算子，就必須設置一個checkpoint目錄，開啓checkpoint機制
        // 這樣的話才能把每個key對應的state除了在內存中有，那麼是不是也要checkpoint一份
        // 因爲要長期保存一份key的stage的話，那麼spark streaming是要求必須用checkpoint的，以便在
        // 內存數據丟失的時候，可以從checkpoint中恢復數據

        // 開啓checkpoint機制，只要調用jssc的checkpoint()方法，設置一個hdfs目錄即可
        // jssc.checkpoint("hdfs://master106:9000/wordcount_checkpoint");

        // 然後先實現基礎的wordcount邏輯
        JavaReceiverInputDStream<String> lines = jssc.socketTextStream("localhost",9999, StorageLevel.MEMORY_AND_DISK_SER());


        // flatMap算子，將每一行文本，拆分爲多個單詞
        // flatMap算子，在java中，接收的參數是FlatMapFunction
        // 我們需要自己定義FlatMapFunction的第二個泛型類型，即，代表了返回的新元素的類型
        // call()方法，返回的類型與FlatMapFunction的第二個泛型類型相同
        JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {

            public Iterator<String> call(String line) throws Exception {
                return Arrays.asList(line.split(" ")).iterator();
            }
        });
        words.print(6);
        JavaPairDStream<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {
            public Tuple2<String, Integer> call(String word) throws Exception {
                return new Tuple2<String, Integer>(word,1);
            }
        });

        JavaPairDStream<String,Integer> wordcount = pairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });


        jssc.start();
        jssc.awaitTermination();
        jssc.close();
    }
}

^ UpdateStateByKeyWordCount

package streaming.java;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.Optional;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.storage.StorageLevel;
import org.apache.spark.streaming.Durations;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaPairDStream;
import org.apache.spark.streaming.api.java.JavaReceiverInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import scala.Int;
import scala.Tuple2;
import sun.net.dns.ResolverConfiguration;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * 基於updateStateByKey算子實現緩存機制的實時wordcount程序
 */
public class UpdateStateByKeyWordCount {

    public static void main(String[] args) throws Exception {
        SparkConf conf = new SparkConf()
                .setMaster("local[2]")
                .setAppName("wc");

        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(1));

        // 第一點，如果要使用 updateStateByKe算子，就必須設置一個checkpoint目錄，開啓checkpoint機制
        // 這樣的話才能把每個key對應的state除了在內存中有，那麼是不是也要checkpoint一份
        // 因爲要長期保存一份key的stage的話，那麼spark streaming是要求必須用checkpoint的，以便在
        // 內存數據丟失的時候，可以從checkpoint中恢復數據

        // 開啓checkpoint機制，只要調用jssc的checkpoint()方法，設置一個hdfs目錄即可
        jssc.checkpoint("hdfs://master106/wordcount_checkpoint");

        // 然後先實現基礎的wordcount邏輯
        JavaReceiverInputDStream<String> lines = jssc.socketTextStream("master106", 9999, StorageLevel.MEMORY_AND_DISK_SER());


        // flatMap算子，將每一行文本，拆分爲多個單詞
        // flatMap算子，在java中，接收的參數是FlatMapFunction
        // 我們需要自己定義FlatMapFunction的第二個泛型類型，即，代表了返回的新元素的類型
        // call()方法，返回的類型與FlatMapFunction的第二個泛型類型相同
        JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {

            public Iterator<String> call(String line) throws Exception {
                return Arrays.asList(line.split(" ")).iterator();
            }
        });

        JavaPairDStream<String, Integer> pairs = words.mapToPair(new PairFunction<String, String, Integer>() {
            public Tuple2<String, Integer> call(String word) throws Exception {
                return new Tuple2<String, Integer>(word, 1);
            }
        });

 /*       JavaPairDStream<String,Integer> wordcount = pairs.reduceByKey(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });*/

        // 到了這裏，就不一樣了，之前的話，直接就是pairs.reduceByKey,
        // 然後就可以得到每個時間段的batch對應的rdd，打印出那個時間段的單詞計數
        // 但是，有個問題，如果要統計每個單詞的全局的計數呢？
        // 就是說，統計出來，從程序啓動開始，到現在爲止，一個單詞出現的次數，那麼之前的方式就不好實現
        // 就必須基於redis這種緩存，或者mysql這種db，來實現累加
        // 但是，undateStateByKey就可以實現直接通過spark維護一份每個單詞的全局的統計次數
        JavaPairDStream<String, Integer> wordCounts = pairs.updateStateByKey(
                // 這裏的Optional,相當於scala中的樣例類,就是Option,可以理解它代表一個狀態,可能之前存在,也可能之前不存在
                new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
                    private static final long serialVersionUID = 1L;
                    // 實際上,對於每個單詞,每次batch計算的時候,都會調用這個函數,第一個參數,values相當於這個batch中,這個key的新的值,
                    // 可能有多個,比如一個hello,可能有2個1,(hello,1) (hello,1) 那麼傳入的是(1,1)
                    // 那麼第二個參數表示的是這個key之前的狀態,其實泛型的參數是你自己指定的
                    public Optional<Integer> call(List<Integer> values, Optional<Integer> state) throws Exception {
                        // 首先定義一個全局的單詞計數
                        Integer newValue = 0;
                        // 其次，判斷state是否存在，如果不存在，說明是key第一次出現
                        // 如果存在，說明這個key之前已經統計過全局的計數了
                        if (state.isPresent()) {
                            newValue = state.get();
                        }
                        //接着，將本次新出現的值，都累加到newValue上去，就是一個key全局的統計次數
                        for (Integer value : values)
                            newValue += value;
                        return Optional.of(newValue);
                    }
                });

        // 到這裏爲止，相當於是，每個batch過來是，計算到pairs DStream，就會執行全局的updateStateByKey
        // 算子，updateByKey返回的JavaPairDStream,其實就代表了每個key的全局的計數
        // 打印處理
        wordCounts.print();

        jssc.start();
        jssc.awaitTermination();
        jssc.close();
    }
}

scala

wordcount