在Java中进行序列化后，是否可以将final transient字段设置为任何非默认值？我的用例是一个缓存变量 - 这就是transient的原因。我还习惯于制作不会被更改的Map字段（即地图内容已更改，但对象本身保持不变）final。但是，这些属性似乎是矛盾的 - 虽然编译器允许这样的组合，但是在反序列化之后，我不能将字段设置为除null之外的任何内容。
我尝试了以下操作，但没有成功：
readObject()中指定字段 - 由于该字段为final，因此无法完成。在示例中cache仅public用于测试。
import java.io.*;
import java.util.*;
public class test
{
public static void main (String[] args) throws Exception
{
X x = new X ();
System.out.println (x + " " + x.cache);
ByteArrayOutputStream buffer = new ByteArrayOutputStream ();
new ObjectOutputStream (buffer).writeObject (x);
x = (X) new ObjectInputStream (new ByteArrayInputStream (buffer.toByteArray ())).readObject ();
System.out.println (x + " " + x.cache);
}
public static class X implements Serializable
{
public final transient Map <Object, Object> cache = new HashMap <Object, Object> ();
}
}
输出：
test$X@1a46e30 {}
test$X@190d11 null
答案 0 :(得分：33)
不幸的是，简短的回答是“不” - 我经常想要这个。但瞬态不可能是最终的。
必须通过直接赋值初始值或在构造函数中初始化final字段。在反序列化期间，这些都不会被调用，因此必须在反序列化期间调用的“readObject（）”私有方法中设置瞬态的初始值。为了实现这一目标，瞬态必须是非最终的。
（严格来说，决赛只是在他们第一次被阅读时才是最后一次，因此有些黑客可能会在读取之前分配一个值，但对我来说这是一步太过分了。）
答案 1 :(得分：16)
您可以使用Reflection更改字段的内容。适用于Java 1.5+。它可以工作，因为序列化是在一个线程中执行的。在另一个线程访问同一个对象之后，它不应该更改最终字段（因为内存模型和反射中的怪异）。
因此，在readObject()中，您可以执行与此示例类似的操作：
import java.lang.reflect.Field;
public class FinalTransient {
private final transient Object a = null;
public static void main(String... args) throws Exception {
FinalTransient b = new FinalTransient();
System.out.println("First: " + b.a); // e.g. after serialization
Field f = b.getClass().getDeclaredField("a");
f.setAccessible(true);
f.set(b, 6); // e.g. putting back your cache
System.out.println("Second: " + b.a); // wow: it has a value!
}
}
答案 2 :(得分：14)
是的，通过实现（显然鲜为人知的！）readResolve()方法很容易实现。它允许您在反序列化后替换对象。您可以使用它来调用构造函数，以便根据需要初始化替换对象。一个例子：
import java.io.*;
import java.util.*;
public class test {
public static void main(String[] args) throws Exception {
X x = new X();
x.name = "This data will be serialized";
x.cache.put("This data", "is transient");
System.out.println("Before: " + x + " '" + x.name + "' " + x.cache);
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
new ObjectOutputStream(buffer).writeObject(x);
x = (X)new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray())).readObject();
System.out.println("After: " + x + " '" + x.name + "' " + x.cache);
}
public static class X implements Serializable {
public final transient Map<Object,Object> cache = new HashMap<>();
public String name;
public X() {} // normal constructor
private X(X x) { // constructor for deserialization
// copy the non-transient fields
this.name = x.name;
}
private Object readResolve() {
// create a new object from the deserialized one
return new X(this);
}
}
}
输出 - 保留字符串，但瞬态映射重置为空（但非空！）映射：
Before: test$X@172e0cc 'This data will be serialized' {This data=is transient}
After: test$X@490662 'This data will be serialized' {}
答案 3 :(得分：5)
这类问题的一般解决方案是使用“串行代理”（参见Effective Java 2nd Ed）。如果您需要在不破坏串行兼容性的情况下将其改装为现有的可序列化类，那么您将需要进行一些黑客攻击。
答案 4 :(得分：3)
五年后，在我通过Google偶然发现这篇文章之后，我发现原来的答案并不令人满意。另一种解决方案是根本不使用反射，并使用Boann建议的技术。
它还使用ObjectInputStream#readFields()方法返回的GetField类，根据序列化规范，必须在私有readObject(...)方法中调用它。
该解决方案通过将检索到的字段存储在反序列化过程创建的临时“实例”的临时瞬态字段（称为FinalExample#fields）中，使字段反序列化显式化。然后反序列化所有对象字段并调用readResolve(...)：创建一个新实例，但这次使用构造函数，使用临时字段丢弃临时实例。该实例使用GetField实例显式恢复每个字段;这是检查任何参数的地方，就像任何其他构造函数一样。如果构造函数抛出异常，则会将其转换为InvalidObjectException，并且此对象的反序列化失败。
包含的微基准确保此解决方案不会比默认序列化/反序列化慢。确实，它在我的电脑上：
Problem: 8.598s Solution: 7.818s
然后是代码：
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectInputStream.GetField;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import org.junit.Test;
import static org.junit.Assert.*;
public class FinalSerialization {
/**
* Using default serialization, there are problems with transient final
* fields. This is because internally, ObjectInputStream uses the Unsafe
* class to create an "instance", without calling a constructor.
*/
@Test
public void problem() throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
WrongExample x = new WrongExample(1234);
oos.writeObject(x);
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
WrongExample y = (WrongExample) ois.readObject();
assertTrue(y.value == 1234);
// Problem:
assertFalse(y.ref != null);
ois.close();
baos.close();
bais.close();
}
/**
* Use the readResolve method to construct a new object with the correct
* finals initialized. Because we now call the constructor explicitly, all
* finals are properly set up.
*/
@Test
public void solution() throws Exception {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
FinalExample x = new FinalExample(1234);
oos.writeObject(x);
oos.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
FinalExample y = (FinalExample) ois.readObject();
assertTrue(y.ref != null);
assertTrue(y.value == 1234);
ois.close();
baos.close();
bais.close();
}
/**
* The solution <em>should not</em> have worse execution time than built-in
* deserialization.
*/
@Test
public void benchmark() throws Exception {
int TRIALS = 500_000;
long a = System.currentTimeMillis();
for (int i = 0; i < TRIALS; i++) {
problem();
}
a = System.currentTimeMillis() - a;
long b = System.currentTimeMillis();
for (int i = 0; i < TRIALS; i++) {
solution();
}
b = System.currentTimeMillis() - b;
System.out.println("Problem: " + a / 1000f + "s Solution: " + b / 1000f + "s");
assertTrue(b <= a);
}
public static class FinalExample implements Serializable {
private static final long serialVersionUID = 4772085863429354018L;
public final transient Object ref = new Object();
public final int value;
private transient GetField fields;
public FinalExample(int value) {
this.value = value;
}
private FinalExample(GetField fields) throws IOException {
// assign fields
value = fields.get("value", 0);
}
private void readObject(ObjectInputStream stream) throws IOException,
ClassNotFoundException {
fields = stream.readFields();
}
private Object readResolve() throws ObjectStreamException {
try {
return new FinalExample(fields);
} catch (IOException ex) {
throw new InvalidObjectException(ex.getMessage());
}
}
}
public static class WrongExample implements Serializable {
private static final long serialVersionUID = 4772085863429354018L;
public final transient Object ref = new Object();
public final int value;
public WrongExample(int value) {
this.value = value;
}
}
}
注意事项：每当类引用另一个对象实例时，可能会泄漏序列化过程创建的临时“实例”：对象解析仅在读取所有子对象后发生，因此它是子对象可以保留对临时对象的引用。类可以通过检查GetField临时字段为空来检查这些非法构造的实例的使用。只有当它为null时，它才是使用常规构造函数创建的，而不是通过反序列化过程创建的。
自我注意：也许五年后会有更好的解决方案。那么见！
答案 5 :(得分：0)
这个问题是关于 Java 默认序列化器的，但我是通过搜索 Gson 来到这里的。此答案不适用于默认序列化程序，但适用于 Gson 和其他人。我不喜欢（手动）使用 Reflection 或 readResolve，所以这里还有别的东西。
反序列化时，Gson调用默认构造函数来创建对象。您可以将瞬态最终分配移动到默认构造函数，它们将被正确分配。如果您只有一个分配最终变量（例如，ID）的非默认构造函数，那么您将它们分配给什么并不重要，因为它们会被 Gson 用反射覆盖。
这确实意味着如果您的临时最终赋值依赖于构造函数参数，这将不起作用。
这是一些示例代码：
import com.google.gson.Gson;
import java.util.HashMap;
public class Test {
public static void main(String[] args) {
BrokenTestObject broken = new BrokenTestObject("broken");
FixedTestObject fixed = new FixedTestObject("fixed");
broken = serializeAndDeserialize(broken, BrokenTestObject.class);
fixed = serializeAndDeserialize(fixed, FixedTestObject.class);
System.out.println(broken.id + ": " + broken.someCache);
System.out.println(fixed.id + ": " + fixed.someCache);
}
public static <O> O serializeAndDeserialize(O object, Class<O> c) {
Gson gson = new Gson();
String json = gson.toJson(object);
return gson.fromJson(json, c);
}
public static class BrokenTestObject {
public final String id;
public transient final HashMap<String, String> someCache = new HashMap<>();
public BrokenTestObject(String id) {
this.id = id;
}
}
public static class FixedTestObject {
public final String id;
public transient final HashMap<String, String> someCache;
public FixedTestObject(String id) {
this.id = id;
this.someCache = new HashMap<>();
}
//only used during deserialization
private FixedTestObject() {
this.id = null; //doesn't matter, will be overwritten during deserialization
this.someCache = new HashMap<>();
}
}
}
打印：
broken: null
fixed: {}