JDK 6 提供了在運行時調用編譯器的 API,後面我們將假設把此 API 應用在 JSP 技術中。在傳統的 JSP 技術中,服務器處理 JSP 通常需要進行下面 6 個步驟:
- 分析 JSP 代碼;
- 生成 Java 代碼;
- 將 Java 代碼寫入存儲器;
- 啓動另外一個進程並運行編譯器編譯 Java 代碼;
- 將類文件寫入存儲器;
- 服務器讀入類文件並運行;
但如果採用運行時編譯,可以同時簡化步驟 4 和 5,節約新進程的開銷和寫入存儲器的輸出開銷,提高系統效率。實際上,在 JDK 5 中,Sun 也提供了調用編譯器的編程接口。然而不同的是,老版本的編程接口並不是標準 API 的一部分,而是作爲 Sun 的專有實現提供的,而新版則帶來了標準化的優點。
新 API 的第二個新特性是可以編譯抽象文件,理論上是任何形式的對象 —— 只要該對象實現了特定的接口。有了這個特性,上述例子中的步驟 3 也可以省略。整個 JSP 的編譯運行在一個進程中完成,同時消除額外的輸入輸出操作。
第三個新特性是可以收集編譯時的診斷信息。作爲對前兩個新特性的補充,它可以使開發人員輕鬆的輸出必要的編譯錯誤或者是警告信息,從而省去了很多重定向的麻煩。
|
在 JDK 6 中,類庫通過 javax.tools
包提供了程序運行時調用編譯器的 API。從這個包的名字 tools 可以看出,這個開發包提供的功能並不僅僅限於編譯器。工具還包括 javah、jar、pack200 等,它們都是 JDK 提供的命令行工具。這個開發包希望通過實現一個統一的接口,可以在運行時調用這些工具。在 JDK 6 中,編譯器被給予了特別的重視。針對編譯器,JDK 設計了兩個接口,分別是 JavaCompiler
和 JavaCompiler.CompilationTask
。
下面給出一個例子,展示如何在運行時調用編譯器。
- 指定編譯文件名稱(該文件必須在 CLASSPATH 中可以找到):
String fullQuanlifiedFileName = "compile" + java.io.File.separator +"Target.java";
- 獲得編譯器對象:
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
通過調用 ToolProvider
的 getSystemJavaCompiler
方法,JDK 提供了將當前平臺的編譯器映射到內存中的一個對象。這樣使用者可以在運行時操縱編譯器。JavaCompiler
是一個接口,它繼承了 javax.tools.Tool
接口。因此,第三方實現的編譯器,只要符合規範就能通過統一的接口調用。同時,tools 開發包希望對所有的工具提供統一的運行時調用接口。相信將來,ToolProvider
類將會爲更多地工具提供 getSystemXXXTool
方法。tools 開發包實際爲多種不同工具、不同實現的共存提供了框架。
- 編譯文件:
int result = compiler.run(null, null, null, fileToCompile);
獲得編譯器對象之後,可以調用 Tool.run
方法對源文件進行編譯。Run
方法的前三個參數,分別可以用來重定向標準輸入、標準輸出和標準錯誤輸出,null
值表示使用默認值。清單 1 給出了一個完整的例子:
清單 1. 程序運行時編譯文件
01 package compile; 02 import java.util.Date; 03 public class Target { 04 public void doSomething(){ 05 Date date = new Date(10, 3, 3); // 這個構造函數被標記爲deprecated, 編譯時會 // 向錯誤輸出輸出信息。 06 System.out.println("Doing..."); 07 } 08 } 09 package compile; 10 import javax.tools.*; 11 import java.io.FileOutputStream; 12 public class Compiler { 13 public static void main(String[] args) throws Exception{ 14 String fullQuanlifiedFileName = "compile" + java.io.File.separator + "Target.java"; 15 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 16 FileOutputStream err = new FileOutputStream("err.txt"); 17 int compilationResult = compiler.run(null, null, err, fullQuanlifiedFileName); 18 if(compilationResult == 0){ 19 System.out.println("Done"); 20 } else { 21 System.out.println("Fail"); 22 } 23 } 24 } |
首先運行 <JDK60_INSTALLATION_DIR>/bin/javac Compiler.java,然後運行 <JDK60_INSTALLATION_DIR>/jdk1.6.0/bin/java compile.Compiler。屏幕上將輸出 Done
,並會在當前目錄生成一個 err.txt 文件,文件內容如下:
Note: compile/Target.java uses or overrides a deprecated API. Note: Recompile with -Xlint:deprecation for details. |
仔細觀察 run
方法,可以發現最後一個參數是 String...arguments
,是一個變長的字符串數組。它的實際作用是接受傳遞給 javac 的參數。假設要編譯 Target.java 文件,並顯示編譯過程中的詳細信息。命令行爲:javac Target.java -verbose
。相應的可以將 17 句改爲:
int compilationResult = compiler.run(null, null, err, “-verbose”,fullQuanlifiedFileName); |
|
JDK 6 的編譯器 API 的另外一個強大之處在於,它可以編譯的源文件的形式並不侷限於文本文件。JavaCompiler
類依靠文件管理服務可以編譯多種形式的源文件。比如直接由內存中的字符串構造的文件,或者是從數據庫中取出的文件。這種服務是由 JavaFileManager
類提供的。通常的編譯過程分爲以下幾個步驟:
- 解析 javac 的參數;
- 在 source path 和/或 CLASSPATH 中查找源文件或者 jar 包;
- 處理輸入,輸出文件;
在這個過程中,JavaFileManager
類可以起到創建輸出文件,讀入並緩存輸出文件的作用。由於它可以讀入並緩存輸入文件,這就使得讀入各種形式的輸入文件成爲可能。JDK 提供的命令行工具,處理機制也大致相似,在未來的版本中,其它的工具處理各種形式的源文件也成爲可能。爲此,新的 JDK 定義了 javax.tools.FileObject
和 javax.tools.JavaFileObject
接口。任何類,只要實現了這個接口,就可以被 JavaFileManager
識別。
如果要使用 JavaFileManager
,就必須構造 CompilationTask
。JDK 6 提供了 JavaCompiler.CompilationTask
類來封裝一個編譯操作。這個類可以通過:
JavaCompiler.getTask ( Writer out, JavaFileManager fileManager, DiagnosticListener<? super JavaFileObject> diagnosticListener, Iterable<String> options, Iterable<String> classes, Iterable<? extends JavaFileObject> compilationUnits ) |
方法得到。關於每個參數的含義,請參見 JDK 文檔。傳遞不同的參數,會得到不同的 CompilationTask
。通過構造這個類,一個編譯過程可以被分成多步。進一步,CompilationTask
提供了 setProcessors(Iterable<? extends Processor>processors)
方法,用戶可以制定處理 annotation 的處理器。圖 1 展示了通過 CompilationTask
進行編譯的過程:
圖 1. 使用 CompilationTask 進行編譯
下面的例子通過構造 CompilationTask
分多步編譯一組 Java 源文件。
清單 2. 構造 CompilationTask 進行編譯
01 package math; 02 public class Calculator { 03 public int multiply(int multiplicand, int multiplier) { 04 return multiplicand * multiplier; 05 } 06 } 07 package compile; 08 import javax.tools.*; 09 import java.io.FileOutputStream; 10 import java.util.Arrays; 11 public class Compiler { 12 public static void main(String[] args) throws Exception{ 13 String fullQuanlifiedFileName = "math" + java.io.File.separator +"Calculator.java"; 14 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 15 StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); 16 Iterable<? extends JavaFileObject> files = fileManager.getJavaFileObjectsFromStrings( Arrays.asList(fullQuanlifiedFileName)); 17 JavaCompiler.CompilationTask task = compiler.getTask( null, fileManager, null, null, null, files); 18 Boolean result = task.call(); 19 if( result == true ) { 20 System.out.println("Succeeded"); 21 } 22 } 23 } |
以上是第一步,通過構造一個 CompilationTask
編譯了一個 Java 文件。14-17 行實現了主要邏輯。第 14 行,首先取得一個編譯器對象。由於僅僅需要編譯普通文件,因此第 15 行中通過編譯器對象取得了一個標準文件管理器。16 行,將需要編譯的文件構造成了一個 Iterable
對象。最後將文件管理器和 Iterable
對象傳遞給 JavaCompiler
的 getTask
方法,取得了 JavaCompiler.CompilationTask
對象。
接下來第二步,開發者希望生成 Calculator
的一個測試類,而不是手工編寫。使用 compiler API,可以將內存中的一段字符串,編譯成一個 CLASS 文件。
清單 3. 定製 JavaFileObject 對象
01 package math; 02 import java.net.URI; 03 public class StringObject extends SimpleJavaFileObject{ 04 private String contents = null; 05 public StringObject(String className, String contents) throws Exception{ 06 super(new URI(className), Kind.SOURCE); 07 this.contents = contents; 08 } 09 public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException { 10 return contents; 11 } 12 } |
SimpleJavaFileObject
是 JavaFileObject
的子類,它提供了默認的實現。繼承 SimpleJavaObject
之後,只需要實現 getCharContent
方法。如 清單 3 中的 9-11 行所示。接下來,在內存中構造 Calculator
的測試類 CalculatorTest
,並將代表該類的字符串放置到 StringObject
中,傳遞給 JavaCompiler
的 getTask
方法。清單 4 展現了這些步驟。
清單 4. 編譯非文本形式的源文件
01 package math; 02 import javax.tools.*; 03 import java.io.FileOutputStream; 04 import java.util.Arrays; 05 public class AdvancedCompiler { 06 public static void main(String[] args) throws Exception{ 07 // Steps used to compile Calculator 08 // Steps used to compile StringObject 09 // construct CalculatorTest in memory 10 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 11 StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); 12 JavaFileObject file = constructTestor(); 13 Iterable<? extends JavaFileObject> files = Arrays.asList(file); 14 JavaCompiler.CompilationTask task = compiler.getTask ( null, fileManager, null, null, null, files); 15 Boolean result = task.call(); 16 if( result == true ) { 17 System.out.println("Succeeded"); 18 } 19 } 20 private static SimpleJavaFileObject constructTestor() { 21 StringBuilder contents = new StringBuilder( "package math;" + "class CalculatorTest {/n" + " public void testMultiply() {/n" + " Calculator c = new Calculator();/n" + " System.out.println(c.multiply(2, 4));/n" + " }/n" + " public static void main(String[] args) {/n" + " CalculatorTest ct = new CalculatorTest();/n" + " ct.testMultiply();/n" + " }/n" + "}/n"); 22 StringObject so = null; 23 try { 24 so = new StringObject("math.CalculatorTest", contents.toString()); 25 } catch(Exception exception) { 26 exception.printStackTrace(); 27 } 28 return so; 29 } 30 } |
實現邏輯和 清單 2 相似。不同的是在 20-30 行,程序在內存中構造了 CalculatorTest
類,並且通過 StringObject
的構造函數,將內存中的字符串,轉換成了 JavaFileObject
對象。
|
第三個新增加的功能,是收集編譯過程中的診斷信息。診斷信息,通常指錯誤、警告或是編譯過程中的詳盡輸出。JDK 6 通過 Listener
機制,獲取這些信息。如果要註冊一個 DiagnosticListener
,必須使用 CompilationTask
來進行編譯,因爲 Tool 的 run
方法沒有辦法註冊 Listener
。步驟很簡單,先構造一個 Listener
,然後傳遞給 JavaFileManager
的構造函數。清單 5 對 清單 2 進行了改動,展示瞭如何註冊一個 DiagnosticListener
。
清單 5. 註冊一個 DiagnosticListener 收集編譯信息
01 package math; 02 public class Calculator { 03 public int multiply(int multiplicand, int multiplier) { 04 return multiplicand * multiplier // deliberately omit semicolon, ADiagnosticListener // will take effect 05 } 06 } 07 package compile; 08 import javax.tools.*; 09 import java.io.FileOutputStream; 10 import java.util.Arrays; 11 public class CompilerWithListener { 12 public static void main(String[] args) throws Exception{ 13 String fullQuanlifiedFileName = "math" + java.io.File.separator +"Calculator.java"; 14 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); 15 StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null); 16 Iterable<? extends JavaFileObject> files = fileManager.getJavaFileObjectsFromStrings( Arrays.asList(fullQuanlifiedFileName)); 17 DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector<JavaFileObject>(); 18 JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, collector, null, null, files); 19 Boolean result = task.call(); 20 List<Diagnostic<? extends JavaFileObject>> diagnostics = collector.getDiagnostics(); 21 for(Diagnostic<? extends JavaFileObject> d : diagnostics){ 22 System.out.println("Line Number->" + d.getLineNumber()); 23 System.out.println("Message->"+ d.getMessage(Locale.ENGLISH)); 24 System.out.println("Source" + d.getCode()); 25 System.out.println("/n"); 26 } 27 if( result == true ) { 28 System.out.println("Succeeded"); 29 } 30 } 31 } |
在 17 行,構造了一個 DiagnosticCollector
對象,這個對象由 JDK 提供,它實現了 DiagnosticListener
接口。18 行將它註冊到 CompilationTask
中去。一個編譯過程可能有多個診斷信息。每一個診斷信息,被抽象爲一個 Diagnostic
。20-26 行,將所有的診斷信息逐個輸出。編譯並運行 Compiler,得到以下輸出:
清單 6. DiagnosticCollector 收集的編譯信息
Line Number->5 Message->math/Calculator.java:5: ';' expected Source->compiler.err.expected |
實際上,也可以由用戶自己定製。清單 7 給出了一個定製的 Listener
。
清單 7. 自定義的 DiagnosticListener
01 class ADiagnosticListener implements DiagnosticListener<JavaFileObject>{ 02 public void report(Diagnostic<? extends JavaFileObject> diagnostic) { 03 System.out.println("Line Number->" + diagnostic.getLineNumber()); 04 System.out.println("Message->"+ diagnostic.getMessage(Locale.ENGLISH)); 05 System.out.println("Source" + diagnostic.getCode()); 06 System.out.println("/n"); 07 } 08 } |
|
JDK 6 的編譯器新特性,使得開發者可以更自如的控制編譯的過程,這給了工具開發者更加靈活的自由度。通過 API 的調用完成編譯操作的特性,使得開發者可以更方便、高效地將編譯變爲軟件系統運行時的服務。而編譯更廣泛形式的源代碼,則爲整合更多的數據源及功能提供了強大的支持。相信隨着 JDK 的不斷完善,更多的工具將具有 API 支持,我們拭目以待。
摘自:http://www.ibm.com/developerworks/cn/java/j-lo-jse64/index.html