深入淺析Java Object Serialization與 Hadoop 序列化

發(fā)布時間：2020-09-05 11:01:05 來源：腳本之家閱讀：148 作者：楊jun堅欄目：編程語言

一，Java Object Serialization

1，什么是序列化(Serialization)

序列化是指將結(jié)構(gòu)化對象轉(zhuǎn)化為字節(jié)流以便在網(wǎng)絡(luò)上傳輸或者寫到磁盤永久存儲的過程。反序列化指將字節(jié)流轉(zhuǎn)回結(jié)構(gòu)化對象的逆過程。簡單的理解就是對象轉(zhuǎn)換為字節(jié)流用來傳輸和保存，字節(jié)流轉(zhuǎn)換為對象將對象恢復(fù)成原來的狀態(tài)。

2，序列化(Serialization)的作用

（1）一種持久化機制，把的內(nèi)存中的對象狀態(tài)保存到一個文件中或者數(shù)據(jù)庫。

（2）一種通信機制，用套接字在網(wǎng)絡(luò)上傳送對象。

（3）Java遠程方法調(diào)用(RMI)需要調(diào)用對象時，

3，實現(xiàn)了Serializable接口的對象的序列化

在java.io包中，接口Serialization用來作為實現(xiàn)對象串行化的工具，只有實現(xiàn)了Serialization的類的對象才可以被序列化。 Serializable接口中沒有任何的方法，當(dāng)一個類聲明要實現(xiàn)Serializable接口時，只是表明該類參加序列化協(xié)議，而不需要實現(xiàn)任何特殊的方法。

要序列化一個對象，首先要創(chuàng)建OutputStream對象，然后將其封裝在一個ObjectOutputStream對象內(nèi)。此時，調(diào)用writeObject()方法將對象序列化并發(fā)送給OutputStream。在反序列化時，需要將一個InputStream封裝在ObjectInputStream內(nèi)，然后調(diào)用readObject()，得到的結(jié)果是一個Object對象，需要進行轉(zhuǎn)型得到最后所需的對象。需要注意的是，在對一個Serializable對象進行反序列化的過程中，沒有調(diào)用任何構(gòu)造器，包括缺省的構(gòu)造器，整個對象都是通過從InputStream中取得數(shù)據(jù)恢復(fù)過來的。對象序列化是面向字節(jié)的，因此采用InputStream和OutputStream層次結(jié)構(gòu)。

對Student序列化

package cn.test.serializable;
/**
 * 序列化對象實現(xiàn)Serializable接口
 * @author Young
 * created on 2017-5-25
 */
import java.io.Serializable;
public class Student implements Serializable {
  private String id;
  private String name;
  public Student (String id,String name){
    this.id=id;
    this.name=name;
  }
  public String getId() {
    return id;
  }
  public void setId(String id) {
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
}

序列化

package cn.test.serializable;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
 * 序列化
 * @author Young
 * created on 2017-5-25
 */
public class TestSerializable {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Student stu=new Student("201441413110","yang");
    try {
      FileOutputStream out=new FileOutputStream("d:\\student");//創(chuàng)建OutputStream對象
      ObjectOutputStream ob=new ObjectOutputStream(out);//封裝在一個ObjectOutputStream對象內(nèi)
      ob.writeObject(stu);//調(diào)用writeObject()方法將對象序列化并發(fā)送給OutputStream,保存在d:\\student中
      ob.close();
      out.close();
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

反序列化

package cn.test.serializable;
/**
 * 反序列化
 * @author Young
 * created on 2017-5-25
 */
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
public class TestDeserializable {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    FileInputStream in;
    Student stu;
    try {
      in = new FileInputStream("d:\\student");
      ObjectInputStream ob=new ObjectInputStream(in);//InputStream封裝在ObjectInputStream內(nèi)
      stu=(Student) ob.readObject();//調(diào)用readObject()，得到的結(jié)果是一個Object對象，需要進行轉(zhuǎn)型得到最后所需的對象.
      ob.close();
      in.close();
      System.out.println(stu.getId());
      System.out.println(stu.getName());
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

序列化機制寫到流中的數(shù)據(jù)有

1，聲明和標(biāo)記，比如聲明使用了序列化協(xié)議、序列化協(xié)議版本、聲明這是一個新的對象、聲明這里開始一個新Class、結(jié)束標(biāo)記等。

2，對象所屬的類，類的長度，

3，SerialVersionUID, 序列化ID，如果沒有指定，則會由算法隨機生成一個8byte的ID。

4，所有的非transient和非static的屬性的個數(shù)以及名稱。名稱長度，屬性的值。

這只是簡單對象序列化后寫到流中的數(shù)據(jù)。如果是復(fù)雜對象序列化就會包含更多的信息。比如引用其他對象作為成員變量，這是會將引用的對象也進行序列化。還有序列化時，只對對象的狀態(tài)進行保存，而不管對象的方法；當(dāng)一個父類實現(xiàn)序列化，子類自動實現(xiàn)序列化，不需要顯式實現(xiàn)Serializable接口；當(dāng)一個對象的實例變量引用其他對象，序列化該對象時也把引用對象進行序列化。

二，Hadoop 序列化

hadoop在節(jié)點間的內(nèi)部通訊使用的是RPC，RPC協(xié)議把消息翻譯成二進制字節(jié)流發(fā)送到遠程節(jié)點，遠程節(jié)點再通過反序列化把二進制流轉(zhuǎn)成原始的信息。

Hadoop使用自己的序列化格式Writable，它絕對緊湊、高速，但不太容易用Java以外的語言進行拓展和使用。

1，Writable接口

Writable接口定義了兩個方法：一個將其狀態(tài)寫到DataOutput二進制流，另一個從DataInput二進制流讀取其狀態(tài)：

實現(xiàn)代碼

package Hadoop.writable;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Writable;
/**
 * hadoop 序列化與反序列化
 * @author Young
 * created by 2017-6-9
 */
public class Serialize {
  public static byte[] serialize(Writable writable) throws IOException{
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    DataOutputStream dataout = new DataOutputStream(out);
    try {
      writable.write(dataout);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }finally{
      dataout.close();
    }
    return out.toByteArray();
  }
  public static byte[] deserialize(Writable writable ,byte[] bytes) throws IOException{
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    DataInputStream datain = new DataInputStream(in);
    try {
      writable.readFields(datain);
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    finally{
      datain.close();
    }
    return bytes;
  }
  public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    IntWritable intwritable = new IntWritable(20);
    IntWritable newwriatble =new IntWritable();
    byte[] bytes=Serialize.serialize(intwritable);
    deserialize(newwriatble,bytes);
    System.out.println(newwriatble.get());
  }
}

2，Hadoop序列化機制中還包含另外幾個重要的接口：WritableComparable、RawComparator 和 WritableComparator

WritableComparable提供類型比較的能力，繼承自Writable接口和Comparable接口，其中Comparable進行類型比較。ByteWritable、IntWritable、DoubleWritable等java基本類型對應(yīng)的Writable類型，都繼承自 WritableComparable。

WritableComparable接口

package org.apache.hadoop.io;
import org.apache.hadoop.classification.InterfaceAudience.Public;
import org.apache.hadoop.classification.InterfaceStability.Stable;
import org.apache.hadoop.io.Writable;
@Public
@Stable
public interface WritableComparable<T> extends Writable, Comparable<T> {
}

對于MapReduce來說，類型的比較非常重要，因為中間有個基于鍵的排序階段。Hadoop提供了一個具有高效比較能力的RawComparator接口。

RawComparator接口

package org.apache.hadoop.io;
import java.util.Comparator;
import org.apache.hadoop.classification.InterfaceAudience.Public;
import org.apache.hadoop.classification.InterfaceStability.Stable;
@Public
@Stable
public interface RawComparator<T> extends Comparator<T> {
  int compare(byte[] arg0, int arg1, int arg2, byte[] arg3, int arg4, int arg5);
}

該接口允許其實現(xiàn)直接比較數(shù)據(jù)流中的記錄，無須先把數(shù)據(jù)流反序列化為對象，這樣避免了新建對象而外的開銷。

WritableComparator 是對繼承自WritableComparable類的RawComparator類的一個通用實現(xiàn)。提供兩個主要功能。1，提供對原始的compare（）方法的一個默認(rèn)實現(xiàn)，該方法能夠反序列化將在流中進行比較的對象，并調(diào)用對象的compare（）方法。2，它充當(dāng)?shù)氖荝awComparator實例的工廠，例如為了獲得IntWritable的comparator，可以直接調(diào)用

RawComparator<IntWritable>comparator=WritableComparator.get(IntWritable.class);

下面是《Hadoop權(quán)威指南》的例子

package cn.serialization;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.RawComparator;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparator;
public class TestWritable {
  //序列化
  public static byte[] serialize(Writable writable) throws IOException{
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    DataOutputStream dataOut= new DataOutputStream(out);
    writable.write(dataOut);
    dataOut.close();
    return out.toByteArray();
  }
  //反序列化
  public static byte[] deserialize(Writable writable, byte[] bytes) throws IOException{
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    DataInputStream dataIn = new DataInputStream(in);
    writable.readFields(dataIn);
    dataIn.close();
    return bytes;
  }
  public static void main(String[] args) throws IOException {
    @SuppressWarnings("unchecked")
    RawComparator <IntWritable> comparator = WritableComparator.get(IntWritable.class);
    IntWritable w1 = new IntWritable(163);
    IntWritable w2 = new IntWritable(67);
    byte[] b1 = serialize(w1);
    byte[] b2 = serialize(w2);
    System.out.println(b1);
    System.out.println(b2);
    System.out.println(comparator.compare(w1, w2));//WritableComparator的 compare()，w1>w2 -> 1;w1<w2 -> -1 ; w1=w2 -> 0
  System.out.println(comparator.compare(b1,0,b1.length,b2,0,b2.length));
  }
}

三，Hadoop 序列化框架

盡管大多數(shù)MapReduce程序使用Writable類型的key，value，但是不是所有MapReduce API 強制使用。事實上，可以使用任何類型，只要能有一種機制將每個類型進行類型與二進制的來回轉(zhuǎn)換。為此Hadoop提供了一個序列化框架來支持，他們在org.apache.hadoop.io.serializer包中，WritableSerialization類是對Writable類型的Serialization實現(xiàn)。
WritableSerialization類

public class WritableSerialization extends Configured implements Serialization<Writable> {...}

Serializer接口

定義了open()接口，序列化接口，close接口

public interface Serializer<T> {
  void open(OutputStream arg0) throws IOException;
  void serialize(T arg0) throws IOException;
  void close() throws IOException;
}

Deserializer接口

定義了open()接口，反序列化接口，close接口

public interface Deserializer<T> {
  void open(InputStream arg0) throws IOException;
  T deserialize(T arg0) throws IOException;
  void close() throws IOException;
}

Serialization接口

定義了一組接口，判斷是否支持輸入的類，根據(jù)輸入的類給出序列化接口和反序列化接口

public interface Serialization<T> {
  boolean accept(Class<?> arg0);
  Serializer<T> getSerializer(Class<T> arg0);
  Deserializer<T> getDeserializer(Class<T> arg0);
}

還有幾個接口，可以查看API文檔

盡管這可以方便我們在MapReduce使用Java類型，比如String，Integer。但是這還是不如Writable高效。

Hadoop中不使用java Object Serialization的原因

1，Java Object Serialization不夠精簡，就如本文前面提到的Java Object Serialization序列化后的字節(jié)流會包含許多信息，比如類名與對象等。

2，對象在序列化中只存引用，引用可以出現(xiàn)的位置很隨機，既可以在序列化的對象前，也可以在其后面，這樣就對隨機訪問和排序造成影響，一旦出錯，整個后面的序列化就會全部錯誤，Writable支持隨機訪問和排序。因為流中的記錄是彼此獨立的。

3，.Java序列化每次反序列化都要重新創(chuàng)建對象，內(nèi)存消耗大，而Writable是可以重用的。

以上所述是小編給大家介紹的Java Object Serialization與 Hadoop 序列化，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復(fù)大家的。在此也非常感謝大家對億速云網(wǎng)站的支持！

向AI問一下細(xì)節(jié)

深入淺析Java Object Serialization與 Hadoop 序列化

猜你喜歡

最新資訊

相關(guān)推薦

相關(guān)標(biāo)簽