transient关键字的理解与应用

下面这段话来自百度百科：

 

java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。

 

下面给出示例：

 

 

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.xiva.domain;

import java.io.Serializable;

/**
 *
 * @author Xiva
 */
public class Traffic implements Serializable{
    
    private int logId;
    
    private String logName;
    
    private String logPosition;
    
    private String logCarNumber;
    
    private transient String logTime;

    
    public String getLogCarNumber() {
        return logCarNumber;
    }

    public void setLogCarNumber(String logCarNumber) {
        this.logCarNumber = logCarNumber;
    }

    public int getLogId() {
        return logId;
    }

    public void setLogId(int logId) {
        this.logId = logId;
    }

    public String getLogName() {
        return logName;
    }

    public void setLogName(String logName) {
        this.logName = logName;
    }

    public String getLogPosition() {
        return logPosition;
    }

    public void setLogPosition(String logPosition) {
        this.logPosition = logPosition;
    }

    public String getLogTime() {
        return logTime;
    }

    public void setLogTime(String logTime) {
        this.logTime = logTime;
    }
    
}

 

调用示例：

 

 

package com.xiva.baseKnowledge;

import com.xiva.domain.Traffic;
import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author XIVA
 */
public class ReverseString {
    
    public static String reverseStr(String orignalStr){
        StringBuilder sBuffer = new StringBuilder(orignalStr);
        sBuffer.reverse();
        return sBuffer.toString();
    }
    
    public static void transientExample() {
        Traffic traf = new Traffic();
        traf.setLogId(1);
        traf.setLogName("xiva" + 1);
        traf.setLogTime("20120514" + 1);
        FileOutputStream f;
        FileInputStream fi;
        ObjectOutputStream s;
        try {
            f = new FileOutputStream("E:\\tmp.txt");
            s = new ObjectOutputStream(f);
            s.writeObject(traf);
            s.flush();
        } catch (IOException ex) {
            Logger.getLogger(ReverseString.class.getName()).log(Level.SEVERE, null, ex);
        }
        try {
            fi= new FileInputStream("E:\\tmp.txt");
            ObjectInputStream  oi = new ObjectInputStream(fi);
            Traffic traf01 = (Traffic)oi.readObject();
            System.out.print(traf01.getLogId() + ":" + traf01.getLogName() + ":" + traf01.getLogTime());
        } catch (Exception ex) {
            Logger.getLogger(ReverseString.class.getName()).log(Level.SEVERE, null, ex);
        }
        
    }
    
    public static void main(String[] args){
//        String reString = reverseStr("ABCDEFG");
//        int firNum = 7;
//        int reNum = firNum >> 1;
//        System.out.println(reNum);
//        System.out.println(reString);
        transientExample();
    }
    
}

运行结果为：1:xiva1:null

 

从运行结果可以看出：

使用了transient属性的对象不能被反序列化的，也可以这样说，一个对象的属性被声明为transient，则在持久化的过程中会被忽略。

 

当某些属性我们需要用到，但没必要持久化的时候，我们可以加上关键词transient。