Java Class 字节码文件结构详解

Class字节码中有两种数据类型：

字节数据直接量：这是基本的数据类型。共细分为u1、u2、u4、u8四种，分别代表连续的1个字节、2个字节、4个字节、8个字节组成的整体数据。
表：表是由多个基本数据或其他表，按照既定顺序组成的大的数据集合。表是有结构的，它的结构体现在，组成表的成分所在的位置和顺序都是已经严格定义好的。

Class字节码总体结构如下：

具体详解请参考http://www.blogjava.net/DLevin/archive/2011/09/05/358033.html

我在这里要说明几个细节问题：

为什么说常量表的数量是constant_pool_count-1，且索引从1开始而不是0。其实根本原因在于，索引为0也是一个常量（保留常量），只不过它不存在常量表，这个常量就对应null值。因此加上这个系统保留常量，常量个数共为constant_pool_count个，但是常量表数量要减1。
在常量池中，如果存在long型或double型字面量，它们会占用两个连续索引。比如：假设一个类中只有一个int型字面量1和一个double型字面量1（当然这种假设是不可能的，因为总会有类名字面量等），则常量池个数为3，而不是2。这正是因为double字面量占用了两个连续的索引。

接下来，贴出一个小demo来展示如何读取字节码：

ClassParser负责把握Class字节码整体结构的解析。

package com.lixin;

import java.io.IOException;
import java.io.InputStream;

public class ClassParser {

	private InputStream in;

	public ClassParser(InputStream in) {
		this.in = in;
	}

	public void parse() throws IOException {
		// 魔数
		magicNumber();
		// 主次版本号
		version();
		// 常量池
		constantPool();
		// 类或接口修饰符
		accessFlag();
		// 继承关系（当前类、父类、父接口）
		inheritence();
		// 字段集合
		fieldList();
		// 方法集合
		methodList();
		// 属性集合
		attributeList();
	}

	private void attributeList() throws IOException {
		line();
		int attrLength = StreamUtils.read2(in);
		System.out.println("共有"+attrLength+"个属性");
		for (int i=0;i<attrLength;i++) {
			line();
			attribute();
		}
	}
	private void attribute() throws IOException {
		int nameIndex = StreamUtils.read2(in); 
		int length = StreamUtils.read4(in); 
		byte[] info = StreamUtils.read(in, length);
		System.out.println("nameIndex:"+nameIndex);
		System.out.println("length:"+length);
		System.out.println("info:"+info);
	}

	private void methodList() throws IOException {
		int length = StreamUtils.read2(in);
		System.out.println("共有"+length+"个方法");
		for (int i=0;i<length;i++)
			method();
	}

	private void method() throws IOException {
		System.out.println("---------------------");
		int accessFlag = StreamUtils.read2(in);
		int nameIndex = StreamUtils.read2(in);
		int descriptorIndex = StreamUtils.read2(in);
		System.out.println("accessFlag:"+accessFlag);
		System.out.println("nameIndex:"+nameIndex);
		System.out.println("descriptorIndex:"+descriptorIndex);
		attributeList();
	}

	private void fieldList() throws IOException {
		line();
		int length = StreamUtils.read2(in);
		System.out.println("共有"+length+"个字段");
		for (int i=0;i<length;i++) {
			System.out.println("-----------------------------");
			int accessFlag = StreamUtils.read2(in);
			int nameIndex = StreamUtils.read2(in);
			int descriptorIndex = StreamUtils.read2(in);
			System.out.println("accessFlag:"+accessFlag);
			System.out.println("nameIndex:"+nameIndex);
			System.out.println("descriptorIndex:"+descriptorIndex);
			attributeList();
		}
	}

	private void inheritence() throws IOException {
		line();
		int thisClassRef = StreamUtils.read2(in);
		int superClassRef = StreamUtils.read2(in);
		System.out.println("thisClassRef:"+thisClassRef);
		System.out.println("superClassRef:"+superClassRef);
		int interfaceLen = StreamUtils.read2(in);
		System.out.println("接口数量："+interfaceLen);
		for (int i=0;i<interfaceLen;i++) {
			int interfaceRef = StreamUtils.read2(in);
			System.out.println("interfaceRef:"+interfaceRef);
		}
	}

	private void accessFlag() throws IOException {
		line();
		int accessFlag = StreamUtils.read2(in);
		System.out.println("accessFlag:0x"+Integer.toHexString(accessFlag)+"("+accessFlag+")");
	}

	private void constantPool() throws IOException {
		new ConstantPoolParser(in).constPool();
	}

	private void version() throws IOException {
		line();
		int minorVersion = StreamUtils.read2(in);
		int majorVersion = StreamUtils.read2(in);
		System.out.println("版本："+majorVersion+"."+minorVersion);
	}

	private void magicNumber() throws IOException {
		line();
		int magic = StreamUtils.read4(in);
		System.out.println("魔数："+Integer.toHexString(magic).toUpperCase());
	}

	private void line() {
		System.out.println("----------------------");
	}
}

ConstPoolParser负责常量池的解析（因为常量池表较多，且数据量也较大，因此单独拉出来解析）

package com.lixin;

import java.io.IOException;
import java.io.InputStream;

public class ConstPoolParser {

	public static final int Utf8_info = 1;
	public static final int Integer_info = 3;
	public static final int Float_info = 4;
	public static final int Long_info = 5;
	public static final int Double_info = 6;
	public static final int Class_info = 7;
	public static final int String_info = 8;
	public static final int Fieldref_info = 9;
	public static final int Methodref_info = 10;
	public static final int InterfaceMethodref_info = 11;
	public static final int NameAndType_info = 12;
	public static final int MethodHandle_info = 15;
	public static final int MethodType_info = 16;
	public static final int InvokeDynamic_info = 18;

	private InputStream in;

	public ConstPoolParser(InputStream in) {
		this.in = in;
	}

	public void constPool() throws IOException {
		line();
		int length = StreamUtils.read2(in);
		System.out.println("共有"+length+"个常量");
		boolean doubleBytes = false;
		for (int i = 1; i < length; i++) {
			if (doubleBytes) {
				doubleBytes = false;
				continue;
			}
			line();
			System.out.println("常量索引："+i);
			int flag = StreamUtils.read1(in);
//			System.out.println("标志:"+flag);

			switch (flag) {
			case Utf8_info:
				utf8Info();
				continue;
			case Integer_info:
				integerInfo();
				continue;
			case Float_info:
				floatInfo();
				continue;
			case Long_info:
				doubleBytes = true;
				longInfo();
				continue;
			case Double_info:
				doubleBytes = true;
				doubleInfo();
				continue;
			case Class_info:
				classInfo();
				continue;
			case String_info:
				stringInfo();
				continue;
			case Fieldref_info:
				fieldrefInfo();
				continue;
			case Methodref_info:
				methodrefInfo();
				continue;
			case InterfaceMethodref_info:
				interfaceMethodrefInfo();
				continue;
			case NameAndType_info:
				nameAndTypeInfo();
				continue;
			case MethodHandle_info:
				methodHandleInfo();
				continue;
			case MethodType_info:
				methodTypeInfo();
				continue;
			case InvokeDynamic_info:
				invokeDynamicInfo();
				continue;
			default:
				System.err.println(flag);
				throw new RuntimeException("unknown");
			}
		}
	}

	private void line() {
		System.out.println("----------------------");
	}

	private void utf8Info() throws IOException {
		int length = StreamUtils.read2(in);
		byte[] buf = StreamUtils.read(in, length);
		String s = new String(buf,0,buf.length);
		System.out.println("utf8Info表：");
		System.out.println("值："+s);
	}

	private void integerInfo() throws IOException {
		System.out.println("integerInfo表：");
		int value = StreamUtils.read4(in);
		System.out.println("值："+value);
	}

	private void floatInfo() throws IOException {
		System.out.println("floatInfo表：");
		int value = StreamUtils.read4(in);
		float f = Float.intBitsToFloat(value);
		System.out.println("值："+f);
	}

	private void longInfo() throws IOException {
		System.out.println("longInfo表：");
		long value = StreamUtils.read8(in);
		System.out.println("值："+value);
	}

	private void doubleInfo() throws IOException {
		System.out.println("doubleInfo表：");
		long value = StreamUtils.read8(in);
		double d = Double.longBitsToDouble(value);
		System.out.println("值："+d);

	}

	private void classInfo() throws IOException {
		System.out.println("classInfo表:");
		int index = StreamUtils.read2(in);
		System.out.println("index:" + index);
	}

	private void stringInfo() throws IOException {
		System.out.println("stringInfo表:");
		int index = StreamUtils.read2(in);
		System.out.println("index:" + index);
	}

	private void fieldrefInfo() throws IOException {
		int classIndex = StreamUtils.read2(in);
		int nameAndTypeIndex = StreamUtils.read2(in);
		System.out.println("fieldrefInfo表:");
		System.out.println("classIndex:" + classIndex);
		System.out.println("nameAndTypeIndex:" + nameAndTypeIndex);
	}

	private void methodrefInfo() throws IOException {
		int classIndex = StreamUtils.read2(in);
		int nameAndTypeIndex = StreamUtils.read2(in);
		System.out.println("methodrefInfo表:");
		System.out.println("classIndex:" + classIndex);
		System.out.println("nameAndTypeIndex:" + nameAndTypeIndex);
	}

	private void interfaceMethodrefInfo() throws IOException {
		int classIndex = StreamUtils.read2(in);
		int nameAndTypeIndex = StreamUtils.read2(in);
		System.out.println("interfaceMethodrefInfo表:");
		System.out.println("classIndex:" + classIndex);
		System.out.println("nameAndTypeIndex:" + nameAndTypeIndex);
	}

	private void nameAndTypeInfo() throws IOException {
		int nameIndex = StreamUtils.read2(in);
		int typeIndex = StreamUtils.read2(in);
		System.out.println("nameAndTypeInfo表:");
		System.out.println("nameIndex:" + nameIndex);
		System.out.println("typeIndex:" + typeIndex);
	}

	private void methodHandleInfo() throws IOException {
		int referenceKind = StreamUtils.read1(in);
		int referenceIndex = StreamUtils.read2(in);
		System.out.println("methodHandleInfo表：");
		System.out.println("referenceKind:"+referenceKind);
		System.out.println("referenceIndex:"+referenceIndex);
	}

	private void methodTypeInfo() throws IOException {
		System.out.println("methodTypeInfo表：");
		int descriptorIndex = StreamUtils.read2(in);
		System.out.println("descriptorIndex:"+descriptorIndex);
	}

	private void invokeDynamicInfo() throws IOException {
		int bootstrapMethodAttrIndex = StreamUtils.read2(in);
		int nameAndTypeIndex = StreamUtils.read2(in);
		System.out.println("bootstrapMethodAttrIndex:"+bootstrapMethodAttrIndex);
		System.out.println("nameAndTypeIndex:"+nameAndTypeIndex);
	}
}

StreamUtils负责从输入字节流中读取数据

package com.lixin;

import java.io.IOException;
import java.io.InputStream;

public class StreamUtils {

	public static int read1(InputStream in) throws IOException {
		return in.read() & 0xff;
	}

	public static int read2(InputStream in) throws IOException{
		return (read1(in) << 8) | read1(in);
	}

	public static int read4(InputStream in) throws IOException {
		return (read2(in) <<16) | read2(in);
	}

	public static long read8(InputStream in) throws IOException {
		long high = read4(in) & 0xffffffffl;
		long low  = read4(in) & 0xffffffffl;
		return (high << 32) | (low);
	}

	public static byte[] read(InputStream in,int length) throws IOException {
		byte[] buf = new byte[length];
		in.read(buf, 0, length);
		return buf;
	}
}

TestClass为待解析的目标类，读者可以任意改写此类来多做实验

package com.lixin;

public class TestClass {

	private int a = 5;
	protected char c = 'c';
	double x = 1.1;
	long y = 111;

	public void show() {

	}
}

测试方法入口：

package com.lixin;

import java.io.InputStream;

/**
 * 程序入口
 * @author lixin
 *
 */
public class App {

	public static void main(String[] args) throws Exception {
		InputStream in = Class.class.getResourceAsStream("/com/lixin/TestClass.class");
		ClassParser parser = new ClassParser(in);
		parser.parse();
	}

}

最后，我们可以使用jdk中的javap进行字节码反编译，来对比我们的读取与反编译结果差别，用于查错。

javap -v TestClass.class >./out.txt

Java Class 字节码文件结构详解的更多相关文章

Kotlin伴生对象及其字节码内幕详解
继续面向对象,开撸就是!! 接口: 我们知道对于JDK8之后接口中除了方法的声明之后还可以有default方法的,而在Kotlin中也类似,下面来看一下在Kotlin接口相关的东东: 很显然就是一个方 ...
从 HelloWorld 看 Java 字节码文件结构
很多时候,我们都是从代码层面去学习如何编程,却很少去看看一个个 Java 代码背后到底是什么.今天就让我们从一个最简单的 Hello World 开始看一看 Java 的类文件结构. 在开始之前,我们 ...
Java之函数式接口@FunctionalInterface详解（附源码）
Java之函数式接口@FunctionalInterface详解函数式接口的定义在java8中,满足下面任意一个条件的接口都是函数式接口: 1.被@FunctionalInterface注释的接口 ...
Java字节码文件结构剖析
今天起开启JVM的新的知识学习篇章----Java的字节码,那学习Java字节码有啥用呢?我们知道Java是跨平台的一门语言,编写一次到处运行,而支撑着这个特性的根基为两点:JVM和.class字节码 ...
＜JVM中篇：字节码与类的加载篇＞01-Class字节码文件结构
笔记来源:尚硅谷JVM全套教程,百万播放,全网巅峰(宋红康详解java虚拟机) 同步更新:https://gitee.com/vectorx/NOTE_JVM https://codechina.cs ...
Java虚拟机之垃圾回收详解一
Java虚拟机之垃圾回收详解一 Java技术和JVM(Java虚拟机) 一.Java技术概述: Java是一门编程语言,是一种计算平台,是SUN公司于1995年首次发布.它是Java程序的技术基础,这 ...
Java I/O : Java中的进制详解
作者:李强强上一篇,泥瓦匠基础地讲了下Java I/O : Bit Operation 位运算.这一讲,泥瓦匠带你走进Java中的进制详解. 一.引子在Java世界里,99%的工作都是处理这高层. ...
Java网络编程和NIO详解开篇：Java网络编程基础
Java网络编程和NIO详解开篇:Java网络编程基础计算机网络编程基础转自:https://mp.weixin.qq.com/s/XXMz5uAFSsPdg38bth2jAA 我们是幸运的,因为 ...
Java网络编程和NIO详解8：浅析mmap和Direct Buffer
Java网络编程与NIO详解8:浅析mmap和Direct Buffer 本系列文章首发于我的个人博客:https://h2pl.github.io/ 欢迎阅览我的CSDN专栏:Java网络编程和NI ...

随机推荐

c指针点滴2之比大小
#include <stdio.h> #include <stdlib.h> void main2() { ]={,,,4.5}; ]; ]; if(p1<p2) { p ...
HDOJ 1316 How Many Fibs?
JAVA大数.... How Many Fibs? Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Jav ...
File类的基本操作之InputStream字节输入流
话不多少,我直接把代码贴上来了.有什么问题请给我留言 package org.mark.streamRW; import java.io.File; import java.io.FileInputS ...
[Redux] Extracting Container Components -- VisibleTodoList
Code to be refacted: const TodoList = ({ todos, onTodoClick }) => ( <ul> {todos.map(todo =& ...
c++11 之 decltype
在C++中,decltype作为操作符,用于查询表达式的数据类型.decltype在C++11标准制定时引入,主要是为泛型编程而设计,以解决泛型编程中,由于有些类型由模板参数决定,而难以(甚至不可能) ...
开始学javascript基础
JavaScript非常值得我们学习. 1)所有主浏览器都支持JavaScript. 2) 目前,全世界大部分网页都使用JavaScript. 3) 它可以使网页呈现各种动态效果. 4)作为一个Web ...
Windows下使用ODBC API访问数据库之关键
本文采用SQL2005 + VS2008环境,以ODBC API方式成功连接数据库. 1.SQL安装和环境配置这部分网上随便搜一下都有很多资料,而且很容易就可以配置成功. 注意的关键点: SA账号配 ...
wcf wpf
转 http://blog.csdn.net/thunder09/article/details/5792157 WPF就是所谓下一代Windows界面层技术,我觉得还有满有前途的.不过Vista发布 ...
DOM 其他一些特性
cookie 允许javascript程序读写HTTP cookie 的特殊的属性 domain 允许当Web页面之间交互时,相同域名下相互信任的Web服务器之间协作放宽同源策略安全限制 (JavaS ...
macbook安装mysql
一.官网下载dmg文件二.双击安装dmg文件,一路next: 三.

Java Class 字节码文件结构详解

Java Class 字节码文件结构详解的更多相关文章

随机推荐

热门专题