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就不一定起作用了。有兴趣的小伙伴可以动手实践一下。