Задача не сериализуема: java.io.NotSerializableException при вызове функции вне замыкания только для классов, а не объектов

Ответ Grega отлично объясняет, почему исходный код не работает, и два способа исправить проблему. Однако это решение не очень гибко; рассмотрите случай, когда ваше закрытие включает вызов метода в классе Serializable, который у вас нет. Вы не можете добавить тег Serializable в этот класс или изменить базовую реализацию, чтобы изменить метод на функцию.

Nilesh представляет большой обходной путь для этого, но решение может быть сделано как более сжатым, так и общим:

def genMapper[A, B](f: A => B): A => B = {
  val locker = com.twitter.chill.MeatLocker(f)
  x => locker.get.apply(x)
}

Этот функционал-сериализатор затем может использоваться для автоматического переноса замыканий и вызовов методов:

rdd map genMapper(someFunc)

Этот метод также имеет преимущество, не требуя дополнительных зависимостей Shark, чтобы получить доступ к KryoSerializationWrapper, поскольку Twitter Chill уже вытащен ядром Spark

Полный разговор, полностью объясняющий проблему, которая предлагает отличную парадигму, позволяющую избежать этих проблем сериализации: https://github.com/samthebest/dump/blob/master/sams-scala-tutorial/serialization-exceptions-and-memory- leaks-no-ws.md

Высший проголосовавший ответ в основном предлагает отбросить всю языковую функцию - это больше не использует методы и использует только функции. В самом деле, в методах функционального программирования в классах следует избегать, но превращение их в функции не решает проблему дизайна здесь (см. Ссылку выше).

В качестве быстрого исправления в этой конкретной ситуации вы можете просто использовать аннотацию @transient чтобы сказать ей, чтобы она не пыталась сериализовать оскорбительное значение (здесь Spark.ctx - это настраиваемый класс, а не Spark, следующий после имен OP):

@transient
val rddList = Spark.ctx.parallelize(list)

Вы также можете реструктурировать код, чтобы rddList проживал где-то в другом месте, но это также противно.

Будущее, вероятно, спор

В будущем Scala будет включать в себя такие вещи, которые называются "спорами", которые должны позволить нам контролировать мелкие зерна, что делает и не совсем затягивается закрытием. Кроме того, это должно привести к ошибкам случайного вытягивания несериализуемых типов (или любых нежелательных значений) в ошибки компиляции, а не в настоящее время, что является ужасным исключением/ошибками в работе.

http://docs.scala-lang.org/sips/pending/spores.html

Совет по сериализации Kryo

При использовании kyro сделайте так, чтобы регистрация была необходима, это будет означать, что вы получите ошибки вместо утечек памяти:

"Наконец, я знаю, что у kryo есть kryo.setRegistrationOptional (правда), но у меня очень трудное время, пытаясь выяснить, как его использовать. Когда этот параметр включен, kryo все еще, кажется, бросает исключения, если я не зарегистрирован классы ".

Стратегия регистрации классов с помощью крио

Конечно, это только дает вам контроль уровня на уровне, а не контроль уровня ценности.

... больше идей.

Я не совсем уверен, что это относится к Scala, но в Java я решил NotSerializableException путем рефакторинга моего кода, чтобы закрытие не получило доступ к несериализуемому полю final.

Я решил эту проблему, используя другой подход. Вам просто нужно сериализовать объекты перед тем, как пройти через закрытие, и затем де-сериализовать. Этот подход просто работает, даже если ваши классы не являются Serializable, потому что он использует Kryo за кулисами. Все, что вам нужно, это карри.;)

Вот пример того, как я это сделал:

def genMapper(kryoWrapper: KryoSerializationWrapper[(Foo => Bar)])
               (foo: Foo) : Bar = {
    kryoWrapper.value.apply(foo)
}
val mapper = genMapper(KryoSerializationWrapper(new Blah(abc))) _
rdd.flatMap(mapper).collectAsMap()

object Blah(abc: ABC) extends (Foo => Bar) {
    def apply(foo: Foo) : Bar = { //This is the real function }
}

Не стесняйтесь сделать Blah настолько сложным, насколько вы хотите, класс, сопутствующий объект, вложенные классы, ссылки на несколько сторонних библиотек.

KryoSerializationWrapper относится к: https://github.com/amplab/shark/blob/master/src/main/scala/shark/execution/serialization/KryoSerializationWrapper.scala

Я столкнулся с подобной проблемой, и то, что я понимаю из ответа Греги,

object NOTworking extends App {
 new testing().doIT
}
//adding extends Serializable wont help
class testing {

val list = List(1,2,3)

val rddList = Spark.ctx.parallelize(list)

def doIT =  {
  //again calling the fucntion someFunc 
  val after = rddList.map(someFunc(_))
  //this will crash (spark lazy)
  after.collect().map(println(_))
}

def someFunc(a:Int) = a+1

}

ваш метод doIT пытается сериализовать метод someFunc (_), но поскольку метод не является сериализуемым, он пытается сериализовать класс тестирование который снова не сериализуем.

Итак, создайте свой код, вы должны определить someFunc внутри метода doIT. Например:

def doIT =  {
 def someFunc(a:Int) = a+1
  //function definition
 }
 val after = rddList.map(someFunc(_))
 after.collect().map(println(_))
}

И если в картинке присутствует несколько функций, все эти функции должны быть доступны для родительского контекста.