JVM深入学习笔记一：Java 编译器初探

闲来无事想大概看下Java编译器的执行过程

一、 编译一个文件

首先去搞到源代码。从JDK6开始Java代码开源，放到OPENJDK组织中去，所以从这个网站进行下载：

http://hg.openjdk.java.net/jdk6/jdk6/langtools/ 

下载之后是一个zip包，解压，可以直接导入到eclipse中进行使用，导入之后可能会报错，需要设置一下。

好，下面写一个用作测试的类:

import java.util.Arrays;
import java.util.List;
import org.apache.commons.lang.StringUtils;

public class Test {
	public static void main(String[] args) {
		System.out.println("main");
	}
	
	public void test(){
		List<Integer> list = Arrays.asList(1, 2, 3, 4);
		for (int i : list) {
			System.out.println(i);
		}
	}
}

这个代码之后还会用到，其中包含了foreach, 变参, 泛型，自动封包这些Java提供的一些语法上的支持， 在后面会看到其实知识语法糖，并不是JVM底层支持的。

另外如下代码调用编译器对这个文件进行编译:

import com.sun.tools.javac.main.Main;

public class MyCompiler {
	public static void main(String[] args) {
		Main compiler = new Main("javac");
		args = new String[]{"-classpath", ".\\lib\\commons-lang-2.5.jar", "-d", "\\", ".\\src\\com\\prince\\jvmtest\\Test.java"};
		compiler.compile(args);
	}
}

执行之就能够编译出class文件了。

二、查看编译过程

1. 参数转化及文件验证

在调用到最最重要的JavaCompiler类之前会有统一进行一次参数处理，

把参数存到Option类中，

检查源文件是否存在，不存在会抛出异常：

javac: 找不到文件： .\src\com\prince\jvmtest\Test1.java

主要的代码块来了:

            // These method calls must be chained to avoid memory leaks
            delegateCompiler =
                processAnnotations(
                    enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                    classnames);

            delegateCompiler.compile2();

2. parseFiles  语法和词法分析，经过了这一步将会把java文件转化为一个treemap, 所有的代码都转化为语法单元。以后就不会用到源文件了。

3. stopIfError  语法错误检测，比如final类型不能重定义等。

4. processAnnotations 标注处理

下一块代码

generate(desugar(flow(attribute(todo.remove()))));

5. attribute  语义错误检查至标注分析。  比如定义了String a = 1;会在这里抛出异常

还进行了代码折叠，比如int a = 1+ 2会被折叠为int a =3.

6. flow  另外一些有关流程的语义分析，比如是否有返回值，受检异常是否捕获， 是否存在未初始化就使用变量的情况

7. desugar 解语法糖

语法糖还是很重要的，  Java中很多新的特性并不提供运行期支持，仅仅提供了编译器支持。

刚才的那段代码经过了这一系列操作之后的代码会变成如下的状态:

[Pair[Env[AttrContext[Scope[super, this]],outer=Env[AttrContext[Scope[java.util.List, java.util.Arrays, com.prince.jvmtest.Test]]]],
public class Test {
    
    public Test() {
        super();
    }
    
    public static void main(String[] args) {
        System.out.println("main");
    }
    
    public void test() {
        List list = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4)});
        for (.java.util.Iterator i$ = list.iterator(); i$.hasNext(); ) {
            int i = ((Integer)i$.next()).intValue();
            {
                System.out.println(i);
            }
        }
    }
}]]

会发现变了很多的内容

• 增加了默认的构造器
• 变长参数会变成一个数组，  int类型会被自动装包
• foreach会变为for + iterator的形式
• 泛型实际上也是强制的类型转换

以后Java可能还会提供更多的语法糖来简化开发。

8. 生成字节码， 回写到class文件。

三、用注解参与Java编译过程

主要需要写两部分内容。 Processor和Scanner.

代码如下:

public class MyCheckerScanner extends ElementScanner6<Void, Void> {
	private final Messager messager;
	public MyCheckerScanner(Messager messager) {
		this.messager = messager;
	}
	
	@Override
	public Void visitVariable(VariableElement e, Void p) {
		String name = e.getSimpleName().toString();
		System.out.println(name);
		int firstCode = name.codePointAt(0);
		if(Character.isUpperCase(firstCode)){
			System.out.println("asdfasdfasf");
			messager.printMessage(Kind.WARNING, "方法名第一个字母必须小写", e);
		}
		return null;
	}
}

只覆盖了一个方法，用来验证参数的第一个字母不能大写。 注意需要把Message传过来。

Processor的代码：

@SupportedAnnotationTypes("*")
@SupportedSourceVersion(SourceVersion.RELEASE_6)
public class MyProcessor extends AbstractProcessor {
	private MyCheckerScanner scanner = null;
	@Override
	public synchronized void init(ProcessingEnvironment processingEnv) {
		super.init(processingEnv);
		scanner = new MyCheckerScanner(processingEnv.getMessager());
	}

	@Override
	public boolean process(Set<? extends TypeElement> annotations,
			RoundEnvironment roundEnv) {
		
		if(!roundEnv.processingOver()){
			for (Element element : roundEnv.getRootElements()) {
				scanner.scan(element);
			}
		}
		return false;
	}

}

• 这两个注解是必须要写的，一个定义了支持所有的注解，一个定义了用在JDK6里面
• init方法进行初始化，主要是为了取得Messager
• process方法就是具体的操作了。调用了Scanner之后将会扫描整个代码结构进行验证。

执行方式也要修改一下，如下：

	public static void main(String[] args) {
		Main compiler = new Main("javac");
		args = new String[]{"-processor","com.prince.jvmtest.MyProcessor", "-classpath", ".\\lib\\commons-lang-2.5.jar", "-d", "\\", ".\\src\\com\\prince\\jvmtest\\Test.java"};
		
		compiler.compile(args);
	}

编译的时候增加了-processor的参数来指定处理器，然后就能够查看到编译的结果了，如下：

.\src\com\prince\jvmtest\Test.java:7: 警告：方法名第一个字母必须小写
	public static void main(String[] Args) {

总的来说Java编译器并不会对代码性能方面有多少提升，更多的是提高了Java本身的易用性和对程序员的编码习惯起到规范的作用。

例子代码下载地址:  http://download.csdn.net/detail/three_man/7990081