1) 闭包检查
    从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor 端执行。那么在 scala 的函数式编程中，就会导致算子内经常会用到算子外的数据，这样就形成了闭包的效果，如果使用的算子外的数据无法序列化，就意味着无法传值给 Executor端执行，就会发生错误，所以需要在执行任务计算前，检测闭包内的对象是否可以进行序列化，这个操作我们称之为闭包检测。Scala2.12 版本后闭包编译方式发生了改变
    2) 序列化方法和属性
    从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行，如下代码

    1. object serializable02_function {
    2.  def main(args: Array[String]): Unit = {
    3.  //1.创建 SparkConf 并设置 App 名称
    4.  val conf: SparkConf = new 
    5. SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
    6.  //2.创建 SparkContext，该对象是提交 Spark App 的入口
    7.  val sc: SparkContext = new SparkContext(conf)
    8.  //3.创建一个 RDD
    9.  val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", 
    10. "hive", "atguigu"))
    11.  //3.1 创建一个 Search 对象
    12.  val search = new Search("hello")
    13.  //3.2 函数传递，打印：ERROR Task not serializable
    14.  search.getMatch1(rdd).collect().foreach(println)
    15.  //3.3 属性传递，打印：ERROR Task not serializable
    16.  search.getMatch2(rdd).collect().foreach(println)
    17.  //4.关闭连接
    18.  sc.stop()
    19.  } }
    20. class Search(query:String) extends Serializable {
    21.   def isMatch(s: String): Boolean = {
    22.     s.contains(query)
    23.  }
    24.  // 函数序列化案例
    25.   def getMatch1 (rdd: RDD[String]): RDD[String] = {
    26.    //rdd.filter(this.isMatch)
    27.     rdd.filter(isMatch)
    28.  }
    29.  // 属性序列化案例
    30.   def getMatch2(rdd: RDD[String]): RDD[String] = {
    31.    //rdd.filter(x => x.contains(this.query))
    32.    rdd.filter(x => x.contains(query))
    33.    //val q = query
    34.    //rdd.filter(x => x.contains(q))
    35.  } }

    3) Kryo 序列化框架
    参考地址: https://github.com/EsotericSoftware/kryo
    Java 的序列化能够序列化任何的类。但是比较重（字节多），序列化后，对象的提交也比较大。Spark 出于性能的考虑，Spark2.0 开始支持另外一种 Kryo 序列化机制。Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候，简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。
    注意：即使使用 Kryo 序列化，也要继承 Serializable 接口。

    1. object serializable_Kryo {
    2.  def main(args: Array[String]): Unit = {
    3.  val conf: SparkConf = new SparkConf()
    4.  .setAppName("SerDemo")
    5.  .setMaster("local[*]")
    6.  // 替换默认的序列化机制
    7.  .set("spark.serializer", 
    8. "org.apache.spark.serializer.KryoSerializer")
    9.  // 注册需要使用 kryo 序列化的自定义类
    10.  .registerKryoClasses(Array(classOf[Searcher]))
    11.  val sc = new SparkContext(conf)
    12.  val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello atguigu", 
    13. "atguigu", "hahah"), 2)
    14.  val searcher = new Searcher("hello")
    15.  val result: RDD[String] = searcher.getMatchedRDD1(rdd)
    16.  result.collect.foreach(println)
    17.  } }
    18. case class Searcher(val query: String) {
    19.  def isMatch(s: String) = {
    20.  s.contains(query)
    21.  }
    22.  def getMatchedRDD1(rdd: RDD[String]) = {
    23.  rdd.filter(isMatch) 
    24.  }
    25.  def getMatchedRDD2(rdd: RDD[String]) = {
    26.  val q = query
    27.  rdd.filter(_.contains(q))
    28.  } }