大数据技术之Spark（三）——RDD序列化

前言：

object Operator_Action {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[2]")
    val sc = SparkContext.getOrCreate(conf)

    val rdd = sc.makeRDD(List(1,2,3,4))

    val user = new User()
    rdd.foreach(num => println(user.age + num))

  }

  class User {
    var age = 30
  }
}

        当我们创建一个自定义类的时候，运行时会报任务未序列化异常，提示User类未序列化。原因如下：

        foreach是rdd的行动算子，算子外部的代码在Driver端执行。所以User类在Driver端构建。而在循环遍历的时候，代码在算子的内部，在Executor端执行println操作。

        但是println的时候用到了Driver端的User类，需要将Driver端的User类传递到Executor端才能使用。User类需要在网络中传递，那么就需要序列化。

 解决方法1：User类混入Serializable实现序列化。

object Operator_Action {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[2]")
    val sc = SparkContext.getOrCreate(conf)

    val rdd = sc.makeRDD(List(1,2,3,4))

    val user = new User()
    rdd.foreach(num => println(user.age + num))

  }

  class User extends Serializable {
    var age = 30
  }
}

解决方法2：使用样例类

        样例类在编译时，会自动混入序列化特质（实现可序列化接口）

object Operator_Action {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[2]")
    val sc = SparkContext.getOrCreate(conf)

    val rdd = sc.makeRDD(List(1,2,3,4))

    val user = new User()
    rdd.foreach(num => println(user.age + num))

  }

  case class User() {
    var age = 30
  }
}

注意：

        如果rdd中List没有传入任何参数，List为空，此时foreach循环按理来说应该不会运行。但此时运行依然报错。原因：

        RDD算子中传递的函数包含闭包检测操作，会进行检测功能。

一、闭包检测

——什么是闭包检测

        从计算的角度，算子以外的代码都是在Driver端执行，算子里面的代码都是在Executor端执行。那么在scala的函数式编程中，会导致算子内经常会用到算子外的函数，这样就形成了闭包的效果。如果使用的算子外的数据无法序列化，就意味着无法传值给Executor端执行，就会发生错误。

        所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化，这个操作我们称之为闭包检测。

二、序列化方法和属性

        从计算的角度，算子以外的代码都是在Driver端执行，算子里面的代码都是在Executor端执行。举例如下：

object Spark01_RDD_Serial {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setMaster("local").setAppName("WordCount")
    val sc = new SparkContext(conf)

    // 创建一个RDD
    val rdd = sc.makeRDD(Array("hello world","hello spark","hive","spark"))

    val search = new Search("h")
    search.getMatch1(rdd).collect.foreach(println)

    sc.stop()
  }

  // 查询对象
  class Search(query:String){
    def isMatch(s:String):Boolean = {
      s.contains(query)
    }

    // 函数序列化案例
    def getMatch1(rdd:RDD[String]):RDD[String] = {
      rdd.filter(isMatch)
    }

    // 属性序列化案例
    def getMatch2(rdd:RDD[String]):RDD[String] = {
      rdd.filter(x=>x.contains(query))
    }
  }
}

这段代码运行会抛出异常：

Exception in thread "main" org.apache.spark.SparkException: Task not serializable

这是因为，类的构造参数其实是类的属性。query是Search的私有属性，在判断是否包含的时候会调用this.query。所以构造参数需要进行闭包检测，等同于类进行闭包检测。

 // 属性序列化案例
    def getMatch2(rdd:RDD[String]):RDD[String] = {
      val s = query
      rdd.filter(x=>x.contains(s))

除了混入特质，上面的报错也可以通过这种方式来解决。原因如下：

        1. filter是RDD的方法，称之为算子，代码逻辑运行在executor端。

        2. val s = query在driver端。

        3. 算子中的s引用的是val变量s，s是字符串类型，字符串能够序列化，而s是getMatch2方法的局部变量，与Search类没有关系。所以使用变量s不需要Search类进行变化。

所以总而言之，就是两个思路：

        一是序列化

        二是想办法让这个属性与类剥离， 局部变量代替类的属性

三、Kryo序列化框架

        Java的序列化能够序列化任何的类。但是比较重（序列化的时候会产生大量字节），序列化后，对象的提交也比较大。spark处于性能的考虑，2.0开始支持另一种Kryo序列化机制。Kryo速度是Serizlizable的10倍。当RDD在Shuffle数据的时候，简单数据类型、数组和字符串类型已经在Spark内部使用Kryo来序列化。

        注意：即使使用了Kryo序列化，也要继承Serializable接口。

val conf = new SparkConf()
            .setAppName("SerDemo")
            .setMaster("local[*]")
        // 替换默认的序列化机制
            .set("spark.serializer","org.apache.spark.serializer.KryoSerializer")
        // 注册需要使用kryo序列化的自定义类
            .registerKryoClasses(Array(classOf[Searchers]))