java java序列化方式 - 最终瞬态场和序列化




java序列化机制 java数组序列化 (5)

您可以使用Reflection更改字段的内容。 适用于Java 1.5+。 它可以工作,因为序列化是在一个线程中执行的。 在另一个线程访问同一个对象之后,它不应该更改最终字段(因为内存模型和reflaction中的怪异)。

因此,在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!
    }

}

记住: 决赛不再是决赛!

在Java中进行序列化后,是否可以将final transient字段设置为任何非默认值? 我的用例是缓存变量 - 这就是它是transient的原因。 我也习惯于制作不会改变的Map字段(即地图的内容被改变,但是对象本身保持不变) final 。 但是,这些属性似乎是矛盾的 - 虽然编译器允许这样的组合,但是在反序列化之后我不能将字段设置为null而是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> ();
    }
}

输出:

[email protected] {}
[email protected] null

是的,通过实现(显然鲜为人知的!) 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: [email protected] 'This data will be serialized' {This data=is transient}
After: [email protected] 'This data will be serialized' {}

五年后,我发现我的原始答案不能令人满意,因为我偶然发现了谷歌这篇文章。 另一种解决方案是根本不使用反射,并使用Boann建议的技术。

它还使用了ObjectInputStream#readFields()方法返回的GetField类,根据Serialization规范必须在私有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时,它才是使用常规构造函数创建的,而不是通过反序列化过程创建的。

自我注意:也许五年后会有更好的解决方案。 回头见!


不幸的是,简短的答案是“不” - 我经常想要这个。 但瞬态不可能是最终的。

必须通过直接赋值初始值或在构造函数中初始化final字段。 在反序列化期间,这些都不会被调用,因此必须在反序列化期间调用的'readObject()'私有方法中设置瞬态的初始值。 为了实现这一点,瞬态必须是非最终的。

(严格来说,决赛只是在他们第一次被阅读时才是最终的,所以有些黑客可能会在读取之前分配一个值,但对我来说这是一步太远了。)


final是Java中的一个保留关键字,用于限制用户,它可以应用于成员变量,方法,类和局部变量。 最终变量通常在Java中用static关键字声明,并被视为常量。 例如:

public static final String hello = "Hello";

当我们将final关键字与变量声明一起使用时,存储在该变量中的值不能被后者改变。

例如:

public class ClassDemo {
  private final int var1 = 3;
  public ClassDemo() {
    ...
  }
}

注意 :声明为final的类不能被扩展或继承(即不能有超类的子类)。 同样值得注意的是,声明为final的方法不能被子类覆盖。

本主题 介绍了使用final关键字的好处





java serialization final