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

Грега это в объяснении, почему исходный код не работает и два способа исправить эту проблему. Однако это решение не очень гибко; рассмотрим случай, когда ваше закрытие включает вызов метода на не-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 уже втянут основной искрой

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

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

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

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

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

будущее, вероятно Споры

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

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

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

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

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

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

конечно, это дает вам только контроль уровня типа, а не контроль уровня значения.

... еще больше идей впереди.

Я решил эту проблему, используя другой подход. Вам просто нужно сериализовать объекты перед прохождением через закрытие,а затем де-сериализовать. Этот подход просто работает, даже если ваши классы не Сериализуемы, потому что он использует 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 }
}

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

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

Я не совсем уверен, что это относится к Scala, но в Java я решил NotSerializableException на рефакторинг мой код так, что закрытие не открыть несериализуемый

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

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(_))
}

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