Spark Streaming之updateStateByKey和mapWithState比较
一 UpdateStateByKey
UpdateStateByKey：统计全局的key的状态，但是就算没有数据输入，他也会在每一个批次的时候返回之前的key的状态。假设5s产生一个批次的数据，那么5s的时候就会更新一次的key的值，然后返回。
这样的缺点就是，如果数据量太大的话，而且我们需要checkpoint数据，这样会占用较大的存储。
如果要使用updateStateByKey,就需要设置一个checkpoint目录，开启checkpoint机制。因为key的state是在内存维护的，如果宕机，则重启之后之前维护的状态就没有了，所以要长期保存它的话需要启用checkpoint，以便恢复数据。
public classSparkUpdateKeyByState {
public staticvoid main(String[]args) {
SparkConf conf= new SparkConf().setAppName("SparkUpdate Key By State").setMaster("local[*]");
JavaStreamingContextjssc= new JavaStreamingContext(conf,Durations.seconds(2));
String checkpointDir= "hdfs://hdfs-cluster/ecommerce/checkpoint/state";
jssc.checkpoint(checkpointDir);
JavaReceiverInputDStream<String>messages = jssc.socketTextStream("hadoop-all-01",9999);
JavaDStream<String>words = messages.flatMap(newFlatMapFunction<String,String>() {
public Iterator<String>call(String s) throws Exception {
return Arrays.asList(s.split(" ")).iterator();
}
});
JavaPairDStream<String,Integer> pairs = words.mapToPair(newPairFunction<String,String, Integer>() {
public Tuple2<String,Integer> call(Stringword) throwsException {
return new Tuple2(word,1);
}
});
// 统计全局的word count，而不是单一的某一批次
JavaPairDStream<String,Integer>wordcounts = pairs.updateStateByKey
(new Function2<List<Integer>,Optional<Integer>,Optional<Integer>>() {
// 参数valueList:相当于这个batch,这个key新的值，可能有多个,比如（hadoop,1）(hadoop,1)传入的可能是(1,1)
// 参数oldState:就是指这个key之前的状态
public Optional<Integer>call(List<Integer>valueList, Optional<Integer>oldState) throwsException {
Integer newState= 0;
// 如果oldState之前已经存在，那么这个key可能之前液晶被统计过，否则说明这个key第一次出现
if (oldState.isPresent()) {
newState = oldState.get();
}
// 更新state
for (Integervalue : valueList) {
newState += value;
}
return Optional.of(newState);
}
});
jssc.start();
try {
jssc.awaitTermination();
} catch (InterruptedExceptione) {
e.printStackTrace();
}
jssc.close();
}
}
二 MapWithState
MapWithState：也是用于全局统计key的状态，但是它如果没有数据输入，便不会返回之前的key的状态，有一点增量的感觉。
这样做的好处是，我们可以只是关心那些已经发生的变化的key，对于没有数据输入，则不会返回那些没有变化的key的数据。这样的话，即使数据量很大，checkpoint也不会像updateStateByKey那样，占用太多的存储。
objectMapWithStateKafkaDirect extendsApp {
val conf = new SparkConf().setAppName("MapWithStateKafkaDirect").setMaster("local[*]")
val sc = SparkContext.getOrCreate(conf)
val checkpointDir= "hdfs://hdfs-cluster/ecommerce/checkpoint/2"
val brokers= "hadoop-all-01:9092,hadoop-all-02:9092,hadoop-all-03:9092"
def mappingFunction(key:String,value:Option[Int],state:State[Long]):(String,Long) = {
// 获取之前状态的值
val oldState= state.getOption().getOrElse(0L)
// 计算当前状态值
val newState= oldState + value.getOrElse(0)
// 更新状态值
state.update(newState)
// 返回结果
(key,newState)
}
val spec = StateSpec.function[String,Int,Long,(String,Long)](mappingFunction_)
def creatingFunc():StreamingContext= {
val ssc = new StreamingContext(sc,Seconds(5))
val kafkaParams= Map(
"metadata.broker.list"->brokers,
"group.id"->"MapWithStateKafkaDirect"
)
val topics= Set("count")
val messages= KafkaUtils.createDirectStream[String,String,StringDecoder,StringDecoder](ssc,kafkaParams,topics)
val results:DStream[(String,Long)] =messages
.filter(_._2.nonEmpty)
.mapPartitions(iter =>{
iter.flatMap(_._2.split(" ").map((_,1)))
})
.mapWithState(spec)
results.print()
ssc.checkpoint(checkpointDir)
ssc
}
def close(ssc:StreamingContext,millis:Long):Unit = {
new Thread(newRunnable {
override def run(): Unit = {
// 当某个条件触发而关闭StreamingContext
Thread.sleep(millis)
println("满足条件,准备关闭StreamingContext")
ssc.stop(true,true)
println("成功关闭StreamingContext")
}
}).start()
}
val ssc = StreamingContext.getOrCreate(checkpointDir,creatingFunc)
ssc.start()
ssc.awaitTermination()
close(ssc,20000)
}