Como serializar um lambda?

Como posso serializar elegantemente um lambda?

Por exemplo, o código abaixo gera a NotSerializableException. Como posso corrigi-lo sem criar uma SerializableRunnableinterface "fictícia"?

public static void main(String[] args) throws Exception {
    File file = Files.createTempFile("lambda", "ser").toFile();
    try (ObjectOutput oo = new ObjectOutputStream(new FileOutputStream(file))) {
        Runnable r = () -> System.out.println("Can I be serialized?");
        oo.writeObject(r);
    }

    try (ObjectInput oi = new ObjectInputStream(new FileInputStream(file))) {
        Runnable  r = (Runnable) oi.readObject();
        r.run();
    }
}

O Java 8 introduz a possibilidade de converter um objeto em uma interseção de tipos adicionando vários limites . No caso de serialização, é possível escrever:

Runnable r = (Runnable & Serializable)() -> System.out.println("Serializable!");

E o lambda se torna automagicamente serializável.

A mesma construção pode ser usada para referências de método. Por exemplo, este código:

import java.io.Serializable;

public class Test {
    static Object bar(String s) {
        return "make serializable";
    }

    void m () {
        SAM s1 = (SAM & Serializable) Test::bar;
        SAM s2 = (SAM & Serializable) t -> "make serializable";
    }

    interface SAM {
        Object action(String s);
    }
}

define uma expressão lambda e uma referência de método com um tipo de destino serializável.

Elenco muito feio. Prefiro definir uma extensão serializável para a interface funcional que estou usando

Por exemplo:

interface SerializableFunction<T,R> extends Function<T,R>, Serializable {}
interface SerializableConsumer<T> extends Consumer<T>, Serializable {}

então o método que aceita o lambda pode ser definido como tal:

private void someFunction(SerializableFunction<String, Object> function) {
   ...
}

e chamando a função, você pode passar seu lambda sem nenhum elenco feio:

someFunction(arg -> doXYZ(arg));

Caso alguém caia aqui ao criar o código Beam / Dataflow:

O Beam possui sua própria interface SerializableFunction, portanto, não há necessidade de interface fictícia ou elencos detalhados.

Se você deseja mudar para outra estrutura de serialização como o Kryo , pode se livrar dos múltiplos limites ou do requisito que a interface implementada deve implementar Serializable. A abordagem é

1. Modifique o InnerClassLambdaMetafactory para sempre gerar o código necessário para serialização
2. Chamar diretamente o LambdaMetaFactorydurante a desserialização

Para detalhes e código, consulte esta postagem do blog