如何以通用方式使函数可序列化

Question

我知道we can cast a function 是我们需要的Serializable。

但是，我想将此转换移动到一个 generic 方法，以使使用代码不那么混乱。 我没有设法创建这样的方法。

我的具体问题是下面的地图不是Serializable：

final Map<MyObject, String> map =
        new TreeMap<>(Comparator.comparing(MyObject::getCode));

我可以使用以下方法解决此问题：

final Map<MyObject, String> map =
        new TreeMap<>(Comparator.comparing((Function<MyObject, String> & Serializable) MyObject::getCode));

但我希望能够做类似的事情：

final Map<MyObject, String> map =
        new TreeMap<>(Comparator.comparing(makeSerializable(MyObject::getCode)));

public static <T, U> Function<T, U> makeSerializable(Function<T, U> function) {
    return (Function<T, U> & Serializable) function;
}

对于编译器来说这很好，但在运行时，我得到一个ClassCastException：

java.lang.ClassCastException: SerializableTest$$Lambda$1/801197928 cannot be cast to java.io.Serializable

我还尝试了以下替代方法，但均未成功：

// ClassCastException
public static <T extends Serializable, U extends Serializable> Function<T, U> makeSerializable(Function<T, U> function) {
    return (Function<T, U> & Serializable) function;
}

// No ClassCastException, but NotSerializableException upon Serializing
public static <T, U> Function<T, U> makeSerializable2(Function<T, U> function) {
    return (Function<T, U> & Serializable) t -> function.apply(t);
}

是否可以创建这样的方法？

MyObject的实现：

static class MyObject implements Serializable {

    private final String code;

    MyObject(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

}

Answer 1

是的，这是可能的，只要您不使用 Function<T, U> 作为参数或结果的类型。

相反，您可以创建自己的函数式接口，既是Function 又是Serializable：

interface SerFunc<T, U> extends Function<T, U>, Serializable { }

正如@M.Prokhorov 在 cmets 中巧妙地建议的那样，您可以创建一个类似于您的方法的方法，但它接收并返回 SerFunc 的实例而不是 Function：

public static <T, U> SerFunc<T, U> makeSerializable(SerFunc<T, U> function) {
    return function;
}

此方法的唯一目标是为方法引用或作为参数传递的 lambda 表达式提供 Serializable 目标类型。这就是为什么我们只是返回参数，即什么都不做。

现在您可以在代码中使用该方法，一切正常：

Map<MyObject, String> map =
    new TreeMap<>(Comparator.comparing(makeSerializable(MyObject::getCode)));

---

至于您的尝试失败的原因，我认为您可以在this question（@Eugene 提供的链接）的答案中找到原因，Brian Goetz 解释说这种行为是设计使然：

这是正确的，并且是设计使然。就像你不能在实例化后获取一个不可序列化的对象并使其可序列化一样，一旦创建了 lambda，它的可序列化性就会被设置。

如果 lambda 的目标类型是可序列化的（并且其捕获的参数是可序列化的），则 lambda 是可序列化的。

在您的尝试中，原始函数（由makeSerializable 方法作为参数接收）不是Serializable，因此我们创建的任何使用此不可序列化函数（实际上是捕获的参数）的 lambda 将也是不可序列化的。

Answer 2

好吧，如果您愿意更改您的参数（我不确定是否可以从inputFunction 中提取所需的信息，但我可以尝试挖掘一些东西），您可以动态创建一个序列化的@987654323 @，不确定这是否适合您...

public static <T, U> Function<T, U> makeSerializable(
        Class<T> targetType, // MyObject
        Class<U> returnType, // String
        String methodName) throws Throwable {

    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodType methodType = MethodType.methodType(returnType, targetType);
    Function<T, U> fun = (Function<T, U>) LambdaMetafactory.altMetafactory(
            lookup,
            "apply",
            MethodType.methodType(Function.class),
            methodType,
            lookup.findVirtual(targetType, methodName, MethodType.methodType(returnType)),
            methodType,
            1) // this signals for serialization 
            .getTarget().invokeExact();
    return fun;
}

这可能需要一个布尔值并与静态方法引用一起使用...

调用将是：

Map<MyObject, String> map = new TreeMap(Comparator.comparing(makeSerializable(
            MyObject.class, String.class, "getCode")));