轉自：http://my.oschina.net/tuzibuluo/blog?catalog=127826

1.Writable介面
Hadoop 並沒有使用 JAVA 的序列化，而是引入了自己實的序列化系統， package org.apache.hadoop.io 這個包中定義了大量的可序列化物件，這些物件都實現了 Writable 介面， Writable 介面是序列化物件的一個通用介面.我們來看下Writable 介面的定義。
public interface Writable{
void write(DataOutput out) throws IOException;
void readFields(DataInput in) throws IOException;
} Writable

介面抽象了兩個序列化的方法Write和ReadFields，分別對應了序列化和反序列化，引數DataOutPut 為java.io包內的IO類，Writable介面只是物件序列化的一個簡單宣告。

2.WriteCompareable介面
WriteCompareable介面是Wirtable介面的二次封裝，提供了compareTo(T o)方法，用於序列化物件的比較的比較。因為mapreduce中間有個基於key的排序階段。
public interface WritableComparable<T> extends Writable, Comparable<T> {
}下面是io包簡單的類圖關係。

3.RawComparator介面
hadoop為序列化提供了優化，型別的比較對M/R而言至關重要，Key和Key的比較也是在排序階段完成的，hadoop提供了原生的比較器介面RawComparator<T>用於序列化位元組間的比較，該介面允許其實現直接比較資料流中的記錄，無需反序列化為物件，RawComparator是一個原生的優化介面類，它只是簡單的提供了用於資料流中簡單的資料對比方法，從而提供優化：
public interface RawComparator<T> extends Comparator<T> {
public int compare(byte

[] b1, int s1, int l1, byte[] b2, int s2, int l2);
} 該介面並非被多數的衍生類所實現，其直接的子類為WritableComparator，多數情況下是作為實現Writable介面的類的內建類，提供序列化位元組的比較。下面是RawComparator介面內建類的實現類圖：

首先，我們看 RawComparator的直接實現類WritableComparator：

WritableComparator類似於一個登錄檔，裡面通過靜態map記錄了所有Comparators成員用一張Hash表記錄Key=Class，value=WritableComprator的註冊資訊.

WritableComparator主要提供了兩個功能

1.提供了對原始compare()方法的一個預設實現

預設實現是先反序列化為對像再通過對像比較（有開銷的問題）,所以一般都會被具體writeCompatable類的Comparator類覆蓋以加快效率。

publicint compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
    try {
      buffer.reset(b1, s1, l1);                   // parse key1
      key1.readFields(buffer);
      buffer.reset(b2, s2, l2);                   // parse key2
      key2.readFields(buffer);
    } catch (IOException e) {
  thrownew RuntimeException(e);
    }
    return compare(key1, key2);                   // compare them
}

2.充當RawComparable例項的工廠，以註冊Writable的實現

例如,為了獲取IntWritable的Comparator，可以直接呼叫其get方法。

4.WritableComparator類
接下來撿關鍵程式碼來分析writableComparator類，該類是RawComparator介面的直接子類。

程式碼1：registry 註冊器

// registry 註冊器：記載了WritableComparator類的集合

privatestaticcomparators = new HashMap<Class, WritableComparator>();

----------------------------------------------------------------

程式碼2：獲取WritableComparator例項

說明：hashMap作為容器類執行緒不安全，故需要synchronized同步，get方法根據key=Class返回對應的WritableComparator,若返回的是空值NUll，則呼叫protected Constructor進行構造，而其兩個protected的建構函式實則是呼叫了newKey()方法進行NewInstance

publicstatic synchronized WritableComparator get(Class<? extends WritableComparable> c) {
   WritableComparator comparator = comparators.get(c);if (comparator ==null)
     comparator =new WritableComparator(c, true);return comparator;
}
----------------------------------------------------------------
程式碼3：WritableComparator構造方法
new WritableComparator(c, true)
WritableComparator的建構函式原始碼如下：/*
   * keyClass,key1,key2和buffer都是用於WritableComparator的建構函式
   */private final Class<? extends WritableComparable> keyClass;
private final WritableComparable key1;  //WritableComparable介面private final WritableComparable key2;
private final DataInputBuffer buffer;      //輸入緩衝流protected WritableComparator(Class<? extends WritableComparable> keyClass,boolean createInstances) {
this.keyClass = keyClass;if (createInstances) {
      key1 = newKey();
      key2 = newKey();
      buffer =new DataInputBuffer();
    } else {
      key1 = key2 =null;
buffer =null;
    }
}
上述的keyClass，key1,key2,buffer是記錄HashMap對應的key值，用於WritableComparator的建構函式，但由其建構函式中我們可以看出WritableComparator根據Boolean createInstance來判斷是否例項化key1,key2和buffer,而key1,key2是用於接收比較的兩個key。在WritableComparator的建構函式裡面通過newKey()的方法去例項化實現WritableComparable介面的一個物件，下面是newKey（）的原始碼，通過hadoop自身的反射去例項化了一個WritableComparable介面物件。
public WritableComparable newKey() {return ReflectionUtils.newInstance(keyClass, null);
  }
----------------------------------------------------------------
程式碼4：Compare（）方法

（1）.public int compare(Object a, Object b)；

（2）.public int compare(WritableComparable a, WritableComparable b)；

（3）.public intbyte[] b1, int s1, int l1, byte[] b2, int s2, int l2)；

三個compare（）過載方法中，compare(Object a, Object b)利用子類塑形為WritableComparable而呼叫了第2個compare方法，而第2個Compare（）方法則呼叫了Writable.compaerTo();最後一個compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2)方法原始碼如下：
publicint compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {try {
      buffer.reset(b1, s1, l1);                   // parse key1
      key1.readFields(buffer);
      buffer.reset(b2, s2, l2);                   // parse key2
      key2.readFields(buffer);
    } catch (IOException e) {thrownew RuntimeException(e);
    }return compare(key1, key2);                   // compare them
  }

Compare方法的一個預設實現方式，根據介面key1,ke2反序列化為物件再進行比較。

利用Buffer為橋接中介，把位元組陣列儲存為buffer後，呼叫key1（WritableComparable）的反序列化方法，再來比較key1,ke2，由此處可以看出，該compare方法是將要比較的二進位制流反序列化為物件，再呼叫方法第2個過載方法進行比較。

----------------------------------------------------------------

程式碼5：方法define方法

該方法用於註冊WritebaleComparaor物件到登錄檔中，注意同時該方法也需要同步，程式碼如下：

public static synchronized void define(Class c, WritableComparator comparator) {
comparators.put(c, comparator);
}
----------------------------------------------------------------
程式碼6：餘下諸如readInt的靜態方法

這些方法用於實現WritableComparable的各種例項，例如 IntWritable例項：內部類Comparator類需要根據自己的IntWritable型別過載WritableComparator裡面的compare（）方法，可以說WritableComparator裡面的compare（）方法只是提供了一個預設的實現，而真正的compare（）方法實現需要根據自己的型別如IntWritable進行過載，所以WritableComparator方法中的那些readInt..等方法只是底層的封裝的一個實現，方便內部Comparator進行呼叫而已。

下面我們著重看下BooleanWritable類的內建RawCompartor<T>的實現過程:

public static class Comparator extends WritableComparator {
    public Comparator() {//呼叫父類的Constructor初始化keyClass=BooleanWrite.class
      super(BooleanWritable.class);
    }

    //重寫父類的序列化比較方法，用些類用到父類提供的預設方法
    public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
      boolean a = (readInt(b1, s1) == 1) ? true : false;
      boolean b = (readInt(b2, s2) == 1) ? true : false;
      return ((a == b) ? 0 : (a == false) ? -1 : 1);
    }
  }

  //註冊
  static {
    WritableComparator.define(BooleanWritable.class, new Comparator());
  }

總結：

hadoop 類似於Java的類包，即提供了Comparable介面（對應於writableComparable介面）和Comparator類（對應於RawComparator類）用於實現序列化的比較，在hadoop 的IO包中已經封裝了JAVA的基本資料型別用於序列化和反序列化，一般自己寫的類實現序列化和反序列化需要繼承WritableComparable介面並且內建一個Comparator（繼承於WritableComparator）的格式來實現自己的物件。

5.WritableFactory介面
作為工廠模式的WritableFactory，其抽象為一個介面，提供了具體的Writable物件建立例項的抽象方法newInstance()，程式碼如下:

publicinterface WritableFactory {

  /** Return a new instance. */
  Writable newInstance();
} WritableFactories類類似於WritableComparator類利用HashMap註冊記錄著所有實現上述介面的WritableFactory的集合，與之不同的是WritableFactories是一個單例模式，所有的方法都是靜態的。
關鍵程式碼：
//提供了一個key=class,value=WritableFactory的登錄檔
   private static final HashMap<Class, WritableFactory> CLASS_TO_FACTORY = new HashMap<Class, WritableFactory>();

  public static Writable newInstance(Class<? extends Writable> c, Configuration conf) {

    WritableFactory factory = WritableFactories.getFactory(c);
    if (factory != null) {
//該方法的newInstanceof是呼叫了factory.newInstance()即你了實現的WritableFactory的newInstance()方法
      Writable result = factory.newInstance();

if (result instanceof Configurable) {
        ((Configurable) result).setConf(conf);
      }
      return result;

} else {
      return ReflectionUtils.newInstance(c, conf);
    }
}

form序列化後轉jsonfunction arrayToJson(formArray){ var dataArray = {}; $.each(formArray,fun

[轉]java-小技巧-001-Long序列化到前端不支持

方式 .cn ria https a long tostring span per pre 調試接口，發現java Long序列化有問題，百度解決方式如下： 1、引入： jackson-mapper-asl-1.9.2.jar 2、導入： import org.code

Django跳轉，緩存，信號，序列化

哈哈前後端跳轉信號 ext 返回 path cookies 如果跳轉問題如果我現在停留在文章的詳情頁，用戶未登陸，如果你要評論，或者點贊就應該回到登陸頁面登陸如果登陸成功了，就要返回到當初跳轉過來的頁面第一種通過前後端傳送數據 $(‘.hit‘).click

Hadoop IO操作之序列化

數據 new 前言一個就是 clas 之間其中 ava 前言：為什麽Hadoop基本類型還要定義序列化？　　1、Hadoop在集群之間通信或者RPC調用時需要序列化，而且要求序列化要快，且體積要小，占用帶寬小。　　2、java的序列化機制占用大量計算開銷，且序列化