为什么Scala可以序列化Function但不能序列化PartialFunction？ [英] Why Scala can serialize Function but not PartialFunction?

问题描述

我在一个对象下类似地定义了2个函数（其中1个是部分函数）：

I have 2 functions (1 of them is partial) defined similarly under an object:

  val partialFn: scala.PartialFunction[String, Int] =
    new AbstractPartialFunction[String, Int] {

      override def isDefinedAt(v: String): Boolean = {
        counter += 1
        if (v == "abc") true
        else false
      }

      override def applyOrElse[A1 <: String, B1 >: Int](v: A1, default: A1 => B1): B1 = {
        counter += 1
        if (v == "abc") {
          v.length
        }
        else {
          default(v)
        }
      }
    }

  val optionFn: (String) => Option[Int] = {
    (v: String) => {
      counter += 1
      if (v == "abc") {
        Some(v.length)
      }
      else {
        None
      }
    }
  }

选项（绝对可序列化）并且已序列化/反序列化，其中之一失败：

When they are both wrapped in an Option (definitely serializable) and being serialized/deserialized, one of them failed:

java.io.NotSerializableException: ***.extractors.ExtractorSuite$$anon$1
Serialization stack:
    - object not serializable (class: ***.extractors.ExtractorSuite$$anon$1, value: <function1>)
    - field (class: scala.Some, name: x, type: class java.lang.Object)
    - object (class scala.Some, Some(<function1>))
    at org.apache.spark.serializer.SerializationDebugger$.improveException(SerializationDebugger.scala:40)
    at org.apache.spark.serializer.JavaSerializationStream.writeObject(JavaSerializer.scala:47)
    at org.apache.spark.serializer.JavaSerializerInstance.serialize(JavaSerializer.scala:101)
    at ***.tests.TestMixin$$anonfun$assertSerializable$1.apply(TestMixin.scala:61)

...

任何人都知道为什么PartialFunction&

Any idea why there is such a big difference between PartialFunction & common function?

推荐答案

因为您要显式创建 AbstractPartialFunction 而不扩展可序列化。如果您对 new AbstractFunction1 [String，Int] {...} 执行相同操作，则它也不会可序列化。另一方面，当您使用匿名函数语法时，编译器会生成一个类，该类的确扩展了 Serializable 。这包括匿名部分函数语法：

Because you are explicitly creating AbstractPartialFunction without extending Serializable. If you do the same with new AbstractFunction1[String, Int] { ... }, it also won't be serializable. On the other hand, when you use the anonymous function syntax, the compiler generates a class which does extend Serializable. This includes anonymous partial function syntax:

scala> val x: PartialFunction[Int, Boolean] = { case 0 => true }
x: PartialFunction[Int,Boolean] = <function1>

scala> x.isInstanceOf[Serializable]
res0: Boolean = true

这篇关于为什么Scala可以序列化Function但不能序列化PartialFunction？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！