hadoop AbstractMapWritable及其實現類是怎樣的

hadoop AbstractMapWritable及其實現類是怎樣的，很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

     AbstractMapWritable作為抽象的Map容器Writable類型，主要是為其實現類MapWritable和SortedMapWritable提供出一套索引表的結構，如下：

Map<Class, Byte> classToIdMap = new ConcurrentHashMap<Class, Byte>()     //id到Class的映射表
Map<Byte, Class> idToClassMap = new ConcurrentHashMap<Byte, Class>()，   //class到Id的映射表

索引表需要添加新的class對象和Id映射關系，勢必需要一個新的Id變量，class對象則作為方法形參，如下

 private volatile byte newClasses = 0;

有了上面的數據結構，則需要增加一些數據的操作方法，既然AbstractMapWritable基本的數據結構是關于索引表的，自然的會有索引的添加

private synchronized void addToMap(Class clazz, byte id) {
  //主要實現功能為對索引id通過兩個索引表操作是否存在已存在，索引Id存在但不為形參id則拋異常，否則加入索引信息
}
protected synchronized void addToMap(Class clazz) {
   //不存在索引id,且當前索引變量newClasses<127則自動加入索引信息 
  if (classToIdMap.containsKey(clazz)) {
      return;
    }
    if (newClasses + 1 > Byte.MAX_VALUE) {
      throw new IndexOutOfBoundsException("adding an additional class would" +
      " exceed the maximum number allowed");
    }
    byte id = ++newClasses;
    addToMap(clazz, id);
}

 AbstractMapWritable提供了一個受保護的構造函數

  protected AbstractMapWritable() {
    this.conf = new AtomicReference<Configuration>();
    
    //添加基礎序列化類型的索引信息，索引表能表示的范圍只有-127~128種類型
    addToMap(ArrayWritable.class,
        Byte.valueOf(Integer.valueOf(-127).byteValue())); 
    addToMap(BooleanWritable.class,
        Byte.valueOf(Integer.valueOf(-126).byteValue()));
    addToMap(BytesWritable.class,
        Byte.valueOf(Integer.valueOf(-125).byteValue()));
    addToMap(FloatWritable.class,
        Byte.valueOf(Integer.valueOf(-124).byteValue()));
    addToMap(IntWritable.class,
        Byte.valueOf(Integer.valueOf(-123).byteValue()));
    addToMap(LongWritable.class,
        Byte.valueOf(Integer.valueOf(-122).byteValue()));
    addToMap(MapWritable.class,
        Byte.valueOf(Integer.valueOf(-121).byteValue()));
    addToMap(MD5Hash.class,
        Byte.valueOf(Integer.valueOf(-120).byteValue()));
    addToMap(NullWritable.class,
        Byte.valueOf(Integer.valueOf(-119).byteValue()));
    addToMap(ObjectWritable.class,
        Byte.valueOf(Integer.valueOf(-118).byteValue()));
    addToMap(SortedMapWritable.class,
        Byte.valueOf(Integer.valueOf(-117).byteValue()));
    addToMap(Text.class,
        Byte.valueOf(Integer.valueOf(-116).byteValue()));
    addToMap(TwoDArrayWritable.class,
        Byte.valueOf(Integer.valueOf(-115).byteValue()));
    
    // UTF8 is deprecated so we don't support it

    addToMap(VIntWritable.class,
        Byte.valueOf(Integer.valueOf(-114).byteValue()));
    addToMap(VLongWritable.class,
        Byte.valueOf(Integer.valueOf(-113).byteValue()));
}

緊接著的是序列化和反序列化方法

序列化：將索引信息寫流中

//序列化方法首先寫入的是當前索引變量newClasses，然后依次從索引Id范圍[1,newClasss]依次寫入索引Id+類名的組合
public void write(DataOutput out) throws IOException {
    
    // First write out the size of the class table and any classes that are
    // "unknown" classes
    //寫入索引ID
    out.writeByte(newClasses);
    /*
    **不明白為什么只是寫入部分[1~newClasses]的索引信息，而非[-127~newClasses的索引信息]，
    **猜想可能與子類覆蓋其受保護的構造函數有關，因為newClasses默認初始為0
    **/
    for (byte i = 1; i <= newClasses; i++) {
      out.writeByte(i);
      out.writeUTF(getClass(i).getName());
    }
  }

反序列化：從流中構造出索引信息

  //主要是根據序列化的結構從流中構造索引信息
  public void readFields(DataInput in) throws IOException {
    
    // Get the number of "unknown" classes
    
    newClasses = in.readByte();
    
    // Then read in the class names and add them to our tables
    
    for (int i = 0; i < newClasses; i++) {
      byte id = in.readByte();
      String className = in.readUTF();
      try {
      //索引信息構造
        addToMap(Class.forName(className), id);
        
      } catch (ClassNotFoundException e) {
        throw new IOException("can't find class: " + className + " because "+
            e.getMessage());
      }
    }
  }

AbstractMapWritable作為MapWritable抽象類并沒有涉及到Map<Wirtable,Writable>的鍵值對操作，而是從抽象層抽象出索引表，其實現類MapWritable和SortedMapWritable則是新增了Map<Wirtable,Writable>變量，不同的之處在于SortedMapWritable是實現了排序了的TreeMap，自身已具有排序功能。

 //MapWritable構造函數
 public MapWritable() {
    super();
    this.instance = new HashMap<Writable, Writable>();
  }
  //SortedMapWritable構造函數
  public SortedMapWritable() {
    super();
    this.instance = new TreeMap<WritableComparable, Writable>();
  }

對于新增的成員Map<Wirtable,Writable>自然需要具備一些方法，基本上跟java的map（這里需要維護索引表）方法無異，但對于序列化和反序列化則是在其抽象類的基礎上擴展，具體如下

序列化：先調用AbstractMapWritable的序列化方法,在對Map<Wirtable,Writable>的容量序列化，接著對key和value一一序列化

//MapWritable的序列化方法
public void write(DataOutput out) throws IOException {
    super.write(out);
    
    // Write out the number of entries in the map
    
    out.writeInt(instance.size());

    // Then write out each key/value pair
    
    for (Map.Entry<Writable, Writable> e: instance.entrySet()) {
      out.writeByte(getId(e.getKey().getClass()));
      e.getKey().write(out);
      out.writeByte(getId(e.getValue().getClass()));
      e.getValue().write(out);
    }
  }

反序列化：則按照上訴的結構從流中構造出索引表和Writable對象。

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。