Java高级——前端编译与优化
前端编译与优化
概述
前端编译器把java文件编译成class文件，如：JDK的Javac、Eclipse JDT中的增量式编译器（ECJ）
- 前端编译器对代码的运行效率无任何优化措施
- 性能优化集中到运行期的即时编译器中，这样可适用于非Javac生成的Class文件
- 但有针对编码过程的优化，从而降低编码复杂度，如语法糖
《Java虚拟机规范》未规定如何将java文件编译为Class文件，给予了较大的灵活性
编译过程与具体编译器实现绑定，可能会导致某些代码在Javac中可以编译，而在ECJ则不可编译
Javac导入
Javac编译器由纯Java实现
- 源码放在/langtools/src/share/classes/com/sun/tools/javac
- JDK9后放在/src/jdk.compiler/share/classes/com/sun/tools/javac
下面导入JDK8中的Javac源码，新建项目，将源码langtools/src/share/classes中的com/sun复制到项目目录（根据提示将private改为package即可解决报错）
将Run-RunConfiguration-Main中的Mian Class指定为javac.Main
新建一个Test.java，在Argument-Program argument指定其路径
点击Run，即可编译出Test.class，与在命令行中运行javac Test.java效果是一样的
Javac编译过程
- 初始化插入式注解处理器
- 解析与填充符号表
- 注解处理
- 分析与字节码生成
Javac编译动作的入口是
com.sun.tools.javac.main.JavaCompiler类，关键代码如下
解析与填充符号表
解析
解析由parseFiles()方法完成，包括词法分析和语法
词法分析将源代码的字符流转变为标记（Token）集合
- 字符是程序最小元素，但标记才是编译时的最小元素
- 关键字、变量名、字面量、运算符都可以作为标记
- 由com.sun.tools.javac.parser.Scanner类实现
- 如int a=b+2包含了6个标记，分别是int、a、=、b、+、2
语法分析根据标记序列构造抽象语法树
- 抽象语法树（Abstract Syntax Tree，AST）是一种用来描述程序代码语法结构的树形表示方式
- 其节点都代表着程序代码中的一个语法结构（Syntax Construct），如包、类型等
- 由com.sun.tools.javac.parser.Parser类构造，com.sun.tools.javac.tree.JCTree类表示
如下是Eclipse AST View插件分析出来的某段代码的抽象语法树视图
生成语法树以后，编译器不会再对源码字符流进行操作了，后续操作都建立在抽象语法树之上
填充符号表
填充符号表由enterTrees()方法完成，符号表（Symbol Table）是由一组符号地址和符号信息构成的数据结构
- 在语义分析阶段用于语义检查（如检查一个名字的使用和原先的声明是否一致）和产生中间代码
- 在目标代码生成阶段根据符号表对符号名进行地址分配
- 由com.sun.tools.javac.comp.Enter类实现
- 生成一个待处理列表，包含了每一个编译单元的抽象语法树和package-info.java的顶级节点
注解处理过程
注解处理由processAnnotations()方法完成，JDK6之前注解只会在程序运行时发挥作用，JDK6设计了插入式注解处理器API将注解处理提前至编译期
可把插入式注解处理器看作编译器的插件，允许读取、修改、添加抽象语法树中的任意元素，如注解来实现自动产生getter/setter方法、生成受查异常表等
若在处理注解期间修改过语法树，编译器将回到解析及填充符号表的过程重新处理，直至不再修改语法树，循环过程称为一个轮次（Round）
若有新的注解处理器，会通过com.sun.tools.javac.processing.JavacProcessing-Environment类的doProcessing()方法生成一个新的JavaCompiler对象
分析和字节码生成
分析和字节码生成由Compile2()方法完成，包括标注检查、数据流及控制流分析、解语法糖、字节码生成
分析指语义分析，对结构上正确的源程序进行上下文相关性质的检查
抽象语法树能够表示一个结构正确的源程序，但无法保证源程序的语义是符合逻辑的，如下
int a = 1;
boolean b = false;
char c = 2;
可能出现
int d = a + c;
int d = b + c;
char d = a + c;
上面3种赋值都能构成正确的抽象语法树，但只有第一种赋值在Java语义上是正确的（IDE的红线错误提示即来源于语义分析）
标注检查
标注检查由attribute()完成，实现类是com.sun.tools.javac.comp.Attr和com.sun.tools.javac.comp.Check
标注检查的内容包括诸如变量使用前是否已被声明、变量与赋值之间的数据类型是否能够匹配
在标注检查中，会进行一个称为常量折叠（Constant Folding）的代码优化，如对于
int a = 1 + 2;
在抽象语法树上仍然能看到字面量“1”“2”和操作符“+”号，但是在经过常量折叠优化之后，会变成字面量“3”，
数据流及控制流分析
数据流及控制流分析由flow()方法完成，实现类为com.sun.tools.javac.comp.Flow
对程序上下文逻辑更进一步的验证，如程序局部变量在使用前是否有赋值、方法的每条路径是否都有返回值等
编译时和类加载时的数据及控制流分析基本一样，但校验范围有所区别，有一些校验项只能在编译期或运行期进行
public void foo(final int arg) {
final int var = 0;
}
public void foo(int arg) {
int var = 0;
}
如上，一个方法有final，一个没有，但它们编译出来的指令都是一模一样
- 局部变量在常量池中并没有CONSTANT_Fieldref_info
- 也无存储有访问标志（access_flags）的信息
- 故Class文件不会知道局部变量是否为final
- final的不可变性仅由Javac在编译期间保证
解语法糖
解语法糖由desugar()方法完成，实现类为com.sun.tools.javac.comp.TransTypes和com.sun.tools.javac.comp.Lower
语法糖指在计算机语言中添加的某种语法，其对语言的编译结果和功能并没有实际影响，但是却能更方便使用该语言
Java中的语法糖如泛型、变长参数、自动装箱拆箱等，JVM运行时并不直接支持这些语法，需在编译阶段将其还原回原始的基础语法结构，称为解语法糖
字节码生成
字节码生成由generate()方法完成，实现类为com.sun.tools.javac.jvm.Gen
把前面各个步骤所生成的信息（语法树、符号表）转化成字节码指令写到磁盘中，还进行了代码添加（<init>）和转换（将+转为StringBuffer的append）
完成对语法树的遍历和调整之后，就会把的符号表交到com.sun.tools.javac.jvm.ClassWriter的writeClass()方法输出字节码，生成Class文件
前端编译优化
泛型
泛型将操作的数据类型指定为方法签名中的一种特殊参数，用于类、接口和方法的创建中，分别构成泛型类、泛型接口和泛型方法
Java和C#的泛型
C#是具现化式泛型（Reified Generics）
- 在源码、编译后的中间语言或是运行期都是实际存在的
- 运行期的List<int>与List<string>是两个不同的类型，有独立的虚方法表和类型数据
Java是类型擦除式泛型（Type Erasure Generics）
- 只在程序源码中存在，在Class中泛型被替换为原来的裸类型（Raw Type），并且加入强制转型代码
- 运行期的ArrayList<int>与ArrayList<String>是同一个类型
Java泛型使用效果（无法instanceof、创建对象和数组）和运行效率（需不断拆箱装箱）都不如C#，唯一优势在于实现只需要修改Javac，不需要改动字节码和JVM，也保证了以前没有使用泛型的库也可运行在JDK5之上
泛型擦除
为了保证兼容性，定义裸类型为所有该类型泛型化实例的共同父类型（Super Type），如下
ArrayList<Integer> ilist = new ArrayList<Integer>();
ArrayList<String> slist = new ArrayList<String>();
ArrayList list; // 裸类型
list = ilist;
list = slist;
在编译时把ArrayList<Integer>还原回ArrayList，在元素访问、修改时自动插入一些强制类型转换和检查指令
public static void main(String[] args) {
Map<String, String> map = new HashMap<String, String>();
map.put("hello", "你好");
map.put("how are you?", "吃了没？");
System.out.println(map.get("hello"));
System.out.println(map.get("how are you?"));
}
对于如上代码，编译成Class，再反编译，程序变回泛型出现之前的写法，泛型都变回了裸类型，在元素访问时插入强制转型代码
public static void main(String[] args) {
Map map = new HashMap();
map.put("hello", "你好");
map.put("how are you?", "吃了没？");
System.out.println((String) map.get("hello"));
System.out.println((String) map.get("how are you?"));
}
泛型缺点
泛型擦除无法支持原始类型，如下
ArrayList<int> list = new ArrayList<int>();
导致只能使用包装类型，运行速度慢
ArrayList<Integer> list = new ArrayList<Integer>();
运行时无法获取泛型类型信息
if (item instanceof E) { // 不合法，无法对泛型进行实例判断
}
E newItem = new E(); // 不合法，无法使用泛型创建对象
E[] itemArray = new E[10]; // 不合法，无法使用泛型创建数组
如写一个泛型版本的从List到数组的转换方法，需显式传递数组的组件类型componentType
public static <T> T[] convert(List<T> list, Class<T> componentType) {
T[] array = (T[])Array.newInstance(componentType, list.size());
}
为了在反射中获取参数化类型，新增Signature属性用于存储一个方法在字节码层面的特征签名，其包含了参数化类型的信息
其他
如下，包含泛型、自动装箱、自动拆箱、遍历循环与变长参数5种语法糖
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4);
int sum = 0;
for (int i : list) {
sum += i;
}
System.out.println(sum);
}
反编译后
- 自动装箱、拆箱转化为对应的包装和还原方法
- 遍历循环把代码还原成了迭代器实现
- 变长参数变成了一个数组类型的参数
public static void main(String[] args) {
List list = Arrays.asList( new Integer[] {
Integer.valueOf(1),
Integer.valueOf(2),
Integer.valueOf(3),
Integer.valueOf(4) });
int sum = 0;
for (Iterator localIterator = list.iterator(); localIterator.hasNext(); ) {
int i = ((Integer)localIterator.next()).intValue();
sum += i;
}
System.out.println(sum);
}
条件编译
使用条件为常量的if语句，会触发条件编译，如下
public static void main(String[] args) {
if (true) {
System.out.println("block 1");
} else {
System.out.println("block 2");
}
}
在编译时，就会优化
public static void main(String[] args) {
System.out.println("block 1");
}
若非if语句，则可能在控制流分析中提示错误且拒绝编译，如下
public static void main(String[] args) {
// 编译器将会提示“Unreachable code”
while (false) {
System.out.println("");
}
}
实战：插入式注解处理器
在前端编译这部分，可通过插入式注解处理器API影响Java编译子系统的行为
接下来基于插入式注解处理器API编写一个校验工具NameCheckProcessor规范书写格式：
- 类（或接口）：驼式命名法，首字母大写
- 方法：驼式命名法，首字母小写
- 类或实例变量：符合驼式命名法，首字母小写。
- 常量：由大写字母或下划线构成，首字符不能是下划线
代码实现
继承抽象类javax.annotation.processing.AbstractProcessor，实现抽象方法process()，其是Javac在执行注解处理器代码时的回调，如下，把当前轮次中的每一个RootElement传递到NameChecker执行名称检查逻辑
import java.util.Set;
import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
@SupportedAnnotationTypes("*") //设置要处理的注解
@SupportedSourceVersion(SourceVersion.RELEASE_6) //设置处理的Java版本
public class NameCheckProcessor extends AbstractProcessor {
private NameChecker nameChecker;
@Override
public void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
nameChecker = new NameChecker(processingEnv);
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (!roundEnv.processingOver()) {
for (Element element : roundEnv.getRootElements())
nameChecker.checkNames(element);
}
return false; //不需要改变或添加抽象语法树，返回false，编译器不构造新的JavaCompiler实例
}
}
- 域processingEnv是父类中的一个protected变量，用于创建新的代码、向编译器输出信息、获取其他工具类等
- visitType()、visitVariable()和visitExecutable()访问类、字段和方法
- checkCamelCase()与checkAllCaps()检查驼式命名法和全大写命名
import java.util.EnumSet;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.Name;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.ElementScanner6;
import javax.tools.Diagnostic;
public class NameChecker {
private final Messager messager;
NameCheckScanner nameCheckScanner = new NameCheckScanner();
NameChecker(ProcessingEnvironment processsingEnv) {
this.messager = processsingEnv.getMessager();
}
public void checkNames(Element element) {
nameCheckScanner.scan(element);
}
/**
* 名称检查器实现类，继承了JDK 6中的ElementScanner6
* 将会以Visitor模式访问抽象语法树中的元素
*/
private class NameCheckScanner extends ElementScanner6<Void, Void> {
/**
* 此方法用于检查Java类
*/
@Override
public Void visitType(TypeElement e, Void p) {
scan(e.getTypeParameters(), p);
checkCamelCase(e, true);
super.visitType(e, p);
return null;
}
/**
* 检查方法命名是否合法
*/
@Override
public Void visitExecutable(ExecutableElement e, Void p) {
if (e.getKind() == ElementKind.METHOD) {
Name name = e.getSimpleName();
if (name.contentEquals(e.getEnclosingElement().getSimpleName()))
messager.printMessage(Diagnostic.Kind.WARNING, "一个普通方法 “" + name + "”不应当与类名重复，避免与构造函数产生混淆", e);
checkCamelCase(e, false);
}
super.visitExecutable(e, p);
return null;
}
/**
* 检查变量命名是否合法
*/
@Override
public Void visitVariable(VariableElement e, Void p) {
// 如果这个Variable是枚举或常量，则按大写命名检查，否则按照驼式命名法规则检查
if (e.getKind() == ElementKind.ENUM_CONSTANT || e.getConstantValue() != null || heuristicallyConstant(e))
checkAllCaps(e);
else
checkCamelCase(e, false);
return null;
}
/**
* 判断一个变量是否是常量
*/
private boolean heuristicallyConstant(VariableElement e) {
if (e.getEnclosingElement().getKind() == ElementKind.INTERFACE)
return true;
else if (e.getKind() == ElementKind.FIELD && e.getModifiers().containsAll(EnumSet.of(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)))
return true;
else {
return false;
}
}
/**
* 检查传入的Element是否符合驼式命名法，如果不符合，则输出警告信息
*/
private void checkCamelCase(Element e, boolean initialCaps) {
String name = e.getSimpleName().toString();
boolean previousUpper = false;
boolean conventional = true;
int firstCodePoint = name.codePointAt(0);
if (Character.isUpperCase(firstCodePoint)) {
previousUpper = true;
if (!initialCaps) {
messager.printMessage(Diagnostic.Kind.WARNING, "名称“" + name + "”应当以小写字母开头", e);
return;
}
} else if (Character.isLowerCase(firstCodePoint)) {
if (initialCaps) {
messager.printMessage(Diagnostic.Kind.WARNING, "名称“" + name + "”应当以大写字母开头", e);
return;
}
} else
conventional = false;
if (conventional) {
int cp = firstCodePoint;
for (int i = Character.charCount(cp); i < name.length(); i += Character.charCount(cp)) {
cp = name.codePointAt(i);
if (Character.isUpperCase(cp)) {
if (previousUpper) {
conventional = false;
break;
}
previousUpper = true;
} else
previousUpper = false;
}
}
if (!conventional)
messager.printMessage(Diagnostic.Kind.WARNING, "名称“" + name + "”应当符合驼式命名法（Camel Case Names）", e);
}
/**
* 大写命名检查，要求第一个字母必须是大写的英文字母，其余部分可以是下划线或大写字母
*/
private void checkAllCaps(Element e) {
String name = e.getSimpleName().toString();
boolean conventional = true;
int firstCodePoint = name.codePointAt(0);
if (!Character.isUpperCase(firstCodePoint))
conventional = false;
else {
boolean previousUnderscore = false;
int cp = firstCodePoint;
for (int i = Character.charCount(cp); i < name.length(); i += Character.charCount(cp)) {
cp = name.codePointAt(i);
if (cp == (int) '_') {
if (previousUnderscore) {
conventional = false;
break;
}
previousUnderscore = true;
} else {
previousUnderscore = false;
if (!Character.isUpperCase(cp) && !Character.isDigit(cp)) {
conventional = false;
break;
}
}
}
}
if (!conventional)
messager.printMessage(Diagnostic.Kind.WARNING, "常量“" + name + "”应当全部以大写字母或下划线命名，并且以字母开头", e);
}
}
}
验证
使用如下代码验证
public class BADLY_NAMED_CODE {
enum colors {
red, blue, green;
}
static final int _FORTY_TWO = 42;
public static int NOT_A_CONSTANT = _FORTY_TWO;
protected void BADLY_NAMED_CODE() {
return;
}
public void NOTcamelCASEmethodNAME() {
return;
}
}
利用上面导入的Javac，参数-processor指定执行编译时需要附带的注解处理器（有多个用逗号分隔）
javac src/com/sun/NameChecker.java
javac src/com/sun/NameCheckProcessor.java
javac -processor com.sun.NameCheckProcessor src/com/sun/BADLY_NAMED_CODE.java
输出如下
