如何安全地序列化lambda？

Question

虽然可以在Java 8中序列化lambda，但强烈建议不要这样做；甚至不鼓励序列化内部类。给出的原因是lambdas可能无法在另一个JRE上正确反序列化。然而，这是否意味着有一种方法可以安全地序列化lambda？

例如，假设我定义一个类如下：

public class MyClass {
    private String value;
    private Predicate<String> validateValue;

    public MyClass(String value, Predicate<String> validate) {
        this.value = value;
        this.validateValue = validate;
    }

    public void setValue(String value) {
        if (!validateValue(value)) throw new IllegalArgumentException();
        this.value = value;
    }

    public void setValidation(Predicate<String> validate) {
        this.validateValue = validate;
    }
}

如果像这样声明了类的实例，则不应序列化它：

MyClass obj = new MyClass("some value", (s) -> !s.isEmpty());

但如果我创建一个这样的类实例，会怎么样：

// Could even be a static nested class
public class IsNonEmpty implements Predicate<String>, Serializable {
    @Override
    public boolean test(String s) {
        return !s.isEmpty();
    }
}

MyClass isThisSafeToSerialize = new MyClass("some string", new IsNonEmpty());

现在序列化是安全的吗？我的直觉告诉我，是的，它应该是安全的，因为没有理由将java.util.function中的接口与任何其他随机接口区别对待。但是我仍然很警惕。

Answer 1

这取决于您想要哪种安全性。序列化lambda并不是不能在不同JRE之间共享的情况。它们有一个定义良好的持久表示，即SerializedLambda。当您研究它是如何工作的时，您会发现它依赖于定义类的存在，它将有一个特殊的方法来重建lambda。

使其不可靠的是对编译器特定工件的依赖，例如合成目标方法，它有一些生成的名称，因此插入另一个lambda表达式或使用不同的编译器重新编译类等简单更改可能会破坏与现有序列化lambda表达式的兼容性。

然而，使用手动编写的类并不能避免这种情况。如果没有显式声明的serialVersionUID，默认算法将通过散列类工件（包括私有工件和合成工件）来计算id，并添加类似的编译器依赖项。因此，如果想要可靠的持久化表单，最起码要声明一个显式的serialVersionUID。

或者你转向最健壮的形式：

public enum IsNonEmpty implements Predicate<String> {
    INSTANCE;

    @Override
    public boolean test(String s) {
        return !s.isEmpty();
    }
}

序列化此常量不存储实际实现的任何属性，除了它的类名（当然还有它是枚举的事实）和对常量名称的引用。反序列化后，将使用该名称的实际唯一实例。

请注意，可序列化的lambda表达式可能会产生安全问题，因为它们提供了另一种方法来获得允许调用目标方法的对象。然而，这适用于所有可序列化的类，因为问题和答案中显示的所有变量都允许故意反序列化对象，从而允许调用封装的操作。但对于显式可序列化类，作者通常更清楚这一事实。