参考于：

  1. JAVA中transient关键字的使用
  2. Java transient关键字使用小记

转载自：http://www.cnblogs.com/lanxuezaipiao/p/3369962.html

哎，虽然自己最熟的是Java，但很多Java基础知识都不知道，比如transient关键字以前都没用到过，所以不知道它的作用是什么，今天做笔试题时发现有一题是关于这个的，于是花个时间整理下transient关键字的使用，涨下姿势~~~好了，废话不多说，下面开始：

1. transient的作用及使用方法

我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。

然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

示例code如下：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/** * @description 使用transient关键字不序列化某个变量 * 注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致 * * @author Alexia * @date 2013-10-15 */
public class TransientTest {

    public static void main(String[] args) {

        User user = new User();
        user.setUsername("Alexia");
        user.setPasswd("123456");

        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());

        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("C:/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "C:/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();

            System.out.println("\nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    private static final long serialVersionUID = 8294180014912103005L;  

    private String username;
    private transient String passwd;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

}
 

 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7
  
  • 8
  
  • 9
  
  • 10
  
  • 11
  
  • 12
  
  • 13
  
  • 14
  
  • 15
  
  • 16
  
  • 17
  
  • 18
  
  • 19
  
  • 20
  
  • 21
  
  • 22
  
  • 23
  
  • 24
  
  • 25
  
  • 26
  
  • 27
  
  • 28
  
  • 29
  
  • 30
  
  • 31
  
  • 32
  
  • 33
  
  • 34
  
  • 35
  
  • 36
  
  • 37
  
  • 38
  
  • 39
  
  • 40
  
  • 41
  
  • 42
  
  • 43
  
  • 44
  
  • 45
  
  • 46
  
  • 47
  
  • 48
  
  • 49
  
  • 50
  
  • 51
  
  • 52
  
  • 53
  
  • 54
  
  • 55
  
  • 56
  
  • 57
  
  • 58
  
  • 59
  
  • 60
  
  • 61
  
  • 62
  
  • 63
  
  • 64
  
  • 65
  
  • 66
  
  • 67
  
  • 68
  
  • 69
  
  • 70
  
  • 71
  
  • 72
  
  • 73
  
  • 74
  
  • 75
  
  • 76
  
  • 77
  
  • 78
  
  • 79
  
  • 80
  
  • 81

输出为：

read before Serializable: 
username: Alexia
password: 123456

read after Serializable: 
username: Alexia
password: null
 

 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7

密码字段为null，说明反序列化时根本没有从文件中获取到信息。

2. transient使用小结

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

第三点可能有些人很迷惑，因为发现在User类中的username字段前加上static关键字后，程序运行结果依然不变，即static类型的username也读出来为“Alexia”了，这不与第三点说的矛盾吗？实际上是这样的：第三点确实没错（一个静态变量不管是否被transient修饰，均不能被序列化），反序列化后类中static型变量username的值为当前JVM中对应static变量的值，这个值是JVM中的不是反序列化得出的，不相信？好吧，下面我来证明：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/** * @description 使用transient关键字不序列化某个变量 * 注意读取的时候，读取数据的顺序一定要和存放数据的顺序保持一致 * * @author Alexia * @date 2013-10-15 */
public class TransientTest {

    public static void main(String[] args) {

        User user = new User();
        user.setUsername("Alexia");
        user.setPasswd("123456");

        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());

        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("C:/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            // 在反序列化之前改变username的值
            User.username = "jmwang";

            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "C:/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();

            System.out.println("\nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    private static final long serialVersionUID = 8294180014912103005L;  

    public static String username;
    private transient String passwd;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

}
 

 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7
  
  • 8
  
  • 9
  
  • 10
  
  • 11
  
  • 12
  
  • 13
  
  • 14
  
  • 15
  
  • 16
  
  • 17
  
  • 18
  
  • 19
  
  • 20
  
  • 21
  
  • 22
  
  • 23
  
  • 24
  
  • 25
  
  • 26
  
  • 27
  
  • 28
  
  • 29
  
  • 30
  
  • 31
  
  • 32
  
  • 33
  
  • 34
  
  • 35
  
  • 36
  
  • 37
  
  • 38
  
  • 39
  
  • 40
  
  • 41
  
  • 42
  
  • 43
  
  • 44
  
  • 45
  
  • 46
  
  • 47
  
  • 48
  
  • 49
  
  • 50
  
  • 51
  
  • 52
  
  • 53
  
  • 54
  
  • 55
  
  • 56
  
  • 57
  
  • 58
  
  • 59
  
  • 60
  
  • 61
  
  • 62
  
  • 63
  
  • 64
  
  • 65
  
  • 66
  
  • 67
  
  • 68
  
  • 69
  
  • 70
  
  • 71
  
  • 72
  
  • 73
  
  • 74
  
  • 75
  
  • 76
  
  • 77
  
  • 78
  
  • 79
  
  • 80
  
  • 81
  
  • 82
  
  • 83
  
  • 84

运行结果为：

read before Serializable: 
username: Alexia
password: 123456

read after Serializable: 
username: jmwang
password: null
 

 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7

这说明反序列化后类中static型变量username的值为当前JVM中对应static变量的值，为修改后jmwang，而不是序列化时的值Alexia。

3. transient使用细节——被transient关键字修饰的变量真的不能被序列化吗？

思考下面的例子：

import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

/** * @descripiton Externalizable接口的使用 * * @author Alexia * @date 2013-10-15 * */
public class ExternalizableTest implements Externalizable {

    private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(content);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        content = (String) in.readObject();
    }

    public static void main(String[] args) throws Exception {

        ExternalizableTest et = new ExternalizableTest();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                new File("test")));
        out.writeObject(et);

        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                "test")));
        et = (ExternalizableTest) in.readObject();
        System.out.println(et.content);

        out.close();
        in.close();
    }
}
 

 
    
  
  • 1
  
  • 2
  
  • 3
  
  • 4
  
  • 5
  
  • 6
  
  • 7
  
  • 8
  
  • 9
  
  • 10
  
  • 11
  
  • 12
  
  • 13
  
  • 14
  
  • 15
  
  • 16
  
  • 17
  
  • 18
  
  • 19
  
  • 20
  
  • 21
  
  • 22
  
  • 23
  
  • 24
  
  • 25
  
  • 26
  
  • 27
  
  • 28
  
  • 29
  
  • 30
  
  • 31
  
  • 32
  
  • 33
  
  • 34
  
  • 35
  
  • 36
  
  • 37
  
  • 38
  
  • 39
  
  • 40
  
  • 41
  
  • 42
  
  • 43
  
  • 44
  
  • 45
  
  • 46
  
  • 47
  
  • 48

content变量会被序列化吗？好吧，我把答案都输出来了，是的，运行结果就是：

是的，我将会被序列化，不管我是否被transient关键字修饰
 

 
    
  
  • 1

这是为什么呢，不是说类的变量被transient关键字修饰以后将不能序列化了吗？

我们知道在Java中，对象的序列化可以通过实现两种接口来实现，若实现的是Serializable接口，则所有的序列化将会自动进行，若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容，而不是null。

上面是原博主的文章，写得非常赞！下面是我自己不清楚的地方的提问和搜集解答。

一、Java序列化的方式

就如上面博主说的那样，Java序列化提供两种方式。

  • 一种是实现Serializable接口
    使用该方式非常简单，通过重写该接口预置的4个方法，可以达到对序列化的控制。不重写这些方法，也可以自动序列化，非常方便。
  • 另一种是实现Exteranlizable接口。
    不像Serializable接口只是一个标记接口，里面的接口方法都是可选的（可实现可不实现，如果不实现则启用其自动序列化功能），而Externalizable接口不是一个标记接口，它强制你自己动手实现串行化和反串行化方法。它的效率比Serializable高一些，并且可以决定哪些属性需要序列化（即使是transient修饰的），但是要求必须重写两个方法。Externalizable对小数目对象有效的多。但是对大量对象，或者重复对象，则效率低。

一、Java序列化有什么作用？

序列化(Serialization)：是将对象的状态信息转换为可以存储或传输的形式的过程.

二、Java序列化的特点

java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的”深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

三、序列化的应用场景

一是实现pojo对象的读写操作，将每个对象转换为字节流，而这些字节流可以被持久化到设备上，再次读取时会将字节流还原成对象。当我们希望某些数据能在程序停止运行后，还能继续存在。在程序再次执行时还能获取这些数据时，或者让其他的程序也能够利用这些数据资源时。这就是我理解的应用场景一。
二是实现网络间的数据传输。网络间的数据传输是高频发而且数据量也是非常大的。以订单数据传输为例，当我们希望获取到订单类里的全部数据并据此生成一份订单的excel文件时，这个订单类就必须要实现序列化，这是我理解的应用场景二。

四、Java序列化的优缺点

正如上面Java序列化特点所说，Java会序列类中所有引用的类，这会导致Java序列化的体积很大。
它的优点是使用简单，效率也不错