APT你真的了解嗎？決議Javac原始碼APT執行原理-有解無憂

前言

最近又到了面試季，大家的技術都在提升，如果自己還是原地踏步，作業10年還是在用著剛作業1-2年的技術在應對現在的開發，所以很多同學的感受是：面試一年比一年“難”，在和一些同學的交流中，感覺很多同學的技術并不扎實，對于很多技術聽說過，也大致寫過Demo，就認為自己懂了，比如這次和大家分享的APT，小公司不會問，大公司要問就不再是怎么使用這么簡單了，

但是在網上搜索了一個圈都沒發現有針對APT原理分析的文章，所以本篇檔案我們就根據javac原始碼徹底搞清楚APT的執行與設計，

閱讀前提

1、了解APT是什么？
2、基于APT能夠做什么？（應用場景）
3、怎么使用（撰寫自己的）APT程式，

解決問題

1、APT原理是什么，怎么被執行起來的？
2、APT中process方法到底執行幾次？為什么這么設計？
3、APT中process方法boolean回傳值回傳true或者false有什么影響？

APT原理

大家在Android Studio上開發，可以創建一個java模塊來實作APT，在這個模塊中寫一個類繼承AbstractProcessor，同時還要進行注冊，注冊可以采用兩種方式：

1、手動
在src/main目錄下，創建resources/META-INF/services/javax.annotation.processing.Processor 檔案，在檔案里寫上APT的實作類（AbstractProcessor子類）全限定名，

2、自動
在APT模塊中引入Google的AutoService，使用@AutoService(Processor.class)注解宣告APT的實作類（AbstractProcessor子類）, AutoService本質上也是利用APT技術來自動創建了第一種方式的注冊檔案，

大家請注意，@AutoService傳的是Processor.class，而手動創建的方式寫的檔案名其實就是Processor類的全限定名，

其實javac認定的注解處理器是實作了 Processor介面的類，我們一般繼承的AbstractProcessor就是實作了Processor介面，

在完成了APT程式的實作以及注冊之后，接下來我們可以直接利用Gradle的依賴配置組：annotationProcessor引入我們的APT模塊，也可以將APT模塊打包出單獨的Jar包程式，利用javac -processorpath xxx.jar(APT) 對指定的java源檔案進行編譯，

其實到這里，APT怎么被執行起來的已經很明顯了，APT程式就是Javac的小插件，由javac在編譯時候根據條件調起！具體的執行程序可以結合javac原始碼進一步了解，

Javac執行追溯

javac本身也是一個計算機程式，當需要編譯java源代碼時就需要執行程式，而javac程式的main函式定義在com/sun/tools/javac/Main.java中：

public class Main {
?
    public static void main(String[] args) throws Exception {
        System.exit(compile(args));
    }
?
    public static int compile(String[] args) {
        com.sun.tools.javac.main.Main compiler =
            new com.sun.tools.javac.main.Main("javac");
        return compiler.compile(args).exitCode;
    }
?
?
    public static int compile(String[] args, PrintWriter out) {
        com.sun.tools.javac.main.Main compiler =
            new com.sun.tools.javac.main.Main("javac", out);
        return compiler.compile(args).exitCode;
    }
}

可以看到，當執行javac程式將會執行上面的main方法，而main方法會呼叫到compile方法，在compile方法中又會創建com.sun.tools.javac.main.Main并執行其compile方法，

打開com/sun/tools/javac/main/Main.java檔案，其compile實作為：

public Result compile(String[] args) {
        Context context = new Context();
        JavacFileManager.preRegister(context); 
    // 呼叫兩參的多載compile方法
    Result result = compile(args, context);
    if (fileManager instanceof JavacFileManager) {
        ((JavacFileManager)fileManager).close();
    }
    return result;
}
?
public Result compile(String[] args, Context context) {
        // 最后一個引數：processors 本次編譯要執行的注解處理器集合 直接置為null
        return compile(args, context, List.<JavaFileObject>nil(), null);
}
?
?
public Result compile(String[] args,
                       Context context,
                       List<JavaFileObject> fileObjects,
                       Iterable<? extends Processor> processors){
        return compile(args,  null, context, fileObjects, processors);
}
public Result compile(String[] args,
                          String[] classNames,
                          Context context,
                          List<JavaFileObject> fileObjects,
                          Iterable<? extends Processor> processors){
    //......
?
    comp = JavaCompiler.instance(context);
    //......
    comp.compile(fileObjects,
                         classnames.toList(),
                         processors);
?
    //......
}

具體的編譯是通過JavaCompiler#compile完成，這個方法的第三個引數即為要執行的注解處理器集合，根據執行流程追溯，此處直接傳遞的為null，進一步進入com/sun/tools/javac/main/JavaCompiler.java

public void compile(List sourceFileObjects,
List classnames,
Iterable<? extends Processor> processors){
//......
//初始化
initProcessAnnotations(processors);
//執行注解處理器
delegateCompiler =
            processAnnotations(
                enterTrees(stopIfError(CompileState.PARSE, parseFiles(sourceFileObjects))),
                classnames);
//......
}

初始化

終于在JavaCompiler#compile方法中找到了javac執行程序中對APT的處理，首先initProcessAnnotations方法實作了對APT的初始化，根據原始碼流程可知此時，該方法引數為要執行的注解處理器集合，當前其實被設定為null，

那initProcessAnnotations方法中會怎么初始化我們的APT程式呢？實際上，在一開始我們說APT程式就是Javac的小插件，由javac在編譯時候根據條件調起！那么既然javac要調起APT中AbstractProcessor的process方法，而process方法是實體方法，自然需要先實作對APT中的AbstractProcessor（Processor介面）實作類class物件的加載，

而這個實作類由我們撰寫，javac如何得知要加載的APT實作類的類名呢？

結合到文章最開頭處APT的注冊，相信基礎扎實的同學馬上就能夠想到：Java SPI機制，實際上，javac就是利用ServiceLoader加載注冊檔案，從而得到了APT實作類的類名！

很多同學聽到AutoService就只能想到APT，這是片面的，實際上AutoService就是利用APT技術完成對Java SPI機制組態檔的自動生成，
ServiceLoader原始碼非常簡單，Java與Android的實作也沒有差異，可以自行閱讀，

public void initProcessAnnotations(Iterable<? extends Processor> processors) {
      //......
      procEnvImpl = JavacProcessingEnvironment.instance(context);
      procEnvImpl.setProcessors(processors); 
      //......
}

進入com/sun/tools/javac/processing/JavacProcessingEnvironment.java檔案:

public void setProcessors(Iterable<? extends Processor> processors) {
        Assert.checkNull(discoveredProcs);
        initProcessorIterator(context, processors);
}
private void initProcessorIterator(Context context, Iterable<? extends Processor> processors) {
        Log log = Log.instance(context);
        //要執行的注解處理器集合
        Iterator<? extends Processor> processorIterator;
        //....
        // ServiceIterator 使用SPI機制（ServiceLoader）加載注冊檔案并創建APT實作類實體物件
        processorIterator = new ServiceIterator(processorClassLoader, log);
        //....
        discoveredProcs = new DiscoveredProcessors(processorIterator);
}

執行注解處理器

回到JavaCompiler#compile，在通過initProcessAnnotations初始化注解處理器后，接著執行processAnnotations實作對注解的處理，

public JavaCompiler processAnnotations(List<JCCompilationUnit> roots,
                                           List<String> classnames) {
    //......
    JavaCompiler c = procEnvImpl.doProcessing(context, roots, classSymbols, pckSymbols,
                        deferredDiagnosticHandler);
    //......
}

進入com/sun/tools/javac/processing/JavacProcessingEnvironment.java檔案:

 public JavaCompiler doProcessing(Context context,
                                     List<JCCompilationUnit> roots,
                                     List<ClassSymbol> classSymbols,
                                     Iterable<? extends PackageSymbol> pckSymbols,
                                     Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
    Round round = new Round(context, roots, classSymbols, deferredDiagnosticHandler);
    boolean errorStatus;
    boolean moreToDo;
    do {
        // 第一次執行apt
        round.run(false, false);
        errorStatus = round.unrecoverableError();
        moreToDo = moreToDo(); //執行apt后是否還需要再次執行
        round = round.next(
                    new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
                    new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));
        if (round.unrecoverableError())
            errorStatus = true;
?
    } while (moreToDo && !errorStatus);
?
    // 最后一次執行apt
    round.run(true, errorStatus);
    //......
}

此處代碼包含了本文需要解決的第2、3個檔案，注解處理器的執行是由javac調起我們APT實作類的process方法，而這個方法就是在round.run中調起的，

第一次執行
第一次執行process方法是在do-while中調起round.run(false, false)完成，

void run(boolean lastRound, boolean errorStatus) {
    try {
        if (lastRound) {
            filer.setLastRound(true);
            Set<Element> emptyRootElements = Collections.emptySet(); // immutable
            RoundEnvironment renv = new JavacRoundEnvironment(true,
                            errorStatus,
                            emptyRootElements,
                            JavacProcessingEnvironment.this);
             //只有最后一次執行此處
            discoveredProcs.iterator().runContributingProcs(renv);
        } else {
            //不是最后一次執行此處
            discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
        }
        } catch (Throwable t) {
             //.......
        } finally {
            //.......
        }
}

如果我們的APT實作類將會被javac調起process方法，它的原型是：
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment)
在編譯程序中第一次由discoverAndRunProcs調起：

 private void discoverAndRunProcs(Context context,
                                     Set<TypeElement> annotationsPresent,
                                     List<ClassSymbol> topLevelClasses,
                                     List<PackageSymbol> packageInfoFiles) {
        //......
        //呼叫APT實作類的process方法的引數
        RoundEnvironment renv = new JavacRoundEnvironment(false,
                                                          false,
                                                          rootElements,
                                                          JavacProcessingEnvironment.this);
?
        while(unmatchedAnnotations.size() > 0 && psi.hasNext() ) {
            ProcessorState ps = psi.next();
            Set<String>  matchedNames = new HashSet<String>();
            Set<TypeElement> typeElements = new LinkedHashSet<TypeElement>();
?
            for (Map.Entry<String, TypeElement> entry: unmatchedAnnotations.entrySet()) {
                String unmatchedAnnotationName = entry.getKey();
                //匹配apt實作類支持的注解
                if (ps.annotationSupported(unmatchedAnnotationName) ) {
                    matchedNames.add(unmatchedAnnotationName);
                    //呼叫APT實作類的process方法的引數
                    TypeElement te = entry.getValue();
                    if (te != null)
                        typeElements.add(te);
                }
            }
?
            if (matchedNames.size() > 0 || ps.contributed) {
                //執行注解處理器
                boolean processingResult = callProcessor(ps.processor, typeElements, renv);
                /**
                 * TODO 問題3 
                 * APT實作類回傳值為ture，洗掉它能處理的注解資訊,
                 * 這樣其他需要處理相同注解的注解處理器就得不到執行了
                 */
                if (processingResult) {
                    // unmatchedAnnotations : 所有的注解集合
                    // matchedNames:匹配此注解處理器的注解
                    unmatchedAnnotations.keySet().removeAll(matchedNames);
                }
?
            }
        }
    //......
}
?
private boolean callProcessor(Processor proc,Set<? extends TypeElement> tes,
                              RoundEnvironment renv) {
    return proc.process(tes, renv);
        
}

process方法回傳值

其實到現在，我們已經看到文章開頭的第三個問題的答案，

在javac執行時可以指定多個APT程式(-processorpath 指定的jar包)，一個APT程式可以包含多個APT實作類，所以javac會將指定的多個APT程式中的所有注冊的APT實作類加載并實體化，使用迭代器Iterator裝載，

在discoverAndRunProcs中對所有要執行的APT實作類進行迭代，依次執行APT實作類的process方法，順序由注冊順序決定，

但是執行APT實作類的前提是：有APT實作類宣告的支持處理的注解資訊，而若先注冊的APT實作類其process方法回傳true，則會在執行結束此APT實作類后，通過
unmatchedAnnotations.keySet().removeAll(matchedNames);將其能處理的注解資訊洗掉，這樣后注冊的APT實作類將會因為沒有匹配處理的注解而得不到執行，

比如AProcessor宣告處理@Test注解，而BProcessor也宣告處理@Test注解，而AProcessor先于BProcessor注冊，AProcessor的process方法回傳ture，此時BProcessor不會執行，

第2-N次執行
回到JavacProcessingEnvironment#doProcessing

public JavaCompiler doProcessing(Context context,
                                     List<JCCompilationUnit> roots,
                                     List<ClassSymbol> classSymbols,
                                     Iterable<? extends PackageSymbol> pckSymbols,
                                     Log.DeferredDiagnosticHandler deferredDiagnosticHandler) {
    Round round = new Round(context, roots, classSymbols, deferredDiagnosticHandler);
    boolean errorStatus;
    boolean moreToDo;
    do {
        // 第一次執行apt
        round.run(false, false);
        errorStatus = round.unrecoverableError();
        moreToDo = moreToDo(); //執行apt后是否還需要再次執行
        round = round.next(
                    new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
                    new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));
        if (round.unrecoverableError())
            errorStatus = true;
?
    } while (moreToDo && !errorStatus);
?
    // 最后一次執行apt
    round.run(true, errorStatus);
    //......
}

round.run(false, false);是在do-while回圈中被呼叫，這也是為什么本節小標題為：第2-N次執行，執行多輪的條件為：moreToDo && !errorStatus，

第二個條件是執行APT實作類時未產生例外，而第一個條件：moreTodo

private boolean moreToDo() {
    return filer.newFiles();
}
public boolean newFiles() {
    return (!generatedSourceNames.isEmpty())
            || (!generatedClasses.isEmpty());
}

如果熟悉APT的同學，應該清楚，一般的我們利用APT實作在編譯階段生成新的Java類：
//在apt中生成 Test.java

JavaFileObject sourceFile = processingEnv.getFiler()
                        .createSourceFile("com.xx.Test");
OutputStream os = sourceFile.openOutputStream();
os.write("package com.xx;\n  public class Test{}".getBytes());
os.close();

JavaPoet框架實際上就是封裝了這些API，所以學習技識訓是應該掌握本質與原理，否則學習其他相關聯或者類似技術時，只能從頭開始，很吃力，這也是所謂面試八股文的意義，掌握和沒掌握，確實有差別！

在執行到os.close()時就會執行一次generatedSourceNames.add(typeName)，

也就是說APT執行多次的條件是：在APT執行是生成了一個java源檔案(或者class檔案)都會導致APT再執行一次，這次執行只會處理新生成的類：

//只處理新生成類的round
round = round.next( new LinkedHashSet<JavaFileObject>(filer.getGeneratedSourceFileObjects()),
                    new LinkedHashMap<String,JavaFileObject>(filer.getGeneratedClasses()));
//執行apt
round.run(false, false);

而如果第二輪執行又新生成了類，就會執行第三輪、第四輪…，直到不再產生新的.java（或.class）

最后一次執行

不產生新的類檔案時會退出do-While回圈，此時會執行一次round.run(true, errorStatus);

void run(boolean lastRound, boolean errorStatus) {
    try {
        if (lastRound) {
            filer.setLastRound(true);
            Set<Element> emptyRootElements = Collections.emptySet(); // immutable
            RoundEnvironment renv = new JavacRoundEnvironment(true,
                            errorStatus,
                            emptyRootElements,
                            JavacProcessingEnvironment.this);
             //只有最后一次執行此處
            discoveredProcs.iterator().runContributingProcs(renv);
        } else {
            //不是最后一次執行此處
            discoverAndRunProcs(context, annotationsPresent, topLevelClasses, packageInfoFiles);
        }
        } catch (Throwable t) {
             //.......
        } finally {
            //.......
        }
}

此時，會通過discoveredProcs.iterator().runContributingProcs(renv);執行最后一輪APT，

public void runContributingProcs(RoundEnvironment re) {
    if (!onProcInterator) {
        // process方法第一個引數
        Set<TypeElement> emptyTypeElements = Collections.emptySet();
        while(innerIter.hasNext()) {
            ProcessorState ps = innerIter.next();
             //執行最后一輪
            if (ps.contributed)
                callProcessor(ps.processor, emptyTypeElements, re);
        }
    }
}

可以看到在執行最后一輪時，會構建一個空Set集合作為process方法的第一個引數，這么做的意義猜測是為了將作業和打掃分開，

第一輪執行：處理你的作業

第X輪執行: 處理你的作業

最后執行：在處理完作業之后，再通知一次，執行收尾，
如：

public class LanceProcessor extends AbstractProcessor {
?
    FileOutputStream fos;
    int i = 0;
?
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        //最后一輪執行會為true
        if (roundEnvironment.processingOver()) {
            if (fos != null) {
                //最后一輪收尾，close
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        } else {
            if (fos == null) {
                // 只在第一輪執行初始化，
                fos = new FileOutputStream(xxx);
            }
        }
        fos.write(("第" + i + "次執行").getBytes());
        i++;
        //......
        return true;
    }
}

總結

Q：APT原理是什么，怎么被執行起來的？

A：在javac編譯時，先通過SPI機制加載所有的APT實作類，并將決議到需要編譯的java源檔案中所有的注解資訊，與APT宣告的支持處理的注解資訊進行匹配，若待編譯的源檔案中存在APT宣告的注解，則調起APT實作類的process方法，

Q：APT中process方法到底執行幾次？為什么這么設計？

A：最少執行兩次，最多無數次，最后一次執行可以視為Finish結束通知，執行收尾作業，

Q：APT中process方法boolean回傳值回傳true或者false有什么影響？

A： true：宣告的注解只能被當前APT處理；false：在當前APT處理完宣告的注解后，仍能被其他APT處理

最后

小編在網上收集了一些 Android 開發相關的學習檔案、面試題、Android 核心筆記等等檔案，希望能幫助到大家學習提升，如有需要學習參考的可以直接點擊下方小卡片進行訪問查閱，

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/303909.html

標籤：其他

上一篇：這個神器，把打包Python腳本為Exe的流程都封裝好了

下一篇：Android Studio 理解com.android.support:appcompat-v7:x.x.x依賴包(建議收藏)