SparkStreaming算子分爲兩類：transformation算子和outputOperator算子
transformation算子：flatMap、count、mapToPair、map、countByValue、repartition、filter、join、union、Reduce、reduceByKey、updataStateByKey、Window、transform
outputOperator算子：print、foreachRDD、saveAsTextFile、saveAsHadoopFile、saveAsObjectFile
outputoperator類的算子
print：顯示DStream結果
foreachRDD：可以遍歷DStream中的RDD，對RDD使用RDD的算子去轉換，一定要有RDD的action類算子觸發RDD的transformation類算子執行
foreachRDD中除了RDD算子之內的代碼在Executor中執行，其他在Driver端執行，可以在foreachRDD中動態改變廣播變量的值，因爲每隔batchInterval會執行foreachRDD中的代碼一次
saveAsTextFile
saveAsHadoopFile
saveAsObjectFile
可以觸發transformation類算子去執行，可以拿到SparkStreaming中的RDD進行處理
foreachRDD算子 注意：
1、foreachRDD是DStream中outputoperator類算子
2、foreachRDD可以遍歷得到DStream中的RDD，可以在這個算子內對RDD使用RDD的Transformation類算子進行轉換，但是一定要使用RDD的Action類算子觸發執行
3、foreachRDD可以得到DStream中的RDD，在這個算子內，RDD算子外執行的代碼是在Driver端執行的，RDD算子內的代碼是在Driver端執行的
counts.foreachRDD(new VoidFunction<JavaPairRDD<String,Integer>>() {
private static final long serialVersionUID = 1L;
@Override
public void call(JavaPairRDD<String, Integer> arg0)
throws Exception {
System.out.println("*****************");
//轉換爲RDD，需要Action算子觸發
JavaRDD<String> maprdd = arg0.map(new Function<Tuple2<String,Integer>, String>() {
private static final long serialVersionUID = 1L;
@Override
public String call(Tuple2<String, Integer> arg0)
throws Exception {
//這個裏面在Executor端執行，外面在Driver端執行，包括上一層的call方法也是在Driver端執行
System.out.println("--------------");
return arg0._1+"---"+arg0._2;
}
});
maprdd.collect();
}
});
updateStateByKey算子
/**
* UpdateStateByKey的主要功能:
* 1、爲Spark Streaming中每一個Key維護一份state狀態，state類型可以是任意類型的， 可以是一個自定義的對象，那麼更新函數也可以是自定義的。
* 2、通過更新函數對該key的狀態不斷更新，對於每個新的batch而言，Spark Streaming會在使用updateStateByKey的時候爲已經存在的key進行state的狀態更新
*
* hello,3
* bjsxt,2
*
* 如果要不斷的更新每個key的state，就一定涉及到了狀態的保存和容錯，這個時候就需要開啓checkpoint機制和功能
*
* 全面的廣告點擊分析
* @author root
*
* 有何用？ 統計廣告點擊流量，統計這一天的車流量，統計點擊量
*/
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local[2]").setAppName("UpdateStateByKeyDemo");
JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
/**
* 設置checkpoint目錄
*
* 多久會將內存中的數據（每一個key所對應的狀態）寫入到磁盤上一份呢？
* 如果你的batch interval小於10s 那麼10s會將內存中的數據寫入到磁盤一份
* 如果bacth interval 大於10s，那麼就以bacth interval爲準
*
* 這樣做是爲了防止頻繁的寫HDFS
*/
// jsc.checkpoint("hdfs://node1:9000/spark/checkpoint");
jsc.checkpoint("./checkpoint");
JavaReceiverInputDStream<String> lines = jsc.socketTextStream("CentOS16", 9999);
JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
private static final long serialVersionUID = 1L;
@Override
public Iterable<String> call(String s) {
return Arrays.asList(s.split(" "));
}
});
JavaPairDStream<String, Integer> ones = words.mapToPair(new PairFunction<String, String, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, Integer> call(String s) {
return new Tuple2<String, Integer>(s, 1);
}
});
JavaPairDStream<String, Integer> counts =
ones.updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
private static final long serialVersionUID = 1L;
@Override
public Optional<Integer> call(List<Integer> values, Optional<Integer> state) throws Exception {
/**
* values:經過分組最後 這個key所對應的value [1,1,1,1,1]
* state:這個key在本次之前之前的狀態
*/
Integer updateValue = 0 ;
if(state.isPresent()){
updateValue = state.get();
}
for (Integer value : values) {
updateValue += value;
}
return Optional.of(updateValue);
}
});
//output operator
counts.print();
jsc.start();
jsc.awaitTermination();
jsc.close();
}
count算子：
count:
通過計算源DStream的每個RDD中的元素數量，返回單元素RDD的新DStream。
public class Operate_count {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("Operate_count");
JavaStreamingContext jsc = new JavaStreamingContext(conf,Durations.seconds(5));
JavaDStream<String> textFileStream = jsc.textFileStream("data");
JavaDStream<Long> count = textFileStream.count();
count.print();
jsc.start();
jsc.awaitTermination();
jsc.close();
}
}
countByValue:
當調用類型爲K的元素的DStream時，返回（K，Long）鍵值對的新DStream，
其中鍵值對的value是key對應的value在Dstream中出現的次數.
public class Operate_countByValue {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("Operate_countByValue");
JavaStreamingContext jsc = new JavaStreamingContext(conf,Durations.seconds(5));
JavaDStream<String> textFileStream = jsc.textFileStream("data");
JavaPairDStream<String, Integer> mapToPair = textFileStream.mapToPair(new PairFunction<String, String, Integer>() {
private static final long serialVersionUID = 1L;
public Tuple2<String, Integer> call(String s) throws Exception {
return new Tuple2<String, Integer>(s.split(" ")[0].trim(),Integer.valueOf(s.split(" ")[1].trim()));
}
});
JavaPairDStream<Tuple2<String, Integer>, Long> countByValue = mapToPair.countByValue();
countByValue.print(1000);
jsc.start();
jsc.awaitTermination();
jsc.close();
}
}
join :數據上面的合併，會把多個Dstream的數據進行合併
當（K，V）格式和（K，W）格式的兩個Dstream使用時，返回一個新的（K，（V，W））格式的DStream。
注意：join 作用在（K,V）格式的DStream
public class Operate_join {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("Operate_join");
JavaStreamingContext jsc = new JavaStreamingContext(conf,Durations.seconds(5));
JavaDStream<String> textFileStream = jsc.textFileStream("data");
//flatMapToPair算子，讀取一行數據，以空格切分，出去一堆RDD數據
JavaPairDStream<String, Integer> flatMapToPair = textFileStream.flatMapToPair(new PairFlatMapFunction<String, String, Integer>() {
private static final long serialVersionUID = 1L;
@SuppressWarnings("unchecked")
public Iterable<Tuple2<String, Integer>> call(String t)
throws Exception {
return Arrays.asList(new Tuple2<String , Integer>(t.trim(), 1));
}
});
flatMapToPair.join(flatMapToPair).print(1000);
jsc.start();
jsc.awaitTermination();
jsc.close();
}
}
union:邏輯上面的合併，不會對數據進行處理
返回一個新的DStream，它包含源DStream和otherDStream中元素的並集。
public class Operate_union {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("Operate_union");
JavaStreamingContext jsc = new JavaStreamingContext(conf,
Durations.seconds(5));
JavaDStream<String> textFileStream1 = jsc.textFileStream("data");
JavaDStream<String> textFileStream2 = jsc.textFileStream("data");
JavaDStream<String> union = textFileStream1.union(textFileStream2);
union.print(1000);
jsc.start();
jsc.awaitTermination();
jsc.close();
}
}
Reduce算子
/**
*reduce(func): 通過使用函數func（其接受兩個參數並返回一個）聚合DStream的每個RDD中的元素,
*返回單元素RDD的新DStream 。該函數是關聯的，以便可以並行計算。
*reduce 處理後返回的是一條數據結果
*
*/
public class Operate_reduce {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("Operate_reduce");
JavaStreamingContext jsc = new JavaStreamingContext(conf,Durations.seconds(5));
JavaDStream<String> textFileStream = jsc.textFileStream("data");
/**
* 下面是拼接本次和下次的字符串來模擬reduce處理數據
*/
JavaDStream<String> reduce = textFileStream.reduce(new Function2<String, String, String>() {
private static final long serialVersionUID = 1L;
public String call(String s1, String s2) throws Exception {
return s1+"****"+s2;
}
});
reduce.print();
jsc.start();
jsc.awaitTermination();
jsc.close();
}
}