国产一级a片免费看高清,亚洲熟女中文字幕在线视频,黄三级高清在线播放,免费黄色视频在线看

作者：Favo yang
favoyang@yahoo.com

一個(gè)感性的認(rèn)識(shí)

java中處處體現(xiàn)著簡(jiǎn)單的程序設(shè)計(jì)風(fēng)格，序列化作為最常用的功能之一，在java中的設(shè)計(jì)尤為“簡(jiǎn)單”。在ObjectInputStream 和ObjectOutputStream的幫助下，我們可以輕松的實(shí)現(xiàn)序列化。

只要我們的class 實(shí)現(xiàn)了java.io.Serializable接口，就可以利用ObjectOutputStream的writeObject（）方法將一個(gè)對(duì)象序列化；利用ObjectInputStream的readObject()方法，可以返回讀出的object對(duì)象。Serializable接口不需要我們實(shí)現(xiàn)任何方法。

以下是一個(gè)例子，它能給我們一個(gè)感性的認(rèn)識(shí)：

Serial實(shí)現(xiàn)了就java.io.Serializable接口，是需要序列化的類。我們首先構(gòu)造一個(gè)Serial的對(duì)象serial1然后將其保存(序列化)在一個(gè)文件中，而后再將其讀出（反序列化），并打印其內(nèi)容。

package Stream;

/**
 * @author favo yang
 */

import java.io.*;

public class Serial implements Serializable {

    int company_id;

    String company_addr;

    boolean company_flag;

    public Serial(){}//不同于c++,沒有也可以

    public Serial(int company_id,String company_addr,boolean company_flag) {

        this.company_id=company_id;

        this.company_addr=company_addr;

        this.company_flag=company_flag;

    }

    public static void main(String[] args) {

        Serial serial1 = new Serial(752,"dayer street #5 building 02-287",false);
//構(gòu)造一個(gè)新的對(duì)象

        FileInputStream in=null;

        FileOutputStream out=null;

        ObjectInputStream oin=null;

        ObjectOutputStream oout=null;

        try {

            out = new FileOutputStream("5.txt");

            oout = new ObjectOutputStream(out);

            serial1.serialize(oout);//序列化

            oout.close();

            oout=null;

            in = new FileInputStream("5.txt");

            oin = new ObjectInputStream(in);

            Serial serial2 = Serial.deserialize(oin);//反序列化

            System.out.println(serial2);//打印結(jié)果

        } catch (Exception ex){

            ex.printStackTrace();

        } finally{

            try {

                if (in != null) {

                    in.close();

                }

                if (oin != null) {

                    oin.close();

                }

                if (out != null) {

                    out.close();

                }

                if (oout != null) {

                    oout.close();

                }

            } catch (IOException ex1) {

                ex1.printStackTrace();

            }

        }

    }

    /**
     * deserialize
     */

    public static Serial deserialize(ObjectInputStream oin) throws Exception{

        Serial s=(Serial)oin.readObject();

        return s;

    }

    public String toString() {

        return "DATA: "+company_id+" "+company_addr+" "+company_flag;

    }

    /**

     * serialize

     */

    public void serialize(ObjectOutputStream oout) throws Exception{

        oout.writeObject(this);

    }

}

運(yùn)行結(jié)果：

DATA: 752 dayer street #5 building 02-287 false
正確打印了結(jié)果。

現(xiàn)在序列化的功能還沒有被j2me支持，所以我們?cè)趈2me中是使用DataInputStream、DataoutputStream配合rms或者網(wǎng)絡(luò)實(shí)現(xiàn)序列化。詳細(xì)的介紹請(qǐng)參見：本站的另外兩篇文章：《Java的基本數(shù)據(jù)類型與流》、
《J2ME聯(lián)網(wǎng)中采用序列化機(jī)制》
 

了解序列化帶來的風(fēng)險(xiǎn)與問題 

    我們已經(jīng)看到了序列化的優(yōu)點(diǎn)，就是簡(jiǎn)單的序列化的實(shí)現(xiàn)成本很低，或者說沒有什么實(shí)現(xiàn)成本，只要實(shí)現(xiàn)一個(gè)接口就行了。但如果你將上文中的那個(gè)例子簡(jiǎn)單的套用在你的程序中，然后發(fā)表的話，你可有苦頭了。你將會(huì)很快發(fā)現(xiàn)序列化帶來問題：

1.實(shí)現(xiàn)了Serializable接口的類的改動(dòng)變得很難（兼容性問題）。
    如果你想保持向下兼容性的話，這意味著要求新版本反序列化老版本序列化的數(shù)據(jù)流；如果你想保持向上兼容性的話，這意味著要求老版本反序列化新版本的數(shù)據(jù)流。尤其是向下兼容性的問題帶來了讓我們的代碼實(shí)現(xiàn)很難改動(dòng)的問題，為了能在新版本中反序列化老版本的數(shù)據(jù)流，類的實(shí)現(xiàn)必須要保留老版本的實(shí)現(xiàn)過程。這無疑是我們給自己加帶上的一副枷鎖。

2.實(shí)現(xiàn)了Serializable接口的類的測(cè)試成本大大增加了
    可以想象，當(dāng)新版本發(fā)布時(shí)，為了保持兼容性，你的測(cè)試量將是版本數(shù)的平方！

3.草率的接受默認(rèn)的序列化方式可能會(huì)帶來性能問題，甚至更糟。
    序列化作為額外的一種“構(gòu)造函數(shù)”可能破壞數(shù)據(jù)的完整性、約束性，甚至，一個(gè)精心偽造的數(shù)據(jù)流所序列化出的對(duì)象可能帶來安全隱患。

了解了這些可能的風(fēng)險(xiǎn)后，我們?cè)谛蛄谢臅r(shí)候遇到了難題，如何避免這些風(fēng)險(xiǎn)呢？我將這些風(fēng)險(xiǎn)概括為以下幾個(gè)方面：

1.    當(dāng)序列化遇到繼承時(shí)引發(fā)的問題？
2.    何時(shí)接受默認(rèn)的java序列化？
3.    兼容性問題
4.    數(shù)據(jù)一致性問題與數(shù)據(jù)約束問題
5.    安全性問題

如何應(yīng)對(duì)這些風(fēng)險(xiǎn)呢？請(qǐng)關(guān)注接下來的內(nèi)容。

當(dāng)序列化遇到繼承…
當(dāng)一個(gè)父類實(shí)現(xiàn)Serializable接口后，他的子類都將自動(dòng)的實(shí)現(xiàn)序列化。

以下驗(yàn)證了這一點(diǎn)：

package Serial;
import java.io.Serializable;
public class SuperC implements Serializable {//父類實(shí)現(xiàn)了序列化 
    int supervalue; 
    public SuperC(int supervalue) { 
       this.supervalue = supervalue; 
    } 
    public String toString() { 
       return "supervalue: "+supervalue; 
    }
}

public class SubC extends SuperC {//子類 
    int subvalue; 

    public SubC(int supervalue,int subvalue) { 
       super(supervalue); 
       this.subvalue=subvalue; 
    } 

    public String toString() { 
       return super.toString()+" sub: "+subvalue; 
    }
}

public class Test1 {

    public static void main(String [] args){ 
       SubC subc=new SubC(100,200); 
       FileInputStream in=null; 
        FileOutputStream out=null; 
        ObjectInputStream oin=null; 
        ObjectOutputStream oout=null; 
        try { 
            out = new FileOutputStream("Test1.txt");//子類序列化 
            oout = new ObjectOutputStream(out); 
            oout.writeObject(subc); 
            oout.close(); 
            oout=null;

            in = new FileInputStream("Test1.txt"); 
            oin = new ObjectInputStream(in); 
            SubC subc2=(SubC)oin.readObject();//子類反序列化 
            System.out.println(subc2); 
        } catch (Exception ex){ 
            ex.printStackTrace(); 
        } finally{ 
            …此處省略 
        } 
    }
}

運(yùn)行結(jié)果如下：

supervalue: 100 sub: 200

可見子類成功的序列化/反序列化了。

怎管讓子類實(shí)現(xiàn)序列化看起來是一件很簡(jiǎn)單的事情，但有的時(shí)候，往往我們不能夠讓父類實(shí)現(xiàn)Serializable接口，原因是有時(shí)候父類是抽象的（這并沒有關(guān)系），并且父類不能夠強(qiáng)制每個(gè)子類都擁有序列化的能力。換句話說父類設(shè)計(jì)的目的僅僅是為了被繼承。

要為一個(gè)沒有實(shí)現(xiàn)Serializable接口的父類，編寫一個(gè)能夠序列化的子類是一件很麻煩的事情。java docs中提到：

“To allow subtypes of non-serializable classes to be serialized, the subtype may assume responsibility for saving and restoring the state of the supertype‘s public, protected, and (if accessible) package fields. The subtype may assume this responsibility only if the class it extends has an accessible no-arg constructor to initialize the class‘s state. It is an error to declare a class Serializable if this is not the case. The error will be detected at runtime. ”

也就是說，要為一個(gè)沒有實(shí)現(xiàn)Serializable接口的父類，編寫一個(gè)能夠序列化的子類要做兩件事情：

其一，父類要有一個(gè)無參的constructor；

其二，子類要負(fù)責(zé)序列化（反序列化）父類的域。

我們將SuperC的Serializable接口去掉，而給SubC加上Serializable接口。運(yùn)行后產(chǎn)生錯(cuò)誤：

java.lang.Error: Unresolved compilation problem: 
    Serializable cannot be resolved or is not a valid superinterface 
    at Serial.SubC.<init>(SubC.java:15) 
    at Serial.Test1.main(Test1.java:19)
Exception in thread "main"

    果真如docs中所說的一樣，父類缺少無參構(gòu)造函數(shù)是不行的。

    接下來，按照docs中的建議我們改寫這個(gè)例子：
public abstract class SuperC  { 
    int supervalue; 
    public SuperC(int supervalue) { 
       this.supervalue = supervalue; 
    }
    public SuperC(){}//增加一個(gè)無參的constructor 
    public String toString() { 
       return "supervalue: "+supervalue; 
    }
}

public class SubC extends SuperC implements Serializable { 
    int subvalue;

    public SubC(int supervalue,int subvalue) { 
       super(supervalue); 
       this.subvalue=subvalue; 
    } 
    
    public String toString() { 
       return super.toString()+" sub: "+subvalue; 
    } 
    
    private void writeObject(java.io.ObjectOutputStream out) 
    throws IOException{ 
       out.defaultWriteObject();//先序列化對(duì)象 
       out.writeInt(supervalue);//再序列化父類的域 
    } 
    private void readObject(java.io.ObjectInputStream in) 
    throws IOException, ClassNotFoundException{ 
       in.defaultReadObject();//先反序列化對(duì)象 
       supervalue=in.readInt();//再反序列化父類的域 
    }
}

運(yùn)行結(jié)果證明了這種方法是正確的。在此處我們用到了writeObject/ readObject方法，這對(duì)方法如果存在的話，序列化時(shí)就會(huì)被調(diào)用，以代替默認(rèn)的行為（以后還要探討，先了解這么多）。我們?cè)谛蛄谢瘯r(shí)，首先調(diào)用了ObjectOutputStream的defaultWriteObject，它使用默認(rèn)的序列化行為，然后序列化父類的域；反序列化的時(shí)候也一樣。

歸納一下：