Hadoop中Writable類之三

1.BytesWritable

<1>定義

ByteWritable是對二進制數據組的封裝。它的序列化格式為一個用於指定后面數據字節數的整數域（4個字節），后跟字節本身。

舉個例子，假如有一個數組bytes，里面有兩個byte，bytes[0]=3，bytes[1]=5,那么，數組序列化后，其返回一個字節數組，序列化方面，可以查看我的博客《Hadoop序列化》  ，那么序列化后，其返回一個字節書組byteSeri,byteSeri里面有多少個字節?

分析：

在定義里指出，序列化格式為一個整數域和字節本身，

• 整數域是用來指定后面數據的字節數，我們知道byte[0],和byte[1]是兩個字節，所以，整數域的二進制為：00000000 00000000 00000000 00000010（4個字節），以16進制表示：00 00 00 02
• 字節本身就是byte[0]和byte[1]這兩個字節，所以，字節本身的二進制表示為：00000011 00000101，以16進制表示為：03 05
• 整個序列化數組的二進制表示為：00000000 00000000 00000000 00000010    00000011 00000101 ，以16進制表示為：00 00 00 02 03 05

那么上述的序列化后數組的長度為字節的個數，也就是 4 + 2 =6；拿例子來驗證：

Example:

package cn.roboson.writable;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.StringUtils;

/**
 * 1.定義一個二進制字節數組
 * 2.將其序列化
 * 3.由其序列化格式分析其內容
 * @author roboson
 *
 */

public class WritableText05 {
    
    public static void main(String[] args) throws IOException {
        //定義一個二進制字節數組
        BytesWritable b = new BytesWritable(new byte[]{3,5});
        
        //輸出其長度，很明顯，只有兩個字節，其長度肯定是2
        System.out.println("二進制數組的長度："+b.getLength());
        
        //將其序列化，序列化可以查看我的博客《Hadoop序列化》
        byte[] bytes=serialize(b);
        //在上面的分析中，16進制的輸出為：00 00 00 02 03 05
        System.out.println("序列化后以16進制表示："+StringUtils.byteToHexString(bytes));
        
        //在上面的分析中，序列化后的數組長度為：6
        System.out.println("序列化后的長度："+bytes.length);
    }
    
    public static byte[] serialize(Writable writable) throws IOException{
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut);
        return out.toByteArray();
        
    }
}

運行結果：

<2>可變性

和Text相似，BytesWritable是可變的，可以通過set()方法，設置進行修改。BytesWritable的getBytes()方法，返回的是字節數組的容量，而其存儲數據的實際大小，需要通過getLong()方法來查看

Example:

package cn.roboson.writable;

import org.apache.hadoop.io.BytesWritable;

public class WritableText06 {
    
    public static void main(String[] args) {
        BytesWritable b = new BytesWritable(new byte[]{3,5});
        System.out.println("字節數組的實際數據長度："+b.getLength());
        System.out.println("字節數組的容量大小："+b.getBytes().length);
        
        //改變其容量
        b.setCapacity(11);
        //getLength()方法，返回的是實際數據的大小
        System.out.println("改變容量后實際數據的大小："+b.getLength());
        //getBytes().length返回的是容量大小
        System.out.println("改變容量后容量的大小："+b.getBytes().length);
    }
}

 

運行結果：

 

 

2.NullWritable

NullWritable是Writable的一個特殊類型，它的序列化長度為0.它並不從數據流中讀取數據，也不寫入數據。它充當占位符；在MapReduce中，如果不需要使用健或者值，就可以將健或者值聲明為NullWritable——結果是存儲常量空值。

NullWritable是一個單例實例類型，可以通過靜態方法get()獲得其實例，public static NullWritable get() ;

Example:

package cn.roboson.writable;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Writable;
/**
 * 1.獲得一個NullWritable
 * 2.序列化后，查看其長度
 * @author roboson
 *
 */

public class Writable02 {
    
    public static void main(String[] args) throws IOException {
        
        NullWritable writable = NullWritable.get();
        byte[] bytes = serialize(writable);
        System.out.println("NullWritable序列化后的長度："+bytes.length);
    }
    
    public static byte[] serialize(Writable writable) throws IOException{
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut);
        return out.toByteArray();
        
    }
}

 

運行結果：

 

3.ObjectWritable

ObjectWritable是對Java基本類型（String、enum,Writable，null或這些類型組成的數組）的通用封裝。在Hadoop RPC中用於對方法的參數和返回類型進行封裝和解封裝。當一個字段中包含多個類型時，ObjectWritable是非常有用的，可以直接將類型聲明為ObjectWritable，但是，缺陷是非常浪費空間。舉個例子來看看，就知道有多么浪費！

Example:

package cn.roboson.writable;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.ObjectWritable;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.StringUtils;

/**
 * 1.新建一個ObjectWritable
 * 2.將其序列化並查看其大小
 * @author roboson
 *
 */
public class Writable03 {
    
    public static void main(String[] args) throws IOException {
        
        BytesWritable bytes = new BytesWritable(new byte[]{3,5});
        byte[] byte1 = serialize(bytes);
        //前面的介紹，可以知道，長度為6
        System.out.println("bytes數組序列化后的長度："+byte1.length);
        System.out.println("bytes數組序列化的16進制表示："+StringUtils.byteToHexString(byte1));
        
        ObjectWritable object = new ObjectWritable();
        object.set(new byte[]{3,5});
        byte[] byte2 = serialize(object);
        System.out.println("ObjectWritable序列化后的長度："+byte2.length);
        System.out.println("ObjectWritable列化的16進制表示："+StringUtils.byteToHexString(byte2));
    }
    
    public static byte[] serialize(Writable writable) throws IOException{
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut);
        return out.toByteArray();
        
    }
}

 

運行結果：

 

4.GenericWritable

通過上面的運行結果，已經知道ObjectWritable類是非常浪費空間的，如果封裝的類型數量比較少，這種情況下，可以用GenericWritable類來代替。它的效率更高一些。因為對序列化后的類型的引用加入位置索引。查看HadoopAPI幫助文檔，發現GenericWritable是一個抽象類：

 

那么如何使用它：

• 寫一個類，繼承自GenericWritable
• 重寫getTypes()方法
• 指定靜態類型數組中的值

Example:

MyGenericWritable.java

package cn.roboson.writable;

import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.GenericWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;

public class MyGenericWritable extends GenericWritable{

    private static Class[] CLASSES={
        Text.class,
        BytesWritable.class,
        IntWritable.class
    };
    @Override
    protected Class<? extends Writable>[] getTypes() {
        // TODO Auto-generated method stub
        return CLASSES;
    }

}

 

　　Writable04.java

package cn.roboson.writable;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import org.apache.hadoop.io.BytesWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.util.StringUtils;

public class Writable04 {
    
    public static void main(String[] args) throws IOException {
        
        Text t = new Text("Hadoop");
        byte[] byte0 = serialize(t);
        System.out.println("Text序列化后的長度："+byte0.length);
        System.out.println("Text序列化的16進制表示："+StringUtils.byteToHexString(byte0));
        
        MyGenericWritable genericText = new MyGenericWritable();
        genericText.set(t);
        byte[] byteText = serialize(genericText);
        System.out.println("TextGenericWritable序列化后的長度："+byteText.length);
        System.out.println("TextGenericWritable列化的16進制表示："+StringUtils.byteToHexString(byteText));
        
        BytesWritable bytes = new BytesWritable(new byte[]{3,5});
        byte[] byte1 = serialize(bytes);
        //前面的介紹，可以知道，長度為6
        System.out.println("bytes數組序列化后的長度："+byte1.length);
        System.out.println("bytes數組序列化的16進制表示："+StringUtils.byteToHexString(byte1));
        
        MyGenericWritable generic = new MyGenericWritable();
        generic.set(bytes);
        byte[] byteBytes = serialize(generic);
        System.out.println("GenericWritable序列化后的長度："+byteBytes.length);
        System.out.println("GenericWritable列化的16進制表示："+StringUtils.byteToHexString(byteBytes));
        

        IntWritable intWritable = new IntWritable(2);
        byte[] byte2 = serialize(intWritable);
        System.out.println("IntWritable序列化后的長度："+byte2.length);
        System.out.println("IntWritable序列化的16進制表示："+StringUtils.byteToHexString(byte2));
        
        MyGenericWritable genericInt = new MyGenericWritable();
        genericInt.set(intWritable);
        byte[] byteInt = serialize(genericInt);
        System.out.println("IntGenericWritable序列化后的長度："+byteInt.length);
        System.out.println("IntGenericWritable列化的16進制表示："+StringUtils.byteToHexString(byteInt));
        
    }
    public static byte[] serialize(Writable writable) throws IOException{
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        writable.write(dataOut);
        return out.toByteArray();
        
    }
}

 

運行結果：

 

 

可以發現，GenericWritable比ObjectWritable更節省空間，和本來的相比，只增加了一個字節，並且這個字節是其在靜態數組CLASSES的下標號！