Java关键字-transient
transient关键字的作用及使用方法
在实际开发当中我们经常需要对一些对象进行序列化操作，但是有时我们一个对象中有些敏感的字段、或者业务要求默写数据不能进行序列化存储，那我们怎么办呢？这时候transient就可以帮我们解决类似的问题了。
transient的使用方法也是很简单，我们只需要在不需要序列化的字段声明时加上transient关键字进行修饰即可，此时被transient关键字修饰的字段的值就不会被序列化了。
让我们来通过实际的代码来体会一下transient的功能吧！
首先我们创建一个用于测试的User类：
package com.mark.java;
import java.io.Serializable;
/**
* Created by Mark on 16/8/11.
*/
public class User implements Serializable {
private String name;
private String password;
public User(String name, String password) {
this.name = name;
this.password = password;
}
public String getName() {
return name;
}
public User setName(String name) {
this.name = name;
return this;
}
public String getPassword() {
return password;
}
public User setPassword(String password) {
this.password = password;
return this;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
User类实现了Serializable接口，表示可以进行序列化操作，我们来看看不使用transient关键字进行序列化和反序列化的效果：
package com.mark.java;
import android.os.Bundle;
import android.os.Environment;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class MainActivity extends AppCompatActivity {
private static final String TAG = MainActivity.class.getSimpleName();
/**
* 存储User对象的路径
*/
private String path = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "user.text";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 序列化操作
findViewById(R.id.btnWrite).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 创建User对象
User user = new User("Mark", "coder");
// 打印User对象
Log.d(TAG, "Write : " + user.toString());
// 将User对象写入到指定的文件中
try {
File file = new File(path);
if (!file.exists()) {
file.createNewFile();
}
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(user);
oos.flush();
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
});
// 反序列化操作
findViewById(R.id.btnRead).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 读取上一步写入文件中的User对象
try {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(path));
User user = (User) ois.readObject();
ois.close();
// 打印获取到的User对象
Log.d(TAG, "Read : " + user.toString());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
});
}
}
上面的代码根据注释大家都能看懂，这里就不解释了，看看操作后的日志输出情况吧。
08-11 02:21:46.124 10302-10302/com.mark.java D/MainActivity: Write : User{name='Mark', password='coder'}
08-11 02:21:48.839 10302-10302/com.mark.java D/MainActivity: Read : User{name='Mark', password='coder'}可以看到，序列化和反序列化操作之后User的信息是相同的，假设这时我们不想讲password字段进行序列化，那我们就需要使用transient关键字进行修饰，例如：
private transient String password;我们在重复上面的操作，日志如下：
08-11 02:26:54.088 15038-15038/com.mark.java D/MainActivity: Write : User{name='Mark', password='coder'}
08-11 02:26:55.855 15038-15038/com.mark.java D/MainActivity: Read : User{name='Mark', password='null'}
可以看到password=null了，这就是transient的作用，因为上面我们使用transient关键字修饰了password字段，所以在序列化操作的时候系统是不会对password进行序列化操作的，而是给他一个null。
我们再来测试一下基本数据类型被transient修饰会怎样。
package com.mark.java;
import java.io.Serializable;
/**
* Created by Mark on 16/8/11.
*/
public class User implements Serializable {
private transient boolean bool = false;
private transient long l = 1234567890L;
private transient double d = 123456789.0D;
private transient float f = 123456789.0F;
private transient short s = 123;
private transient byte b = 1;
private transient int age = 20;
private String name;
private transient String password;
public User(String name, String password) {
this.name = name;
this.password = password;
}
public String getName() {
return name;
}
public User setName(String name) {
this.name = name;
return this;
}
public String getPassword() {
return password;
}
public User setPassword(String password) {
this.password = password;
return this;
}
@Override
public String toString() {
return "User{" +
"bool=" + bool +
", l=" + l +
", d=" + d +
", f=" + f +
", s=" + s +
", b=" + b +
", age=" + age +
", name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
我们在User中简单的增加了一些基本数据类型的测试数据，并重写了toString方法。打印日志如下：
08-11 02:37:22.256 24595-24595/com.mark.java D/MainActivity: Write : User{bool=false, l=1234567890, d=1.23456789E8, f=1.2345679E8, b=1, age=20, name='Mark', password='coder'}
08-11 02:37:24.671 24595-24595/com.mark.java D/MainActivity: Read : User{bool=false, l=0, d=0.0, f=0.0, b=0, age=0, name='Mark', password='null'}
根据日志可以得出结论，所有被transient修饰的字段，不会被序列化，在反序列化时此字段会使用此字段类型的默认值。
static、final对transient的影响
修改User类如下：
package com.mark.java;
import java.io.Serializable;
/**
* Created by Mark on 16/8/11.
*/
public class User implements Serializable {
private final boolean bool = true;
private final long l = 1234567890L;
private static double d = 123456789.0D;
private static float f = 123456789.0F;
private short s = 123;
private byte b = 1;
private int age = 20;
private static String name;
private final String name1 = "Mark";
private static final String name2 = "Mark";
private String password;
public User(String name, String password) {
this.name = name;
this.password = password;
}
public String getName() {
return name;
}
public User setName(String name) {
this.name = name;
return this;
}
public String getPassword() {
return password;
}
public User setPassword(String password) {
this.password = password;
return this;
}
@Override
public String toString() {
return "User{" +
"bool=" + bool +
", l=" + l +
", d=" + d +
", f=" + f +
", s=" + s +
", b=" + b +
", age=" + age +
", name='" + name + '\'' +
", name1='" + name1 + '\'' +
", name2='" + name2 + '\'' +
", password='" + password + '\'' +
'}';
}
}
我们修改所有字段不被transient修饰，只使用static、和final来修饰，我们来看看日志：
08-11 03:47:05.222 6872-6872/com.mark.java D/MainActivity: Write : User{bool=true, l=1234567890, d=1.23456789E8, f=1.2345679E8, s=123, b=1, age=20, name='Mark', name1='Mark', name2='Mark', password='coder'}
08-11 03:47:08.870 6872-6872/com.mark.java D/MainActivity: Read : User{bool=true, l=1234567890, d=1.23456789E8, f=1.2345679E8, s=123, b=1, age=20, name='Mark', name1='Mark', name2='Mark', password='coder'}从日志中我们可以看出，static、和final单独修饰字段或者组合修饰字段都不会影响序列化和反序列化操作。接下来我们将上面User类的所有字段都加上transient关键字，如下：
private transient final boolean bool = true;
private transient final long l = 1234567890L;
private transient static double d = 123456789.0D;
private transient static float f = 123456789.0F;
private transient short s = 123;
private transient byte b = 1;
private transient int age = 20;
private transient static String name;
private transient final String name1 = "Mark";
private transient static final String name2 = "Mark";
private transient String password;运行日志如下：
08-11 03:52:30.773 11948-11948/com.mark.java D/MainActivity: Write : User{bool=true, l=1234567890, d=1.23456789E8, f=1.2345679E8, s=123, b=1, age=20, name='Mark', name1='Mark', name2='Mark', password='coder'}
08-11 03:52:37.911 11948-11948/com.mark.java D/MainActivity: Read : User{bool=true, l=1234567890, d=1.23456789E8, f=1.2345679E8, s=0, b=0, age=0, name='Mark', name1='Mark', name2='Mark', password='null'}
从日志可以看出只有b、age、password的transient起了作用。恰巧这三个字段没有static、final修饰，故我们可以得出结论：
static、final修饰的字段在使用transient修饰，则transient关键字不起作用，即static、final修饰的字段可以正常进行序列化和反序列化。
transient使用小结
1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。
transient修饰的变量也可以进行序列化
在Android中要序列化可以实现Serializable接口或者Parcelable接口。以上所有测试都是基于Serializable接口，对于Parcelable不成立。因为Parcelable接口序列化过程是我们自己控制的，而Serializable接口序列化过程是系统控制的，所以以上测试和结论都是相对Serializable接口序列化而言。
如果实现Parcelable接口进行序列化则transient就不一定起作用了。有兴趣的小伙伴可以动手实践一下。