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