Spark RDD 中的函数传递

在我们进行 Spark 进行编程的时候，初始化工作实在 driver 端完成的，而实际的运行程序实在 executor 端进行的。所以就涉及到了进程间的通讯，数据是需要序列化的。

传递函数

先看一个需求：在 RDD 中查找出来包含 query 子字符串的元素

object SerDemo {
    def main(args: Array[String]): Unit = {
        val conf: SparkConf = new SparkConf().setAppName("CreateRDD").setMaster("local[2]")
        val sc = new SparkContext(conf)
        val rdd1 = sc.makeRDD(Array("hello world", "hello atguigu", "atguigu", "hahah"), 2)
        val searcher = new Searcher("hello")
        val result: RDD[String] = searcher.getMatchedRDD1(rdd1)
        result.collect.foreach(println)
        sc.stop()
    }
}

// query 为需要查找的子字符串
class Searcher(val query: String) {
    // 判断 s 中是否包含自字符串 query
    def isMatch(s: String): Boolean = {
        s.contains(query)
    }
    // 过滤出包含 query 字符串的字符组成新的 RDD
    def getMatchedRDD1(rdd: RDD[String]): RDD[String] = {
        rdd.filter(isMatch)
    }
    // 过滤出包含 query 字符串的字符串组成的新的 RDD
    def getMatchedRDD2(rdd: RDD[String]): RDD[String] = {
        rdd.filter((_: String).contains(query))
    }
}

运行结果：

说明：

1. 直接运行程序会发现报错: Task not serializable，因为 rdd.filter(isMatch) 用到了 对象 this 的方法 isMatch，所以对象 this 需要序列化，才能把对象从driver 发送到 executor
2. 解决方案： 让 Searcher 类实现序列化接口： Serializable
   
   

---

传递变量

object SerDemo {
    def main(args: Array[String]): Unit = {
        val conf: SparkConf = new SparkConf().setAppName("CreateRDD").setMaster("local[2]")
        val sc = new SparkContext(conf)
        val rdd1 = sc.makeRDD(Array("hello world", "hello kino", "kino", "hahah"), 2)
        val searcher = new Searcher("hello")
        val result: RDD[String] = searcher.getMatchedRDD2(rdd1)
        result.collect.foreach(println)
        sc.stop()
    }
}

// query 为需要查找的子字符串
class Searcher(val query: String) {
    // 判断 s 中是否包含自字符串 query
    def isMatch(s: String): Boolean = {
        s.contains(query)
    }
    // 过滤出包含 query 字符串的字符组成新的 RDD
    def getMatchedRDD1(rdd: RDD[String]): RDD[String] = {
        rdd.filter(isMatch)
    }
    // 过滤出包含 query 字符串的字符串组成的新的 RDD
    def getMatchedRDD2(rdd: RDD[String]): RDD[String] = {
        rdd.filter(_.contains(query))
    }
}

运行结果：

说明：

1. 这次没有传递函数，而是传递了一个属性过去，仍然会报错没有序列化，因为 this 仍然没有序列化
2. 解决方案
   1. 让类实现序列化接口： Serializable
   2. 传递局部变量而不是属性
      

---

kryo 序列化框架

参考地址： https://github.com/EsotericSoftware/kryo

Serializable 是 Java 的序列化机制，Java 的序列化比较中，能够序列化任何的类，比较灵活，但是相当的慢， 并且序列化后对象的提交也比较大

Spark 处于性能的考虑，支持另一种序列化机制：kryo(2.0 开始支持), kryo 比较快和简洁(速度是 Serializable 的 10倍)。想获取更好的性能应该使用 kryo 来序列化

从 2.0 开始，Spark 内部已经在使用 kryo 序列化机制： 当 RDD 在 shuffle 数据的时候，简单数据类型，简单数据类型的数组和字符串类型已经在使用 kryo 来序列化

有一点点需要注意的是：即使使用 kryo 序列化，也要继承 Serializable

object SerDemo {
    def main(args: Array[String]): Unit = {
        val conf: SparkConf = new SparkConf()
                .setAppName("CreateRDD")
                .setMaster("local[2]")
                // 替换默认的序列化机制
                .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
                // 注册需要使用 kryo 序列化的自定义类
                .registerKryoClasses(Array(classOf[Searcher]))    
                
        val sc = new SparkContext(conf)
        val rdd1 = sc.makeRDD(Array("hello world", "hello kino", "kino", "hahah"), 2)
        val searcher = new Searcher("hello")
        val result: RDD[String] = searcher.getMatchedRDD1(rdd1)
        println("")
        result.collect.foreach(println)

        val rdd3: RDD[String] = searcher.getMatchedRDD2(rdd1)
        rdd3.collect.foreach(println)

        sc.stop()
    }
}
//需求: 在 RDD 中查找出来包含 query 子字符串的元素

// query 为需要查找的子字符串
class Searcher(val query: String) {
    // 判断 s 中是否包含自字符串 query
    def isMatch(s: String): Boolean = {
        s.contains(query)
    }
    // 过滤出包含 query 字符串的字符组成新的 RDD
    def getMatchedRDD1(rdd: RDD[String]): RDD[String] = {
        rdd.filter(isMatch)
    }
    // 过滤出包含 query 字符串的字符串组成的新的 RDD
    def getMatchedRDD2(rdd: RDD[String]): RDD[String] = {
        rdd.filter(_.contains(q))
    }
}