Code属性用于表示成员方法的代码部分，Code中包含了指令集（byte数组），JVM调用成员方法时实际上就是执行的Code中的指令，而反编译工具则是把Code中的指令翻译成了Java代码。

    1. Code_attribute {
    2.   u2 attribute_name_index;
    3.   u4 attribute_length;
    4.   u2 max_stack;
    5.   u2 max_locals;
    6.   u4 code_length;
    7.   u1 code[code_length];
    8.   u2 exception_table_length;
    9.   { u2 start_pc;
    10.    u2 end_pc;
    11.    u2 handler_pc;
    12.    u2 catch_type;
    13.   } exception_table[exception_table_length];
    14.   u2 attributes_count;
    15.   attribute_info attributes[attributes_count];
    16. }

    Code解析代码片段：

    1. int          maxStack   = dis.readUnsignedShort();
    2. int          maxLocals  = dis.readUnsignedShort();
    3. int          codeLength = dis.readInt();
    4. List<String> opcodeList = new ArrayList<>();
    5. byte[]       bytes      = new byte[codeLength];
    7. // 读取所有的code字节
    8. dis.read(bytes);
    10. // 创建Code输入流
    11. DataInputStream bis = new DataInputStream(new ByteArrayInputStream(bytes));
    13. // 创建属性Map
    14. Map<String, Object> attrMap = new LinkedHashMap<>();
    15. attrMap.put("maxStack", maxStack);
    16. attrMap.put("maxLocals", maxLocals);
    17. attrMap.put("codeLength", codeLength);
    19. // 是否是宽类型
    20. boolean wide = false;
    22. for (int offset = 0; offset < codeLength; offset++) {
    23.     int     branchOffset          = -1;
    24.     int     defaultOffset         = -1;
    25.     int     switchNumberofPairs   = -1;
    26.     int     switchNumberOfOffsets = -1;
    27.     int     immediateByte         = -1;
    28.     int     immediateShort        = -1;
    29.     int     arrayDimensions       = 0;
    30.     int     incrementConst        = -1;
    31.     int     incrementConst2       = -1;
    32.     int     switchMatch           = -1;
    33.     int     switchOffset          = -1;
    34.     int[]   switchJumpOffsets     = null;
    35.     int     bytesToRead           = 0;
    36.     int     code                  = bis.readUnsignedByte();
    37.     Opcodes opcode                = Opcodes.getOpcodes(code);
    39.     if (opcode == null) {
    40.         continue;
    41.     }
    43.     switch (opcode) {
    44.         case BIPUSH:
    45.         case LDC:
    46.         case ILOAD:
    47.         case LLOAD:
    48.         case FLOAD:
    49.         case DLOAD:
    50.         case ALOAD:
    51.         case ISTORE:
    52.         case LSTORE:
    53.         case FSTORE:
    54.         case DSTORE:
    55.         case ASTORE:
    56.         case RET:
    57.         case NEWARRAY:
    58.           if (wide) {
    59.             immediateByte = bis.readUnsignedShort();
    60.           } else {
    61.             immediateByte = bis.readUnsignedByte();
    62.           }
    64.           addOpcodes(opcodeList, opcode, immediateByte);
    66.           // 因为读取了byte，所以需要重新计算bis偏移量
    67.           offset += wide ? 2 : 1;
    68.           break;
    69.         case LDC_W:
    70.         case LDC2_W:
    71.         case GETSTATIC:
    72.         case PUTSTATIC:
    73.         case GETFIELD:
    74.         case PUTFIELD:
    75.         case INVOKEVIRTUAL:
    76.         case INVOKESPECIAL:
    77.         case INVOKESTATIC:
    78.         case NEW:
    79.         case ANEWARRAY:
    80.         case CHECKCAST:
    81.         case INSTANCEOF:
    82.         case SIPUSH:
    83.           addOpcodes(opcodeList, opcode, bis.readUnsignedShort());
    85.           offset += 2;
    86.           break;
    87.         case IFEQ:
    88.         case IFNE:
    89.         case IFLT:
    90.         case IFGE:
    91.         case IFGT:
    92.         case IFLE:
    93.         case IF_ICMPEQ:
    94.         case IF_ICMPNE:
    95.         case IF_ICMPLT:
    96.         case IF_ICMPGE:
    97.         case IF_ICMPGT:
    98.         case IF_ICMPLE:
    99.         case IF_ACMPEQ:
    100.         case IF_ACMPNE:
    101.         case GOTO:
    102.         case JSR:
    103.         case IFNULL:
    104.         case IFNONNULL:
    105.           branchOffset = bis.readShort();
    107.           opcodeList.add(opcode.getDesc() + " " + branchOffset);
    109.           offset += 2;
    110.           break;
    111.         case GOTO_W:
    112.         case JSR_W:
    113.           branchOffset = bis.readInt();
    115.           opcodeList.add(opcode.getDesc() + " " + branchOffset);
    117.           offset += 4;
    118.           break;
    119.         case IINC:
    120.           if (wide) {
    121.             incrementConst = bis.readUnsignedShort();
    122.           } else {
    123.             incrementConst = bis.readUnsignedByte();
    124.           }
    126.           if (wide) {
    127.             incrementConst2 = bis.readUnsignedShort();
    128.           } else {
    129.             incrementConst2 = bis.readUnsignedByte();
    130.           }
    132.           opcodeList.add(opcode.getDesc() + " " + incrementConst + " by " + incrementConst2);
    134.           offset += wide ? 4 : 2;
    135.           break;
    136.         case TABLESWITCH:
    137.           bytesToRead = readPaddingBytes(bytes, bis);
    139.           defaultOffset = bis.readInt();
    140.           int lowByte = bis.readInt();
    141.           int highByte = bis.readInt();
    143.           switchNumberOfOffsets = highByte - lowByte + 1;
    144.           switchJumpOffsets = new int[switchNumberOfOffsets];
    146.           for (int k = 0; k < switchNumberOfOffsets; k++) {
    147.             switchJumpOffsets[k] = bis.readInt();
    148.           }
    150.           opcodeList.add(opcode.getDesc());
    152.           offset += bytesToRead + 12 + 4 * switchNumberOfOffsets;
    153.           break;
    154.         case LOOKUPSWITCH:
    155.           bytesToRead = readPaddingBytes(bytes, bis);
    157.           defaultOffset = bis.readInt();
    158.           switchNumberofPairs = bis.readInt();
    160.           for (int k = 0; k < switchNumberofPairs; k++) {
    161.             switchMatch = bis.readInt();
    162.             switchOffset = bis.readInt();
    163.           }
    165.           opcodeList.add(opcode.getDesc());
    167.           offset += bytesToRead + 8 + 8 * switchNumberofPairs;
    168.           break;
    169.         case INVOKEINTERFACE:
    170.           immediateShort = bis.readUnsignedShort();
    171.           offset += 2;
    173.           int count = bis.readUnsignedByte();
    175.           // 下1个byte永远为0，所以直接丢弃
    176.           bis.readByte();
    178.           addOpcodes(opcodeList, opcode, immediateShort);
    180.           offset += 2;
    181.           break;
    182.         case INVOKEDYNAMIC:
    183.           immediateShort = bis.readUnsignedShort();
    184.           offset += 2;
    186.           // 下2个byte永远为0，所以直接丢弃
    187.           bis.readUnsignedShort();
    189.           addOpcodes(opcodeList, opcode, immediateShort);
    191.           offset += 2;
    192.           break;
    193.         case MULTIANEWARRAY:
    194.           immediateShort = bis.readUnsignedShort();
    195.           offset += 2;
    197.           arrayDimensions = bis.readUnsignedByte();
    199.           addOpcodes(opcodeList, opcode, immediateShort);
    201.           offset += 1;
    202.           break;
    203.         default:
    204.           opcodeList.add(opcode.getDesc());
    205.     }
    207.     wide = (WIDE == opcode);
    208. }
    210. attrMap.put("opcodes", opcodeList);
    212. // 读取异常表
    213. attrMap.put("exceptionTable", readExceptionTable());
    215. // u2 attributes_count;
    216. int attributesCount = dis.readShort();
    217. attrMap.put("attributeLength", attributeLength);
    218. attrMap.put("attributes", readAttributes(attributesCount));
    220. // 递归读取属性信息
    221. attributeMap.put("Code", attrMap);

    在解析Code属性时code_length表示的是Code的字节长度，max_stack和max_locals是一个固定值，表示的是最大操作数栈和最大局部变量数，这两个值是在编译类方法时自动计算出来的，如果通过ASM修改了类方法可能会需要重新计算max_stack和max_locals。

    示例 - TestHelloWorld类Hello方法解析结果：

    1. {
    2.   "access": 1, 
    3.   "name": "hello", 
    4.   "desc": "(Ljava/lang/String;)Ljava/lang/String;", 
    5.   "attributesCount": 1, 
    6.   "attributes": {
    7.     "attributeName": "Code", 
    8.     "attributeLength": 88, 
    9.     "Code": {
    10.       "maxStack": 2, 
    11.       "maxLocals": 3, 
    12.       "codeLength": 22, 
    13.       "opcodes": [
    14.         "ldc #3 <Hello:>", 
    15.         "astore_2", 
    16.         "new #4 <java/lang/StringBuilder>", 
    17.         "dup", 
    18.         "invokespecial #5 <java/lang/StringBuilder.<init>>", 
    19.         "aload_2", 
    20.         "invokevirtual #6 <java/lang/StringBuilder.append>", 
    21.         "aload_1", 
    22.         "invokevirtual #6 <java/lang/StringBuilder.append>", 
    23.         "invokevirtual #7 <java/lang/StringBuilder.toString>", 
    24.         "areturn"
    25.       ], 
    26.       "exceptionTable": {
    27.         "exceptionTableLength": 0, 
    28.         "exceptionTableList": [ ]
    29.       }, 
    30.       "attributeLength": 88, 
    31.       "attributes": {
    32.         "attributeName": "LocalVariableTable", 
    33.         "attributeLength": 32, 
    34.         "LineNumberTable": {
    35.           "lineNumberTableLength": 2, 
    36.           "lineNumberTableList": [
    37.             {
    38.               "startPc": 0, 
    39.               "lineNumber": 21
    40.             }, 
    41.             {
    42.               "startPc": 3, 
    43.               "lineNumber": 22
    44.             }
    45.           ]
    46.         }, 
    47.         "LocalVariableTable": {
    48.           "localVariableTableLength": 3, 
    49.           "localVariableTableList": [
    50.             {
    51.               "startPc": 0, 
    52.               "length": 22, 
    53.               "name": "this", 
    54.               "desc": "Lcom/anbai/sec/bytecode/TestHelloWorld;", 
    55.               "index": 0
    56.             }, 
    57.             {
    58.               "startPc": 0, 
    59.               "length": 22, 
    60.               "name": "content", 
    61.               "desc": "Ljava/lang/String;", 
    62.               "index": 1
    63.             }, 
    64.             {
    65.               "startPc": 3, 
    66.               "length": 19, 
    67.               "name": "str", 
    68.               "desc": "Ljava/lang/String;", 
    69.               "index": 2
    70.             }
    71.           ]
    72.         }
    73.       }
    74.     }
    75.   }
    76. }

    解析Code的指令集时需要对照指令集映射表，然后根据不同的指令实现不一样的指令处理逻辑，指令列表和详细的描述请参考：JVM规范-指令。