Java 用serializable函数包装不可序列化的类型

鉴于：

---

ValueProvider[SomeTypeNotSerializable]

serializable吗？有没有办法通过用函数包装对象来解决不可序列化的问题

根据规则，它是

可序列化的

，但如果将该

T

存储为非瞬态字段，它将在运行时失败。如果

T

是暂时的，或者没有字段支持（例如，在每次调用

get

时创建），那么您应该不会有问题，尽管我仍然很好奇为什么要序列化服务对象，这不是通常的做法。

从我看到的

ValueProvider[SomeTypeNotSerializable]在这种情况下，

将无法序列化

这可以通过以下示例代码进行检查，该代码在运行时打印：

trait SomeTypeNotSerializable
trait ValueProvider[T] extends java.io.Serializable {
  def get: T
}

主要类别：

testString is Serializable
st2 is Serializable

import java.io.Serializable；
公共班机{
公共静态void main（字符串[]args）{
NonSerializableThing nst=新的NonSerializableThing（）；
SerializableThing st=新的SerializableThing（）；
圣塞特（nst）；
如果（nst instanceof Serializable）{//始终为false
System.out.println（“nst可序列化”）；
}
if（可序列化的st.get（）实例）{
System.out.println（“st可序列化”）；
}
String testString=“testString”；
SerializableThing st2=新的SerializableThing（）；
st2.set（testString）；
if（testString instanceof Serializable）{//始终为true
System.out.println（“testString是可序列化的”）；
}
if（st2.get（）instanceof Serializable）{
System.out.println（“st2可序列化”）；
}
}
}

其他类型：

import java.io.Serializable;

public class Main {

    public static void main(String[] args) {

        NonSerializableThing nst = new NonSerializableThing();

        SerializableThing<NonSerializableThing> st = new SerializableThing<>();
        st.set(nst);

        if(nst instanceof Serializable) { // always false
            System.out.println("nst is Serializable");
        }

        if(st.get() instanceof Serializable) {
            System.out.println("st is Serializable");
        }

        String testString = "testString";
        SerializableThing<String> st2 = new SerializableThing<>();
        st2.set(testString);

        if(testString instanceof Serializable) { // always true
            System.out.println("testString is Serializable");
        }

        if(st2.get() instanceof Serializable) {
            System.out.println("st2 is Serializable");
        }

    }
}

公共类不可序列化的东西{
非序列化对象（）{}
}
公共类SerializableThing实现java.io.Serializable{
公共交通；
public SerializableThing（）{}
公共无效集（T）{this.T=T；}
公共T get（）{return T；}
}

我试图提供的不是一个服务对象，而是一个设计糟糕、不可序列化的第三方对象。

public class NonSerializableThing {

    NonSerializableThing() {}
}

public class SerializableThing<T> implements java.io.Serializable {

    public T t;

    public SerializableThing() { }

    public void set(T t) {this.t = t;}
    public T get() {return t;}

}