java transient 方法_Java中序列化与transient的使用

一、序列化

1.1 什么是序列化，为什么要序列化？

我们在运行Java程序的时候，各个对象是有状态的。比如，我们创建了如下的一个Fruit对象，它的名字和重量是它当前的状态信息：

public static void main(String[] args) {

Fruit apple = new Fruit();

apple.setName("apple");

apple.setWeight(23);

}

在有的场景下，我们需要将该对象当前的状态信息持久化地保留下来，或者借助网络传输到别的地方，而这些场景是无法以对象的形态保留信息的，毕竟只有Java运行的时候才有对象这个概念。

因此，我们只能以文本或者字符的形式来表示当前Java中该对象的状态信息。那么，将Java中一个动态的对象表示成文本或者字符的过程，我们就称之为序列化。

1.2 如何在Java中使用序列化

常见的Java序列化方法有Java原生序列化、Hessian序列化、kryo序列化、Json序列化等，这里以介绍Java原生序列化为例。

默认声明的类是不能支持序列化的，只有当这个类实现了Serializable接口，才可以被序列化。而这个Serializable接口中不包含任何方法和属性，它仅仅是起到一个序列化标识的作用。下面是一个例子：

@Data

public class Fruit implements Serializable {

private String name;

private Integer weight;

// setters and getters...

}

public static void main(String[] args) {

Fruit apple = new Fruit();

apple.setName("apple");

apple.setWeight(23);

saveToFile(apple);

System.out.println("序列化结束");

}

private static void saveToFile(Fruit fruit){

try {

FileOutputStream fs = new FileOutputStream("fruit.txt");

ObjectOutputStream os = new ObjectOutputStream(fs);

os.writeObject(fruit);

os.flush();

os.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

如果以上Fruit类没有实现Serializable接口，程序运行就会报错：

java.io.NotSerializableException: cn.zx.demo.Fruit

at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)

at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)

at cn.zx.demo.Main.saveToFile(Main.java:27)

at cn.zx.demo.Main.main(Main.java:19)

只有实现了该接口，才能正常运行并生成一个txt文件，这个就是我们apple对象序列化后的结果。

1.3 反序列化的使用

反序列化，顾名思义，就是要把以文本形式持久化了的对象信息再还原成Java运行时动态的对象的状态。

我们使用上面序列化中的例子，将持久化了的文本txt读入：

public static void main(String[] args) {

Fruit apple = readFromFile("fruit.txt");

// print apple

System.out.println(apple.getName());

// print 23

System.out.println(apple.getWeight());

}

private static Fruit readFromFile(String fileName){

Fruit fruit = null;

try{

FileInputStream fs = new FileInputStream(fileName);

ObjectInputStream os = new ObjectInputStream(fs);

fruit = (Fruit) os.readObject();

os.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return fruit;

}

反序列化成功，我们成功地从序列化了的文本信息中恢复了动态的Java对象及其序列化时的状态信息。

1.4 版本标识serialVersionUID

当一个对象被序列化后，接着需要被反序列化时，如何判断能否顺利地反序列化形成对象呢？因为原来的类可能被修改了，可能和序列化时的类是不一样的。

因此，需要使用serialVersionUID用来标识反序列化时类的版本和序列化时类的版本是否一致。当值是一致的，则表示可以序列化，反之则不能序列化，会报如下错误：

java.io.InvalidClassException: cn.zx.demo.code.Fruit; local class incompatible: stream classdesc serialVersionUID = -4079670274710263332, local class serialVersionUID = -1938591684852446153

at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)

at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1843)

在默认情况下，serialVersionUID的值不需要我们手动指定，系统会自动指定，只要我们确定序列化和反序列化前后的类没有发生变化，那么就不会出现如上的问题。

倘若我们将序列化之后的类增加了一个属性，或者加了一个别的逻辑，改变了类的程序结构，那么系统就会自动更改serialVersionUID的值，从而使得反序列化失败，报出如上的错误。比如我们加一个属性：

@Data

public class Fruit implements Serializable {

private String name;

private Integer weight;

private Double price;

// setters and getters...

}

但这是不合理的，因为我们只是加了一个属性，并不妨碍反序列化，新加的属性让其值为空不就行了，所以，让系统自动指定serialVersionUID的值在这种场景下就不是那么合理。我们需要自己指定它的值。

@Data

public class Fruit implements Serializable {

private static final long serialVersionUID = -1L;

private String name;

private Integer weight;

// setters and getters...

}

然后，随便你怎么改动类的结构，只要保证serialVersionUID不变，程序就不会比较这个值是否一致，从而尝试反序列化。

比如新加的一个属性反序列化后，内存中的它只不过是没有值而已，其它可以反序列化的属性不受影响。如果你改动的是原先序列化时就存在的属性，那么也没有关系，反序列化找不到对应的属性就会跳过，把能反序列化的都赋值，不能的全部为空。

1.5 序列化的使用注意事项

父类如果实现了序列化的接口，那么其子类自动拥有了序列化的能力；

一个已经实现了序列化的类引用了其它的类，那么其它的类也必须实现序列化的接口，否则序列化过程会报错java.io.NotSerializableException;

静态变量和transient修饰的变量不会被序列化；

1.6 序列化的常见使用场景

远程方法调用(RPC)；

对象存储到文件或者数据库中；

实现对象的深拷贝；

二、transient

2.1 transient的作用是什么

在将对象序列化的时候，并不是所有的字段都需要保存起来。比如一些敏感信息，我们只要求在内存中使用就好，序列化的时候不要连同它们一起持久化。这时候，Java中的transient关键字就派上用场了，被它修饰了的字段就不会被序列化：

private transient Integer weight;

我们仍然使用上面的序列化和反序列化的例子，只不过给Fruit类中的weight属性加上transient关键字，希望它不要被序列化。

然后运行一次序列化和反序列的程序，得到的打印结果中weight为null。由此证明了transient生效了。

2.2 transient的使用注意事项

被transient修饰的变量无法序列化，随后反序列时便无法恢复该变量的值；

transient只能用来修饰变量，无法修饰类和方法；

类中的静态变量也是无法序列化的，因为类变量属于类，不属于对象。

关于如上第三点，给出实验进行证明：

public class Fruit implements Serializable {

private static final long serialVersionUID = 6950076107144781481L;

private String name;

private transient Integer weight;

private static String color;

public Fruit(){}

// getters and setters...

}

public static void main(String[] args) {

Fruit apple = new Fruit();

apple.setName("apple");

apple.setWeight(23);

Fruit.setColor("red");

saveToFile(apple);

System.out.println("序列化结束");

}

private static void saveToFile(Fruit fruit){

try {

FileOutputStream fs = new FileOutputStream("fruit.txt");

ObjectOutputStream os = new ObjectOutputStream(fs);

os.writeObject(fruit);

os.flush();

os.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

先执行如上程序，将设置好静态变量color的apple对象进行序列化，然后再执行如下程序得出反序列化后的结果：

public static void main(String[] args) {

Fruit apple = readFromFile("fruit.txt");

// print apple

System.out.println(apple.getName());

// print null

System.out.println(apple.getWeight());

// print null

System.out.println(Fruit.getColor());

}

private static Fruit readFromFile(String fileName){

Fruit fruit = null;

try{

FileInputStream fs = new FileInputStream(fileName);

ObjectInputStream os = new ObjectInputStream(fs);

fruit = (Fruit) os.readObject();

os.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

return fruit;

}

三、待解决的疑问

你最常用的序列化和反序列化的业务场景是什么？

答复：在1.6中已经列出场景。

日常开发中，最常使用的场景就是数据库数据的读写、关联方系统Json数据的传输，但是并没有留意到DTO和PO有实现Serializable接口，更没有serialVersionUID的声明，这是为什么呢？它们不算序列化的操作吗？

答复：Json是Java中的另一种序列化方法，不是原生的序列化方法，不需要实现Serializable接口。