一、累加器API
关于累加器，前面我也写了一篇博客，顺便粘贴这儿，对比学习，Spark学习之编程进阶总结(一)。Spark 2.0系列引入了一个更加简单和更高性能的累加器API，如在1.X版本中可以这样使用累加器：
val sparkSession = SparkSession.builder().master("local").appName("wordcount").getOrCreate()
val sc = sparkSession.sparkContext
sc.setLogLevel("WARN")
// Spark1.x版本 定义累加器，这里直接使用SparkContext内置的累加器
val accum = sc.accumulator(0, "My Accumulator")
sc.parallelize(Array(1,2,3,4)).foreach(x=>accum+=x)
// 获取累加器的值，Executor上面只能对累加器进行累加操作，只要Driver才能读取累加器的值
// Driver读取值的时候会把各个Executor上存储的本地累加器的值加起来，这里的结果是10
println(accum) // 输出10
在Spark 2.X版本里使用SparkContext里内置的累加器：
// 与Spark1.x不同的是，需要指定累加器的类型，目前SparkContext有Long类型和Double类型
// 可以直接使用，不需要指定初始值
val accum1 = sc.longAccumulator("My Accumulator")
sc.parallelize(Array(1,2,3,4)).foreach(x=>accum1.add(x))
println(accum1.value) // 输出10
只使用SparkContext里内置的累加器功能肯定不能满足略微复杂的业务类型，此时我们就可以自定义累加器。这里给出Spark2.X自定义累加器的参考代码
在Scala中有一种方式来自定义累加器，用户只需要继承Accumulable，就可以把元素和返回值定义为不同的类型，这样我们就可以完成添加操作（如往Int类型的List里添加整数，此时元素为Int类型，而返回类型为List）。
在Spark 2.X中加入一个新的抽象类—AccumulatorV2，继承这个类要实现以下几种方法：
add方法：指定元素相加操作。
copy方法：指定对自定义累加器的复制操作。
isZero方法：返回该累加器的值是否为“零”。
merge方法：合并两个相同类型的累加器。
reset方法：重置累加器。
value方法：返回累加器当前的值。
重写这几种方法之后，只需实例化自定义累加器，并连同累加器名字一起传给sparkContext.register方法。
下面简单实现一个把字符串合并为数组的累加器：
// 首先要继承AccumulatorV2，并指定输入为String类型，输出为ArrayBuffer[String]
class MyAccumulator extends AccumulatorV2[String,ArrayBuffer[String]]{
// 设置累加器的结果，类型为ArrayBuffer[String]
private var result = ArrayBuffer[String]()
// 判断累加器当前值是否为零值，这里我们指定如果result的size为0，则累加器当前值是零值
override def isZero:Boolean = this.result.size == 0
// copy方法设置为新建本累加器，并把result赋给新的累加器
override def copy():AccumulatorV2[String,ArrayBuffer[String]] = {
val newAccum = new MyAccumulator
newAccum.result = this.result
newAccum
}
// reset 方法设置为把result设置为新的ArrayBuffer
override def reset():Unit = this.result = new ArrayBuffer[String]()
// add 方法把传进来的字符串添加到result中
override def add(v:String):Unit = this.result+=v
// merge 方法把两个累加器的result合并起来
override def merge(other:AccumulatorV2[String,ArrayBuffer[String]]):Unit={
result.++=:(other.value)
}
// value 方法返回result
override def value:ArrayBuffer[String] = this.result
}
// 接着在main方法里使用累加器
val Myaccum = new MyAccumulator()
// 向SparkContext注册累加器
sc.register(Myaccum)
// 把 a b c d添加进累加器的result数组并打印出来
sc.parallelize(Array("a","b","c","d")).foreach(x=>Myaccum.add(x))
println(Myaccum.value) // 输出ArrayBuffer(a, b, c, d)
二、Spark2.X Streaming
关于Streaming我以前也有一篇博客，这里粘贴出来对比学习。Spark学习之Spark Streaming。这里写一个程序来监听网络端口发来的内容，然后进行WordCount。
第一步：创建程序入口SparkSession，并引入spark.implicits来允许Scalaobject隐式转换为DataFrame。
第二步：创建流。配置从socket读取流数据，地址和端口为localhost:9999
第三步：进行单词统计。这里lines是DataFrame，使用as[String]给它定义类型转换为DataSet。之后在DataSet里进行单词统计。
第四步：创建查询句柄，定义打印结果方式并启动程序。这里使用writeStream方法，输出模式为全部输出到控制台。
import org.apache.spark.sql.SparkSession
object StreamingTest {
def main(args: Array[String]): Unit = {
val spark = SparkSession.builder().master("local").appName("StructuredNetworkCount").getOrCreate()
val sc = spark.sparkContext
sc.setLogLevel("WARN")
// 上面变量一定也得为spark
import spark.implicits._
val lines = spark.readStream.format("socket").option("host", "localhost").option("port", 9999).load()
val words = lines.as[String].flatMap(_.split(" "))
val wordcount = words.groupBy("value").count()
val query = wordcount.writeStream.outputMode("complete").format("console").start()
// 调用awaitTermination方法来防止程序在处理数据时停止
query.awaitTermination()
}
}
运行上面的程序首先nc软件要先运行起来，连接成功后再输入下面的字符串。
然后控制台打印的结果为：
Streaming的关键思想如图所示：把数据流视作一张数据不断增加的表，这样用户就可以基于这张表进行数据处理，就好像使用批处理来处理静态数据一样，但实际上Spark底层是把新数据不断地增量添加到这张无界的表的下一行中。
Structured Streaming共有3种输出模式，这3种模式都只适用于某些类型的查询：
（1）CompleteMode：完整模式。整个更新的结果表将被写入外部存储器。由存储连接器决定如何处理整张表的写入。聚合操作以及聚合之后的排序操作支持这种模式。
（2）AppendMode：附加模式。只有自上次触发执行后在结果表中附加的新行会被写入外部存储器。这仅适用于结果表中的现有行不会更改的查询，如select、where、map、flatMap、filter、join等操作支持这种模式。
（3）UpdateMode：更新模式（这个模式将在以后的版本中实现）。只有自上次触发执行后在结果表中更新的行将被写入外部存储器（不输出未更改的行）。
这篇博文主要来自《Spark大数据商业实战三部曲》这本书里面的第二章，内容有删减，还有本书的一些代码的实验结果。