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的下标号！