- Spark-core—RDD序列化
- 1、闭包检查
- 2、序列化方法和属性
- 1)Task not serializable报错原因
- 2)报错修改
- 3、序列化方法的案例2
- 4、Kryo序列化框架
- 从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行。那么在 scala 的函数式编程中,就会导致算子内经常会用到算子外的数据,这样就形成了闭包的效果。
- 如果使用的算子外的数据无法序列化,就意味着无法传值给 Executor端执行,就会发生错误,所以需要在执行任务计算前,检测闭包内的对象是否可以进行序列化,这个操作我们称之为闭包检测。
从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行。
1)Task not serializable报错原因package Operator.action
import org.apache.spark.{SparkConf, SparkContext}
object Spark07_RDD_Operator_Action {
def main(args: Array[String]): Unit = {
val sparkConf = new SparkConf().setAppName("Operator").setMaster("local[*]")
val sc: SparkContext = new SparkContext(sparkConf)
val rdd = sc.makeRDD(List(1, 2, 3, 4))
val user = new User()
rdd.foreach(
num => {
println( "age= " + (user.age+num))
}
)
sc.stop()
}
class User{
val age:Int=20
}
}
运行以上代码,报错显示定义的User(类)没有序列化。
Exception in thread "main" org.apache.spark.SparkException: Task not serializable Operator.action.Spark07_RDD_Operator_Action$User Serialization stack:
可是,它凭什么要序列化呢?
val user = new User() //在行动算子外部创建了User ,在Driver端构建
rdd.foreach(
num => {
println( "age= " + (user.age+num)) //在行动算子内部调用了User ,在Executor端调用
}
)
在Executor端调用Driver端的User,需要将Driver端的User传到Executor端。因为Driver和Executor共享数据数据,是需要传递数据的,所以User需要序列化
2)报错修改定义User时混入Serializable
//方法一:定义User时混入Serializable
class User extends Serializable {
val age:Int=20
}
// 方法二:样例类在编译时,自动混入序列化特质(实现可序列化接口)
case class User(){
val age:Int=20
}
问题成功解决,输出结果
package Acc
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark01_RDD_Serial {
def main(args: Array[String]): Unit = {
//1.创建 SparkConf 并设置 App 名称
val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
//2.创建 SparkContext,该对象是提交 Spark App 的入口
val sc: SparkContext = new SparkContext(conf)
//3.创建一个 RDD
val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", "hive", "atguigu"))
//3.1 创建一个 Search 对象
val search = new Search("h")
//3.2 函数传递,打印:ERROR Task not serializable
search.getMatch1(rdd).collect().foreach(println)
//3.3 属性传递,打印:ERROR Task not serializable
search.getMatch2(rdd).collect().foreach(println)
//如果类Search不进行序列化,那么getMatch1,getMatch2在调用时就会报 ERROR Task not serializable
//4.关闭连接
sc.stop()
} }
//从数据源中查询指定规则的数据
//类的构造参数,其实是类的属性,构造参数需要进行闭包检测,其实就等同于类进行闭包检测
class Search(query:String) extends Serializable {
def isMatch(s: String): Boolean = {
s.contains(this.query)
}
// 函数序列化案例
def getMatch1 (rdd: RDD[String]): RDD[String] = {
rdd.filter(isMatch) //采用外置函数
}
// 属性序列化案例
def getMatch2(rdd: RDD[String]): RDD[String] = {
// val s=query 如果加了这句,则getMatch2对于类Search不需要序列化,因为s为String,String已经继承序列化类;因为此时s是方法的局部变量,与Search无关
rdd.filter(x => x.contains(query)) //采用匿名函数
}
}
4、Kryo序列化框架
- 参考地址: https://github.com/EsotericSoftware/kryo
- Java 的序列化能够序列化任何的类。但是比较重(字节多),序列化后,对象的提交也比较大。Spark 出于性能的考虑,Spark2.0 开始支持另外一种 Kryo 序列化机制。
- Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候,简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。
- 注意:即使使用 Kryo 序列化,也要继承 Serializable 接口。
package Acc
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}
object Spark01_RDD_serializable_Kryo {
def main(args: Array[String]): Unit = {
val conf: SparkConf = new SparkConf()
.setAppName("SerDemo")
.setMaster("local[*]")
// 替换默认的序列化机制
.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
// 注册需要使用 kryo 序列化的自定义类
.registerKryoClasses(Array(classOf[Searcher]))
val sc = new SparkContext(conf)
val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello atguigu", "atguigu", "hahah"), 2)
val searcher = new Searcher("hello")
val result: RDD[String] = searcher.getMatchedRDD1(rdd)
result.collect.foreach(println)
}
}
case class Searcher(val query: String) {
def isMatch(s: String) = {
s.contains(query)
}
def getMatchedRDD1(rdd: RDD[String]) = {
rdd.filter(isMatch)
}
def getMatchedRDD2(rdd: RDD[String]) = {
val q = query
rdd.filter(_.contains(q))
}
}



