java bean的序列化及关键字transient的学习

2022-12-05 20:03:56

一、初识transient关键字

其实这个关键字的作用很好理解，就是简单的一句话：将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会被序列化。

概念也很好理解，下面使用代码去验证一下：

首先我们创建一个User类:

package com.bean;

import java.io.Serializable;

public class User implements Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private transient int age;
	private String name;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public static long getSerialversionuid() {
		return serialVersionUID;
	}
	
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + ", getAge()=" + getAge()
				+ ", getName()=" + getName() + ", getClass()=" + getClass()
				+ ", hashCode()=" + hashCode() + ", toString()="
				+ super.toString() + "]";
	}
	
}

要运行下面这个程序，首先要创建一个bin的二进制文件，G://java_learning/template.bin

package com.main;
import java.io.*;
import org.junit.Test;
import com.bean.User;


public class test1 {
	@Test	
	public void myTest1(){
		try {
			SerializeUser();
			DeSerializeUser();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	//序列化
	private static void SerializeUser() throws FileNotFoundException,IOException,ClassNotFoundException{
		User user=new User();
		user.setName("Java序列号学习");
		user.setAge(24);
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("G://java_learning/template.bin"));
		oos.writeObject(user);
		oos.close();
		System.out.println("添加了transient关键字序列化:age="+user.getAge());
	}
	
	//反序列化
	private static void DeSerializeUser() throws              IOException,ClassNotFoundException{
		File file=new File("G://java_learning/template.bin");
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
		User newUser=(User)ois.readObject();
		System.out.println("添加了transient关键字反序列化:age="+newUser.getAge());
		
	}
}

从上面可以看出，在序列化SerializeUser方法中，首先创建一个序列化user类，然后将其写入到G://java_learning/template.bin文件中。在反序列化DeSerializeUser方法中，首先创建一个File，然后读取G://java_learning/template.bin文件中的数据。

这就是序列化和反序列化的基本实现，而且我们看一下结果，也就是被transient关键字修饰的age属性是否被序列化。

然后我们运行，

看到红圈地方，我们序列化之前，把age设置为24，序列化之后，然后再次从bin文件中读出来，age变成了0，因此，可以得出结论，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会被序列化。

二、深入分析transient关键字

为了更加深入的去分析transient关键字，我们需要带着几个问题去解读：

（1）transient底层实现的原理是什么？

（2）被transient关键字修饰过得变量真的不能被序列化嘛？

（3）静态变量能被序列化吗？被transient关键字修饰之后呢？

带着这些问题一个一个来解决：

1、transient底层实现原理是什么？

java的serialization提供了一个非常棒的存储对象状态的机制，说白了serialization就是把对象的状态存储到硬盘上去，等需要的时候就可以再把它读出来使用。有些时候像银行卡号这些字段是不希望在网络上传输的，transient的作用就是把这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化，意思是transient修饰的age字段，他的生命周期仅仅在内存中，不会被写到磁盘中。

2、被transient关键字修饰过得变量真的不能被序列化嘛？

想要解决这个问题，首先还要再重提一下对象的序列化方式：

Java序列化提供两种方式。

一种是实现Serializable接口

另一种是实现Exteranlizable接口。需要重写writeExternal和readExternal方法，它的效率比Serializable高一些，并且可以决定哪些属性需要序列化（即使是transient修饰的），但是对大量对象，或者重复对象，则效率低。

从上面的这两种序列化方式，我想你已经看到了，使用Exteranlizable接口实现序列化时，我们自己指定那些属性是需要序列化的，即使是transient修饰的。下面就验证一下

首先我们定义User1类：这个类是被Externalizable接口修饰的

package com.bean;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class User1 implements Externalizable {
	private transient String name;
	
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "User1 [name=" + name + ", getName()=" + getName()
				+ ", getClass()=" + getClass() + ", hashCode()=" + hashCode()
				+ ", toString()=" + super.toString() + "]";
	}

	@Override
	public void readExternal(ObjectInput in) throws IOException,
			ClassNotFoundException {
		// TODO Auto-generated method stub
		name=(String) in.readObject();
	}

	@Override
	public void writeExternal(ObjectOutput out) throws IOException {
		// TODO Auto-generated method stub
		out.writeObject(name);
	}

}

然后我们就可以测试了

package com.main;

import java.io.*;
import org.junit.Test;
import com.bean.User1;

public class test1 {   
   @Test
   public void myTest2(){
		try {
			SerializeUser2();
			DeSerializeUser2();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	//序列化
		private static void SerializeUser2() throws FileNotFoundException,IOException,ClassNotFoundException{
			User1 user=new User1();
			user.setName("Java的架构师技术");
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("G://java_learning/template.bin"));
			oos.writeObject(user);
			oos.close();
			System.out.println("使用Externalizable接口，添加了transient关键字序列化之前"+user.toString());
		}
		
		//反序列化
		private static void DeSerializeUser2() throws IOException,ClassNotFoundException{
			File file=new File("G://java_learning/template.bin");
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
			User1 newUser=(User1)ois.readObject();
			System.out.println("使用Externalizable接口，添加了transient关键字序列化之后"+newUser.toString());
			//实现了Externalizable接口，哪一个属性被序列化使我们手动去指定的，即使是transient关键字修饰也不起作用。
		}
}

上面，代码分了两个方法，一个是序列化，一个是反序列化。里面的代码和一开始给出的差不多，只不过，User1里面少了age这个属性。

然后看一下结果：

结果基本上验证了我们的猜想，也就是说，实现了Externalizable接口，哪一个属性被序列化使我们手动去指定的，即使是transient关键字修饰也不起作用。

3、静态变量能被序列化吗？没被transient关键字修饰之后呢？

这个我可以提前先告诉结果，静态变量是不会被序列化的，即使没有transient关键字修饰。下面去验证一下，然后再解释原因。

首先，我们创建一个User2类，并且对age属性添加transient关键字和static关键字修饰。

package com.bean;

import java.io.Serializable;

public class User2 implements Serializable {
	private static transient int age;

	
	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User2 [age=" + age + ", getClass()=" + getClass()
				+ ", hashCode()=" + hashCode() + ", toString()="
				+ super.toString() + "]";
	}
	
}

然后，在Test类中去测试

package com.main;

import java.io.*;
import org.junit.Test;
import com.bean.User2;

public class test1 {

@Test
		public void SerializeUser3() throws FileNotFoundException,IOException,ClassNotFoundException{
			User2 user=new User2();
			//系列化之前age是24
			user.setAge(24);
			ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("G://java_learning/template.bin"));
			oos.writeObject(user);
			oos.close();
			//读取age的值
			System.out.println("static、transient关键字修饰age之前"+user.getAge());
			
			user.setAge(18);
			
			ObjectInputStream ois=new ObjectInputStream(new FileInputStream("G://java_learning/template.bin"));
			User2 newUser=(User2)ois.readObject();
			System.out.println("改变age之后"+newUser.getAge());
			
		}
}

运行，看下结果

结果已经很明显了。现在解释一下，为什么会是这样，其实在前面已经提到过了。因为静态变量在全局区,本来流里面就没有写入静态变量,我打印静态变量当然会去全局区查找,而我们的序列化是写到磁盘上的，所以JVM查找这个静态变量的值，是从全局区查找的，而不是磁盘上。user.setAge(18);年龄改成18之后，被写到了全局区，其实就是方法区，只不过被所有的线程共享的一块空间。因此可以总结一句话：

静态变量不管是不是transient关键字修饰，都不会被序列化

三、transient关键字总结

java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。像银行卡、密码等等这些数据。这个需要根据业务情况了。

码农公寓

相关文章