// Example IDL file for our monster's schema.
namespace MyGame.Sample;
enum Color:byte { Red = 0, Green, Blue = 2 }
union Equipment { Weapon } // Optionally add more tables.
struct Vec3 {
  x:float;
  y:float;
  z:float;
}
table Monster {
  pos:Vec3; // Struct.
  mana:short = 150;
  hp:short = 100;
  name:string;
  friendly:bool = false (deprecated);
  inventory:[ubyte];  // Vector of scalars.
  color:Color = Blue; // Enum.
  weapons:[Weapon];   // Vector of tables.
  equipped:Equipment; // Union.
}
table Weapon {
  name:string;
  damage:short;
}
root_type Monster;

flatc --java samples/monster.FlatBufferss

    private static void testFlatBuffers() {
    
    /*************************** 序列化 ************************/
    
    /**
     *  FlatBufferBuilder是FlatBuffers进行序列化和反序列化的关键类，这个类内部定义了各种数据类型进行序列化和反序列化的规则，
     *  并且封装了一系列数据结构序列化和反序列化时需要进行的操作。
     */
    FlatBufferBuilder builder = new FlatBufferBuilder();    

    // 创建一个字符串名称，返回的是字符串在底层ByteBuffer中的偏移
    int monsterName = builder.createString("软泥麦塔");     

    // 通过生成的Monster类存储一个数组信息，其实最终数据还是通过FlatBuilder来完成存储的
    byte[] treasure = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };     
    int inv = Monster.createInventoryVector(builder, treasure);     

    /**
     * 根据Weapon类封装的方法创建武器信息，之所以Weapon类要封装这个操作是因为Weapon要根据
     * schema对自身的定义写死一些常量，例如Weapon的成员个数以及各个成员的索引。
     */
    int weapon1Name = builder.createString("axe");
    short axeDamage = 50;
    int axe = Weapon.createWeapon(builder, weapon1Name, axeDamage);

    int weapon2Name = builder.createString("锈刀");
    short swordDamage = 100;
    int sword = Weapon.createWeapon(builder, weapon2Name, swordDamage);
    
    // Pass the `weaps` array into the `createWeaponsVector()` method to create a FlatBuffer vector.
    int[] weaps = new int[2];
    weaps[0] = sword;
    weaps[1] = axe;
    int weapons = Monster.createWeaponsVector(builder, weaps);
    
    /**
     * 上面的那些类型是不能内联存储到Monster中的，因为它们属于schema中的复杂类型，需要先单独使用FlatBuilder在底层的
     * ByteBuffer中存储，然后将各个类型的偏移保存起来构建Monster信息。
     */
    Monster.startMonster(builder);      // 准备构建Monster信息
    Monster.addName(builder, monsterName);  // 使用之前得到的偏移构建怪兽名称
    /**
     * Vec3是Struct类型，Struct类型是用来保存固定不变的数据的，一旦规定变不可更改（不能增加也不能减少），
     * 并且FlatBuffers为了提高数据访问效率，Struct的数据访问没有适用相对寻址，而是适用了直接寻址，因此它的数据只能内联存储。
     */
    int postion = Vec3.createVec3(builder, 1, 2, 3);    // vector必须要内联存储
    Monster.addPos(builder, postion);
    Monster.addColor(builder, Color.Blue);  // 简单数据也进行内联存储
    Monster.addHp(builder, (short) 700);
    Monster.addMana(builder, (short) 10);
    Monster.addInventory(builder, inv);
    Monster.addWeapons(builder, weapons);
    Monster.addEquippedType(builder, Equipment.Weapon);
    Monster.addEquipped(builder, axe);
    int rootMonster = Monster.endMonster(builder); // monster 构造结束

    builder.finish(rootMonster); // 所有数据写入完毕，写入FlatBuffers root_table的位置

    ByteBuffer data = builder.dataBuffer();     //得到底层存储二进制数据的ByteBuffer
    
    // 写入数据到文件
    File file = new File("flatbuffersFile.txt");
    FileOutputStream out = null;
    FileChannel channel = null;
    try {
        out = new FileOutputStream(file);
        channel = out.getChannel();
        while (data.hasRemaining()) {
            try {
                channel.write(data);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        try {
            if (null != out) {
                out.close();
            }
            
            if (null != channel) {
                channel.close();
            }
        } catch (Exception e2) {
        }
        
    }
    
    /*************************** 反序列化 ************************/
    
    // 从文件中读取数据
    FileInputStream fis = null;
    FileChannel readChannel = null;
    try {
        fis = new FileInputStream(file);
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        readChannel = fis.getChannel();
        int readbytes = 0;
        while ((readbytes = readChannel.read(byteBuffer)) != -1)  {
            System.out.println("读到 " + readbytes + " 个数据");
        }
        byteBuffer.flip();  // position回绕，准备从ByteBuffer中读取数据
        
        Monster monster = Monster.getRootAsMonster(byteBuffer);     // 找到root_table的位置，即数据的入口
        
        // 测试读取的数据是否和写入的数据一致。
        System.out.println("monster name: " + monster.name() + " hp: " + monster.hp());
    } catch (Exception e) {
        e.printStackTrace();
        try {
            if (null != readChannel) {
                readChannel.close();
            }
            if (null != fis) {
                fis.close();
            }
        } catch (Exception e2) {
            e2.printStackTrace();
        }
    }
}

  int monsterName = builder.createString("软泥麦塔");

/**
 * Encode the string `s` in the buffer using UTF-8.
 * 创建字符串，从左到右依次是字符串长度，字符串数据和结尾的0
 * @param s The string to encode.
 * @return The offset in the buffer where the encoded string starts.
 */
public int createString(String s) {
    byte[] utf8 = s.getBytes(utf8charset);
    addByte((byte) 0);                  // 以0结尾
    startVector(1, utf8.length, 1);     // 也是按照vector进行存储的,当做长度为utf8.length的vector
    bb.position(space -= utf8.length);  // 存储字符串，注意顺序
    bb.put(utf8, 0, utf8.length);       // 存储字符串
    return endVector();
}

/**
 * Add a `byte` to the buffer, properly aligned, and grows the buffer (if necessary).
 *
 * @param x A `byte` to put into the buffer.
 */
public void addByte(byte x) {
    prep(1, 0);
    putByte(x);
}

/**
 * Add a `byte` to the buffer, backwards from the current location. Doesn't align nor
 * check for space.
 *
 * @param x A `byte` to put into the buffer.
 */
public void putByte(byte x) {
    bb.put(space -= 1, x);
}

public void startVector(int elem_size, int num_elems, int alignment) {
    notNested();
    vector_num_elems = num_elems;
    prep(SIZEOF_INT, elem_size * num_elems);    // 初始化存储空间
    prep(alignment, elem_size * num_elems); // Just in case alignment > int.
    nested = true;
}

/**
 * Finish off the creation of an array and all its elements.  The array
 * must be created with {@link #startVector(int, int, int)}.<br>
 * 结束vector的创建，同时会将此vector的长度信息写入，同时返回当前vector相对于ByteBuffer的偏移
 * @return The offset at which the newly created array starts.<br>
 *     当前创建的vector相对于ByteBuffer结尾的偏移
 * @see #startVector(int, int, int)
 */
public int endVector() {
    if (!nested)
        throw new AssertionError("FlatBuffers: endVector called without startVector");
    nested = false;
    putInt(vector_num_elems);   // 保存vector的成员个数，不是存储空间长度
    return offset();    // 当前bytebuffer存放数据的长度
}

/**
 * Offset relative to the end of the buffer.<br>
 * 能够反映当前bytebuffer中存储数据的长度，也能表明当前对象相对于bytebuffer结尾的偏移
 * @return Offset relative to the end of the buffer.
 */
public int offset() {
    return bb.capacity() - space;
}

/**
 * Monster经过flatc编译后自动生成的代码
 */
public static void addName(FlatBufferBuilder builder, int nameOffset) {
    builder.addOffset(3, nameOffset, 0);
}

/**
 * Adds on offset, relative to where it will be written.
 * 计算并保存指定off偏移与当前table_data第i个成员数据字段之间的偏移，
 * 方便以后找到第i个成员的数据位置后能够根据这个值计算出真正第i个数据的存储位置
 * @param off The offset to add.<br>相对于整个ByteBuffer的偏移
 */
public void addOffset(int off) {
    prep(SIZEOF_INT, 0);  // Ensure alignment is already done.
    assert off <= offset();
    off = offset() - off + SIZEOF_INT; // 计算相对于当前写入位置的偏移
    putInt(off);
}

/**
 * Monster经过flatc编译后自动生成的代码
 */
public String name() {
    int o = __offset(10);	  // 得到vtable[10]相对于vatble_data[10]的偏移
    return o != 0 ? __string(o + bb_pos) : null;
}


/**
 * Create a Java `String` from UTF-8 data stored inside the FlatBuffer.
 * <p/>
 * This allocates a new string and converts to wide chars upon each access,
 * which is not very efficient. Instead, each FlatBuffer string also comes with an
 * accessor based on __vector_as_bytebuffer below, which is much more efficient,
 * assuming your Java program can handle UTF-8 data directly.
 *
 * @param offset An `int` index into the Table's ByteBuffer.<br>
 * @return Returns a `String` from the data stored inside the FlatBuffer at `offset`.
 */
protected String __string(int offset) {
    offset += bb.getInt(offset);  // 当前位置和当前位置写入的相对偏移相加得到真实数据的位置
    if (bb.hasArray()) {    // ByteBuffer底层是否由byte数组支持
        return new String(bb.array(), bb.arrayOffset() + offset + SIZEOF_INT, bb.getInt(offset),
                FlatBufferBuilder.utf8charset);
    } else {
        // We can't access .array(), since the ByteBuffer is read-only,
        // off-heap or a memory map
        ByteBuffer bb = this.bb.duplicate().order(ByteOrder.LITTLE_ENDIAN);
        // We're forced to make an extra copy:
        byte[] copy = new byte[bb.getInt(offset)];  // string第一个int表示字符串数组的长度，因此bb.getint(offset)就是string有效数据的长度
        bb.position(offset + SIZEOF_INT); // 要多偏移一个整型长度 ，以便跳过记录字符串的长度的数据，这样才能拷贝到真正的有效数据
        bb.get(copy);
        return new String(copy, 0, copy.length, FlatBufferBuilder.utf8charset); // 根据二进制构造字符串
    }
}

/**
 * All structs in the generated code derive from this class, and add their own accessors.
 */
public class Struct {
  /** Used to hold the position of the `bb` buffer. */
  protected int bb_pos;
  /** The underlying ByteBuffer to hold the data of the Struct. */
  protected ByteBuffer bb;
} 非常简单，只有两个成员变量，*bb*就是FlatBuffers用来存储数据的ByteBuffer，*bb_post*用来指明这个Struct对应的真实数在ByteBuffer中的绝对位置。这两个成员只描述了Struct最基本需求，至于Struct有几个成员变量，以及如何从底层ByteBuffer中解析Struct中的各个对象则留给了Struct的子类来实现。例如，我们可以看看Vec3的实现：

public final class Vec3 extends Struct {
    public Vec3 __init(int _i, ByteBuffer _bb) {
        bb_pos = _i;
        bb = _bb;
        return this;
    }

    public float x() {
        return bb.getFloat(bb_pos + 0);
    }

    public float y() {
        return bb.getFloat(bb_pos + 4);
    }

    public float z() {
        return bb.getFloat(bb_pos + 8);
    }

    public static int createVec3(FlatBufferBuilder builder, float x, float y, float z) {
        builder.prep(4, 12);  // 准备，进行对齐及ByteBuffer长度不够时进行自动增长
        builder.putFloat(z);
        builder.putFloat(y);
        builder.putFloat(x);
        return builder.offset();
    }
};

union Equipment { Weapon }

public final class Equipment {
  private Equipment() { }
  public static final byte NONE = 0;
  public static final byte Weapon = 1;

  private static final String[] names = { "NONE", "Weapon", };

  public static String name(int e) { return names[e]; }
};	

public byte equippedType() {
    int o = __offset(20);
    return o != 0 ? bb.get(o + bb_pos) : 0;
}

public Table equipped(Table obj) {
    int o = __offset(22);
    return o != 0 ? __union(obj, o) : null;
}

public static void addEquippedType(FlatBufferBuilder builder, byte equippedType) {
    builder.addByte(8, equippedType, 0);
}

public static void addEquipped(FlatBufferBuilder builder, int equippedOffset) {
    builder.addOffset(9, equippedOffset, 0);
}

public final class Color {
  private Color() { }
  public static final byte Red = 0;
  public static final byte Green = 1;
  public static final byte Blue = 2;

  private static final String[] names = { "Red", "Green", "Blue", };

  public static String name(int e) { return names[e]; }
};

public static void addColor(FlatBufferBuilder builder, byte color) {
    builder.addByte(6, color, 2);
}

public byte color() {
    int o = __offset(16);
    return o != 0 ? bb.get(o + bb_pos) : 2;  // 默认颜色为Blue，因此没有存储颜色的时候使用2
}

/********** Monster.java **********/

public static void addWeapons(FlatBufferBuilder builder, int weaponsOffset) {
    builder.addOffset(7, weaponsOffset, 0);
}

public static int createWeaponsVector(FlatBufferBuilder builder, int[] data) {
    builder.startVector(4, data.length, 4);
    for (int i = data.length - 1; i >= 0; i--) {
        /** 
         * 由于weapon属于复杂类型，因此这里用addOffset记录成员变量，如果只是简单类型的vector，
         * flatc处理的时候会自动调用addInt等方法来记录简单数据，而不用进行相对寻址了。
         */
        builder.addOffset(data[i]);     
    }
    return builder.endVector();
}

public static void startWeaponsVector(FlatBufferBuilder builder, int numElems) {
    builder.startVector(4, numElems, 4);
}


public Weapon weapons(int j) {
    return weapons(new Weapon(), j);
}

public Weapon weapons(Weapon obj, int j) {
    int o = __offset(18);
    // 由于weapon vector成员记录的是各个weapon数据的存储地址相对成员数据写入位置的相对偏移，因此还要通过__indirect进行一次相对寻址
    return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null;
}

public int weaponsLength() {
    int o = __offset(18);
    return o != 0 ? __vector_len(o) : 0;
}

/*********** Table.java ***********/

/**
 * Look up a field in the vtable.<br>
 * 得到vtable中记录的第vtable_index个成员的值（是相应成员在数据字段中的偏移）
 * @param vtable_index An `int` offset to the vtable in the Table's ByteBuffer.
 * @return Returns an offset into the object, or `0` if the field is not present.
 *          得到vtable_offset指定的table成员相对table data中的位置
 */
protected int __offset(int vtable_index) {
    int vtable = bb_pos - bb.getInt(bb_pos);    // bb_pos得到的是table的data字段相对于vtable的偏移，因此这种方法得到的是vatable的位置
    return vtable_index < bb.getShort(vtable) ? bb.getShort(vtable + vtable_index) : 0;   // 因为vtable_offset是相对于vtable的偏移，因此vtable_offset < bb.getShort(vtable)可以防止偏移越界
}

/**
 * Retrieve a relative offset.<br>
 * 进行一次相对寻址
 * @param offset An `int` index into the Table's ByteBuffer containing the relative offset.
 * @return Returns the relative offset stored at `offset`.
 */
protected int __indirect(int offset) {
    return offset + bb.getInt(offset);
}

/**
 * Get the length of a vector.
 *
 * @param offset An `int` index into the Table's ByteBuffer.
 * @return Returns the length of the vector whose offset is stored at `offset`.
 */
protected int __vector_len(int offset) {
    offset += bb_pos;  // 加上byteBuffer数据段在Table中的偏移。
    offset += bb.getInt(offset);  // ByteBuffer中数据段的偏移
    return bb.getInt(offset); // 得到数据段中表明有效数据长度的值
}

/**
 * Get the start data of a vector.<br>
 * 得到vector中有效数据相对于整个ByteBuffer的偏移
 *
 * @param offset An `int` index into the Table's ByteBuffer.
 * @return Returns the start of the vector data whose offset is stored at `offset`.
 */
protected int __vector(int offset) {
    offset += bb_pos;   // 得到Table中第offset个成员的地址
    return offset + bb.getInt(offset) + SIZEOF_INT;  // data starts after the length，相对寻址，得到vector数据的真正地址
}


/*************** FlatBuilder.java ***********/

public void startVector(int elem_size, int num_elems, int alignment) {
    notNested();
    vector_num_elems = num_elems;
    prep(SIZEOF_INT, elem_size * num_elems);    // 初始化存储空间
    prep(alignment, elem_size * num_elems); // Just in case alignment > int.
    nested = true;
}

/**
 * Finish off the creation of an array and all its elements.  The array
 * must be created with {@link #startVector(int, int, int)}.<br>
 * 结束vector的创建，同时会将此vector的长度信息写入，同时返回当前vector相对于ByteBuffer的偏移
 * @return The offset at which the newly created array starts.<br>
 *     当前创建的vector相对于ByteBuffer结尾的偏移
 * @see #startVector(int, int, int)
 */
public int endVector() {
    if (!nested)
        throw new AssertionError("FlatBuffers: endVector called without startVector");
    nested = false;
    putInt(vector_num_elems);   // 保存vector的成员个数，不是存储空间长度，除非vector是以byte为单位保存
    return offset();    // 当前bytebuffer存放数据的长度
}

/********** Monster.java *************/

public static void startMonster(FlatBufferBuilder builder) {
    builder.startObject(10);
}


/********* FlatBuilders.java ********/

public void startObject(int numfields) {
    notNested();
    if (vtable == null || vtable.length < numfields)
        vtable = new int[numfields];
    vtable_in_use = numfields;
    Arrays.fill(vtable, 0, vtable_in_use, 0);
    nested = true;
    object_start = offset();
}

/********* Monster.java ********/
public static void addMana(FlatBufferBuilder builder, short mana) {
    builder.addShort(1, mana, 150);
}

public short mana() {
    int o = __offset(6);
    return o != 0 ? bb.getShort(o + bb_pos) : 150;
}

public static void addName(FlatBufferBuilder builder, int nameOffset) {
    builder.addOffset(3, nameOffset, 0);
}

public String name() {
    int o = __offset(10);
    return o != 0 ? __string(o + bb_pos) : null;
}

/******** FlatBuilder.java *********/

/**
 * Add a `short` to the buffer, properly aligned, and grows the buffer (if necessary).
 *
 * @param x A `short` to put into the buffer.
 */
public void addShort(short x) {
    prep(2, 0);
    putShort(x);
}

/**
 * Add a `short` to the buffer, backwards from the current location. Doesn't align nor
 * check for space.
 *
 * @param x A `short` to put into the buffer.
 */
public void putShort(short x) {
    bb.putShort(space -= 2, x);
}

/**
 * Adds on offset, relative to where it will be written.<br>
 * 写入相对偏移信息，相对的是当前写入位置的偏移。
 * @param off The offset to add.<br>相对于整个ByteBuffer的偏移
 */
public void addOffset(int off) {
    prep(SIZEOF_INT, 0);  // Ensure alignment is already done.
    assert off <= offset();
    off = offset() - off + SIZEOF_INT;  // 相对寻址，得到的是相对于当前写入位置的偏移
    putInt(off);
}

/**
 * Add an `int` to the buffer, backwards from the current location. Doesn't align nor
 * check for space.
 *
 * @param x An `int` to put into the buffer.
 */
public void putInt(int x) {
    bb.putInt(space -= 4, x);
}

protected String __string(int offset) {
    offset += bb.getInt(offset);  // 相对寻址
    if (bb.hasArray()) {    // ByteBuffer底层是否由byte数组支持
        return new String(bb.array(), bb.arrayOffset() + offset + SIZEOF_INT, bb.getInt(offset),
                FlatBufferBuilder.utf8charset);
    } else {
        // We can't access .array(), since the ByteBuffer is read-only,
        // off-heap or a memory map
        ByteBuffer bb = this.bb.duplicate().order(ByteOrder.LITTLE_ENDIAN);
        // We're forced to make an extra copy:
        byte[] copy = new byte[bb.getInt(offset)];  // offset加上了偏移，因此bb.getint(offset)就是bytebuffer有效数据的长度
        bb.position(offset + SIZEOF_INT); // 要多加一个代表有效数据长度的偏移，这样才能拷贝到真正的有效数据
        bb.get(copy);
        return new String(copy, 0, copy.length, FlatBufferBuilder.utf8charset);
    }
}

/******** Monster.java ********/

public static int endMonster(FlatBufferBuilder builder) {
    int o = builder.endObject();
    return o;
}

/**
 * Finish off writing the object that is under construction.
 *
 * @return The offset to the object inside {@link #dataBuffer()}.
 * @see #startObject(int)
 */
public int endObject() {
    if (vtable == null || !nested)
        throw new AssertionError("FlatBuffers: endObject called without startObject");

    addInt(0);  // 中间间隔4个字节 用来记录vatable相对于table_data的结尾位置的偏移   ---> tag 2

    //----------- 记录vatable信息到bytebuffer START ------------

    int vtableloc = offset();
    // Write out the current vtable.
    for (int i = vtable_in_use - 1; i >= 0; i--) {  // 从后向前依次记录成员vtable的成员偏移到bytebuffer中
        // Offset relative to the start of the table.
        /**
         * 注意这里的相对偏移的计算：
         * vtableloc = capacity - vtablePos;   // table_data相对于bytebuffer结尾的偏移
         * vtable[i] = capacity -  tableDataPos_i;   // table数据段中第i个字段相对于bytebuffer结尾的偏移
         * 那么第i个字段相对于table_data的偏移计算为：
         * offset = vtableloc - vtable[i] = tableDataPos_i - vtablePos;
         *  那么在之后知道table_data相对于bytebuffer偏移的情况下，要得到这个成员记录的偏移就直接可以用：
         *
         * vtablePos + offset = tableDataPos_i;
         *
         * 参见 ：{@link Table#__offset(int)}
         */

        short off = (short) (vtable[i] != 0 ? vtableloc - vtable[i] : 0);   // 得到成员数据在table_data中的写入位置相对于table_data的偏移

        addShort(off);
    }

    final int standard_fields = 2; // The fields below: 因为后面还要写两个字段，因此这里是2
    addShort((short) (vtableloc - object_start));   // 再写入整个 table_data的长度
    addShort((short) ((vtable_in_use + standard_fields) * SIZEOF_SHORT));   // vtable 的长度   ---> tag 1

    //----------- 记录vatable信息到bytebuffer END   ------------

    // Search for an existing vtable that matches the current one.
    int existing_vtable = 0;
    outer_loop:
    for (int i = 0; i < num_vtables; i++) {
        int vt1 = bb.capacity() - vtables[i];       // vtables记录的是每个vtable的偏移
        int vt2 = space;    // 因为刚才才存储了一个vtable数据到bytebuffer，因此这里space就指向当前的vatable
        short len = bb.getShort(vt1);   // vtable的第一个short字段记录的就是该vatable的长度（见上面注释的tag 1）
        if (len == bb.getShort(vt2)) {
            for (int j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT) {
                if (bb.getShort(vt1 + j) != bb.getShort(vt2 + j)) {
                    continue outer_loop;
                }
            }
            existing_vtable = vtables[i];
            break outer_loop;
        }
    }

    if (existing_vtable != 0) {     // 存在和当前vtable一样的vatable
        // Found a match:
        // Remove the current vtable.
        space = bb.capacity() - vtableloc;  // 移动space到table_data的结尾
        // Point table to existing vtable.
        bb.putInt(space, existing_vtable - vtableloc);  // 记录当前table_data对应的vtable的位置（见 tag 2注释)
    } else {
        // No match:
        // Add the location of the current vtable to the list of vtables.
        if (num_vtables == vtables.length)
            vtables = Arrays.copyOf(vtables, num_vtables * 2);  // 扩容
        vtables[num_vtables++] = offset();  // 记录当前vtable
        // Point table to current vtable.
        bb.putInt(bb.capacity() - vtableloc, offset() - vtableloc); // 记录vatable相对于table的偏移位置
    }

    nested = false;
    return vtableloc;  // 注意返回的是table_data的偏移，不是vtable的偏移
}

/**
 * Finalize a buffer, pointing to the given `root_table`.
 *
 * @param root_table An offset to be added to the buffer.
 */
public void finish(int root_table) {
    prep(minalign, SIZEOF_INT);
    addOffset(root_table);  // 写入root_table的table_data的偏移
    bb.position(space);     // 修改bytebuffer的指针位置，以指明ByteBuffer中的有效数据的开端
    finished = true;
}

public static Monster getRootAsMonster(ByteBuffer _bb) {
    return getRootAsMonster(_bb, new Monster());
}

public static Monster getRootAsMonster(ByteBuffer _bb, Monster obj) {
    _bb.order(ByteOrder.LITTLE_ENDIAN);
    return (obj.__init(_bb.getInt(_bb.position()) + _bb.position(), _bb));  // _bb.getInt(_bb.position()) + _bb.position()得到的就是table_data在bytebuffer中的position
}

public Monster __init(int _i, ByteBuffer _bb) {
    bb_pos = _i;
    bb = _bb;
    return this;
} 请注意，上面的代码中*_bb.getInt(_bb.position())+_bb.position()*得到的就是table_data的偏移，因为*FlatBuilder.endObject()*返回的是table_data的偏移，*FlatBuilder.finish()*又将这个偏移计算成了相对偏移并记录。因此Table中的bb_pos就是这个Table中的table_data字段在ByteBuffer中的偏移地址。 到这里基本上就将FlatBuffers中的Table讲解完毕了，只剩下最后一个小的细节，那就是：*对于简单数据，如果指定写入的数据和默认值相同，FlatBuffers是不会将此数据写入到底层ByteBuffer中的*，这又是FlatBuffers节省数据长度的一个优化。大家可以从下面的代码看到这个特点：

/******* Monster.java *********/

public static void addHp(FlatBufferBuilder builder, short hp) {
    builder.addShort(2, hp, 100);
}

public short hp() {
    int o = __offset(8);
    return o != 0 ? bb.getShort(o + bb_pos) : 100;
}

/******** FlatBuilder.java ********/
/**
 * Add a `short` to a table at `o` into its vtable, with value `x` and default `d`.
 *
 * @param o The index into the vtable.
 * @param x A `short` to put into the buffer, depending on how defaults are handled. If
 *          `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
 *          default value, it can be skipped.
 * @param d A `short` default value to compare against when `force_defaults` is `false`.
 */
public void addShort(int o, short x, int d) {
    if (force_defaults || x != d) {
        addShort(x);
        slot(o);
    }
}

/**
 * Set the current vtable at `voffset` to the current location in the buffer.<br>
 * 使vtable的第vtableIndex记录当前bytebuffer的偏移。一般用于vtable记录table中字段的位置
 *
 * @param vtableIndex The index into the vtable to store the offset relative to the end of the
 *                buffer.<br>
 *                table中成员的索引
 */
public void slot(int vtableIndex) {
    vtable[vtableIndex] = offset();
}