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

妖狐艹你老母 2022-08-12 16:26 127阅读 0赞

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

**一、 编译一个文件**

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

[http://hg.openjdk.java.net/jdk6/jdk6/langtools/][http_hg.openjdk.java.net_jdk6_jdk6_langtools]

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

![Center][]

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

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

[http_hg.openjdk.java.net_jdk6_jdk6_langtools]: http://hg.openjdk.java.net/jdk6/jdk6/langtools/
[Center]: /images/20220810/e4fb4a957dd7423f9e6d3b95c3809500.png