解析常量池信息时需要先解析出常量池对象的数量，然后遍历常量池，解析cp_info对象。

    1. u2 constant_pool_count;
    2. cp_info constant_pool[constant_pool_count-1];

    为了便于理解解析过程，特意将常量池解析流程单独拆开成如下几步：

    1. 读取常量池数量（u2 constant_pool_count;）；
    2. 读取tag；
    3. 根据不同的tag类型解析常量池对象；
    4. 解析常量池中的对象；
    5. 链接常量池中的索引引用；

    常量池解析片段：

    1. /**
    2.  * 解析常量池数据
    3.  *
    4.  * @throws IOException 数据读取异常
    5.  */
    6. private void parseConstantPool() throws IOException {
    7.     // u2 constant_pool_count;
    8.     this.poolCount = dis.readUnsignedShort();
    10.     // cp_info constant_pool[constant_pool_count-1];
    11.     for (int i = 1; i <= poolCount - 1; i++) {
    12.         //      cp_info {
    13.         //        u1 tag;
    14.         //        u1 info[];
    15.         //      }
    16.         int      tag      = dis.readUnsignedByte();
    17.         Constant constant = Constant.getConstant(tag);
    19.         if (constant == null) {
    20.             throw new RuntimeException("解析常量池异常，无法识别的常量池类型：" + tag);
    21.         }
    23.         // 解析常量池对象
    24.         parseConstantItems(constant, i);
    26.         // Long和Double是宽类型，占两位
    27.         if (CONSTANT_LONG == constant || CONSTANT_DOUBLE == constant) {
    28.             i++;
    29.         }
    30.     }
    32.     // 链接常量池中的引用
    33.     linkConstantPool();
    34. }

    解析常量池对象代码片段：

    1. /**
    2.    * 解析常量池中的对象
    3.    *
    4.    * @param constant 常量池
    5.    * @param index    常量池中的索引位置
    6.    * @throws IOException 数据读取异常
    7.    */
    8. private void parseConstantItems(Constant constant, int index) throws IOException {
    9.     Map<String, Object> map = new LinkedHashMap<>();
    11.     switch (constant) {
    12.         case CONSTANT_UTF8:
    13.           //          CONSTANT_Utf8_info {
    14.           //            u1 tag;
    15.           //            u2 length;
    16.           //            u1 bytes[length];
    17.           //          }
    19.           int length = dis.readUnsignedShort();
    20.           byte[] bytes = new byte[length];
    21.           dis.read(bytes);
    23.           map.put("tag", CONSTANT_UTF8);
    24.           map.put("value", new String(bytes, UTF_8));
    25.           break;
    26.         case CONSTANT_INTEGER:
    27.           //          CONSTANT_Integer_info {
    28.           //            u1 tag;
    29.           //            u4 bytes;
    30.           //          }
    32.           map.put("tag", CONSTANT_INTEGER);
    33.           map.put("value", dis.readInt());
    34.           break;
    35.         case CONSTANT_FLOAT:
    36.           //          CONSTANT_Float_info {
    37.           //            u1 tag;
    38.           //            u4 bytes;
    39.           //          }
    41.           map.put("tag", CONSTANT_FLOAT);
    42.           map.put("value", dis.readFloat());
    43.           break;
    44.         case CONSTANT_LONG:
    45.           //          CONSTANT_Long_info {
    46.           //            u1 tag;
    47.           //            u4 high_bytes;
    48.           //            u4 low_bytes;
    49.           //          }
    51.           map.put("tag", CONSTANT_LONG);
    52.           map.put("value", dis.readLong());
    53.           break;
    54.         case CONSTANT_DOUBLE:
    55.           //          CONSTANT_Double_info {
    56.           //            u1 tag;
    57.           //            u4 high_bytes;
    58.           //            u4 low_bytes;
    59.           //          }
    61.           map.put("tag", CONSTANT_DOUBLE);
    62.           map.put("value", dis.readDouble());
    63.           break;
    64.         case CONSTANT_CLASS:
    65.           //          CONSTANT_Class_info {
    66.           //            u1 tag;
    67.           //            u2 name_index;
    68.           //          }
    70.           map.put("tag", CONSTANT_CLASS);
    71.           map.put("nameIndex", dis.readUnsignedShort());
    72.           break;
    73.         case CONSTANT_STRING:
    74.           //          CONSTANT_String_info {
    75.           //            u1 tag;
    76.           //            u2 string_index;
    77.           //          }
    79.           map.put("tag", CONSTANT_STRING);
    80.           map.put("stringIndex", dis.readUnsignedShort());
    81.           break;
    82.         case CONSTANT_FIELD_REF:
    83.           //          CONSTANT_Fieldref_info {
    84.           //            u1 tag;
    85.           //            u2 class_index;
    86.           //            u2 name_and_type_index;
    87.           //          }
    89.           map.put("tag", CONSTANT_FIELD_REF);
    90.           map.put("classIndex", dis.readUnsignedShort());
    91.           map.put("nameAndTypeIndex", dis.readUnsignedShort());
    92.           break;
    93.         case CONSTANT_METHOD_REF:
    94.           //          CONSTANT_Methodref_info {
    95.           //            u1 tag;
    96.           //            u2 class_index;
    97.           //            u2 name_and_type_index;
    98.           //          }
    100.           map.put("tag", CONSTANT_METHOD_REF);
    101.           map.put("classIndex", dis.readUnsignedShort());
    102.           map.put("nameAndTypeIndex", dis.readUnsignedShort());
    103.           break;
    104.         case CONSTANT_INTERFACE_METHOD_REF:
    105.           //          CONSTANT_InterfaceMethodref_info {
    106.           //            u1 tag;
    107.           //            u2 class_index;
    108.           //            u2 name_and_type_index;
    109.           //          }
    111.           map.put("tag", CONSTANT_INTERFACE_METHOD_REF);
    112.           map.put("classIndex", dis.readUnsignedShort());
    113.           map.put("nameAndTypeIndex", dis.readUnsignedShort());
    114.           break;
    115.         case CONSTANT_NAME_AND_TYPE:
    116.           //          CONSTANT_NameAndType_info {
    117.           //            u1 tag;
    118.           //            u2 name_index;
    119.           //            u2 descriptor_index;
    120.           //          }
    122.           map.put("tag", CONSTANT_NAME_AND_TYPE);
    123.           map.put("nameIndex", dis.readUnsignedShort());
    124.           map.put("descriptorIndex", dis.readUnsignedShort());
    125.           break;
    126.         case CONSTANT_METHOD_HANDLE:
    127.           //          CONSTANT_MethodHandle_info {
    128.           //            u1 tag;
    129.           //            u1 reference_kind;
    130.           //            u2 reference_index;
    131.           //          }
    133.           map.put("tag", CONSTANT_METHOD_HANDLE);
    134.           map.put("referenceKind", dis.readUnsignedByte());
    135.           map.put("referenceIndex", dis.readUnsignedShort());
    136.           break;
    137.         case CONSTANT_METHOD_TYPE:
    138.           //          CONSTANT_MethodType_info {
    139.           //            u1 tag;
    140.           //            u2 descriptor_index;
    141.           //          }
    143.           map.put("tag", CONSTANT_METHOD_TYPE);
    144.           map.put("descriptorIndex", dis.readUnsignedShort());
    145.           break;
    146.         case CONSTANT_DYNAMIC:
    147.           //          CONSTANT_Dynamic_info {
    148.           //            u1 tag;
    149.           //            u2 bootstrap_method_attr_index;
    150.           //            u2 name_and_type_index;
    151.           //          }
    153.           map.put("tag", CONSTANT_DYNAMIC);
    154.           map.put("bootstrapMethodAttrIdx", dis.readUnsignedShort());
    155.           map.put("nameAndTypeIndex", dis.readUnsignedShort());
    156.           break;
    157.         case CONSTANT_INVOKE_DYNAMIC:
    158.           //          CONSTANT_InvokeDynamic_info {
    159.           //            u1 tag;
    160.           //            u2 bootstrap_method_attr_index;
    161.           //            u2 name_and_type_index;
    162.           //          }
    164.           map.put("tag", CONSTANT_INVOKE_DYNAMIC);
    165.           map.put("bootstrapMethodAttrIdx", dis.readUnsignedShort());
    166.           map.put("nameAndTypeIndex", dis.readUnsignedShort());
    167.           break;
    168.         case CONSTANT_MODULE:
    169.           //          CONSTANT_Module_info {
    170.           //            u1 tag;
    171.           //            u2 name_index;
    172.           //          }
    174.           map.put("tag", CONSTANT_MODULE);
    175.           map.put("nameIndex", dis.readUnsignedShort());
    176.           break;
    177.         case CONSTANT_PACKAGE:
    178.           //          CONSTANT_Package_info {
    179.           //            u1 tag;
    180.           //            u2 name_index;
    181.           //          }
    183.           map.put("tag", CONSTANT_PACKAGE);
    184.           map.put("nameIndex", dis.readUnsignedShort());
    185.           break;
    186.     }
    188.     constantPoolMap.put(index, map);
    189. }

    解析完常量池的对象后会发现很多数据结构中都引用了其他对象，比如ID（索引位置）为1的常量池对象CONSTANT_METHOD_REF引用了ID为21的CONSTANT_CLASS对象和ID为64的CONSTANT_NAME_AND_TYPE对象，而CONSTANT_CLASS对象又引用了CONSTANT_UTF8（java/lang/Object）、CONSTANT_NAME_AND_TYPE同时引用了CONSTANT_UTF8（<init>）和CONSTANT_UTF8（()V）,为了能够直观的看到常量池ID为1的对象信息我们就必须要将所有使用索引方式链接的映射关系改成直接字符串引用，最终得到如下结果：

    1. {
    2.     "constantPoolMap": {
    3.         "1": {
    4.             "tag": "CONSTANT_METHOD_REF", 
    5.             "classIndex": 21, 
    6.             "nameAndTypeIndex": 64, 
    7.             "classValue": "java/lang/Object", 
    8.             "nameAndTypeValue": "<init>"
    9.         }
    10.         .... 省略其他对象
    11.     }
    12. }

    常量池对象链接代码片段：

    1. /**
    2.  * 链接常量池中的引用
    3.  */
    4. private void linkConstantPool() {
    5.     for (Integer id : constantPoolMap.keySet()) {
    6.         Map<String, Object> valueMap = constantPoolMap.get(id);
    8.         if (!valueMap.containsKey("value")) {
    9.             Map<String, Object> newMap = new LinkedHashMap<>();
    11.             for (String key : valueMap.keySet()) {
    12.                 if (key.endsWith("Index")) {
    13.                     Object value = recursionValue((Integer) valueMap.get(key));
    15.                     if (value != null) {
    16.                         String newKey = key.substring(0, key.indexOf("Index"));
    18.                         newMap.put(newKey + "Value", value);
    19.                     }
    20.                 }
    21.             }
    23.             valueMap.putAll(newMap);
    24.         }
    25.     }
    26. }
    28. /**
    29.  * 递归查找ID对应的常量池中的值
    30.  *
    31.  * @param id 常量池ID
    32.  * @return 常量池中存储的值
    33.  */
    34. private Object recursionValue(Integer id) {
    35.     Map<String, Object> map = constantPoolMap.get(id);
    37.     if (map.containsKey("value")) {
    38.         return map.get("value");
    39.     }
    41.     for (String key : map.keySet()) {
    42.         if (key.endsWith("Index")) {
    43.             Integer value = (Integer) map.get(key);
    45.             return recursionValue(value);
    46.         }
    47.     }
    49.     return null;
    50. }

    为了方便通过ID（常量池索引）访问常量池中的对象值，封装了一个getConstantPoolValue方法：

    1. /**
    2.  * 通过常量池中的索引ID和名称获取常量池中的值
    3.  *
    4.  * @param index 索引ID
    5.  * @return 常量池对象值
    6.  */
    7. private Object getConstantPoolValue(int index) {
    8.      if (constantPoolMap.containsKey(index)) {
    9.         Map<String, Object> dataMap  = constantPoolMap.get(index);
    10.         Constant            constant = (Constant) dataMap.get("tag");
    12.         switch (constant) {
    13.            case CONSTANT_UTF8:
    14.            case CONSTANT_INTEGER:
    15.            case CONSTANT_FLOAT:
    16.            case CONSTANT_LONG:
    17.            case CONSTANT_DOUBLE:
    18.               return dataMap.get("value");
    19.            case CONSTANT_CLASS:
    20.            case CONSTANT_MODULE:
    21.            case CONSTANT_PACKAGE:
    22.               return dataMap.get("nameValue");
    23.            case CONSTANT_STRING:
    24.               return dataMap.get("stringValue");
    25.            case CONSTANT_FIELD_REF:
    26.            case CONSTANT_METHOD_REF:
    27.            case CONSTANT_INTERFACE_METHOD_REF:
    28.               return dataMap.get("classValue") + "." + dataMap.get("nameAndTypeValue");
    29.            case CONSTANT_NAME_AND_TYPE:
    30.            case CONSTANT_METHOD_TYPE:
    31.               return dataMap.get("descriptorValue");
    32.            case CONSTANT_METHOD_HANDLE:
    33.               return dataMap.get("referenceValue");
    34.            case CONSTANT_DYNAMIC:
    35.            case CONSTANT_INVOKE_DYNAMIC:
    36.               return dataMap.get("bootstrapMethodAttrValue") + "." + dataMap.get("nameAndTypeValue");
    37.            default:
    38.               break;
    39.         }
    40.      }
    42.      return null;
    43. }