Java自定義註解入門之源碼編譯階段

環境

MacBook Pro
Java：1.8
gradle：5.5.1

前言

公司封裝了一個@slf4j，用於日誌打印；
最近研究了下這個註解，瞭解到了AST，抽象樹這個概念；
明白了lombok這樣的插件也是利用這個技術來實現的；
在研究過程中，被下面這個錯卡了很久：

錯誤: 程序包com.sun.source.tree不存在
import com.sun.source.tree.Tree;

特意記錄下；

抽象語法樹 AST

自己的話：

用代碼去描述代碼的結構

編程語言有很多，但是基本都是：類型、運算符、函數、對象，流程語句組成的本質；

那該如何表示這些本質性的東西呢？

答案：轉化爲統一結構；

… 未完

簡單列子

項目結構

 processor 
		|
		|--src
		|   |--java
		|		|--com
		|			|--hello
		|				|--Person
		|
		|
		|
		|
		|--myprocessor
				|-- src
					 |--main
					 	 |--java
					 	 	 |-- com.processor
					 	 	 		|-- MyGetterProcessor
					 	 	 		|-- MyGetter

創建項目

下一步

再點下一步後，再點擊Finish即可。

創建module

這個module是專門用來存放自定義註解和自定義註解處理器的。

先點擊項目名，再

下一步後，再點擊Finish即可。

自定義註解

在myprocessor模塊中創建MyGetter註解

package com.processor;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author yutao
 * @since 2020/5/9 4:46 下午
 */
@Retention(RetentionPolicy.SOURCE) // 註解只在源碼中保留
@Target(ElementType.TYPE) // 用於修飾類
public @interface MyGetter {
}

創建註解處理器

package com.processor;

import com.sun.source.tree.Tree;
import com.sun.tools.javac.api.JavacTrees;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.TreeTranslator;
import com.sun.tools.javac.util.*;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import java.util.Set;

/**
 * @author yutao
 * @since 2020/5/9 4:47 下午
 */
@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes("com.processor.MyGetter")
public class MyGetterProcessor extends AbstractProcessor {

    private Messager messager; // 編譯時期輸入日誌的
    private JavacTrees javacTrees; // 提供了待處理的抽象語法樹
    private TreeMaker treeMaker; // 封裝了創建AST節點的一些方法
    private Names names; // 提供了創建標識符的方法

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.messager = processingEnv.getMessager();
        this.javacTrees = JavacTrees.instance(processingEnv);
        Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
        this.treeMaker = TreeMaker.instance(context);
        this.names = Names.instance(context);
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(MyGetter.class);
        elementsAnnotatedWith.forEach(e -> {
            JCTree tree = javacTrees.getTree(e);
            tree.accept(new TreeTranslator() {
                @Override
                public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
                    List<JCTree.JCVariableDecl> jcVariableDeclList = List.nil();
                    // 在抽象樹中找出所有的變量
                    for (JCTree jcTree : jcClassDecl.defs) {
                        if (jcTree.getKind().equals(Tree.Kind.VARIABLE)) {
                            JCTree.JCVariableDecl jcVariableDecl = (JCTree.JCVariableDecl) jcTree;
                            jcVariableDeclList = jcVariableDeclList.append(jcVariableDecl);
                        }
                    }
                    // 對於變量進行生成方法的操作
                    jcVariableDeclList.forEach(jcVariableDecl -> {
                        messager.printMessage(Diagnostic.Kind.NOTE, jcVariableDecl.getName() + " has been processed");
                        jcClassDecl.defs = jcClassDecl.defs.prepend(makeGetterMethodDecl(jcVariableDecl));
                    });
                    super.visitClassDef(jcClassDecl);
                }
            });
        });
        return true;
    }

    private JCTree.JCMethodDecl makeGetterMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {
        ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
        // 生成表達式 例如 this.a = a;
        JCTree.JCExpressionStatement aThis = makeAssignment(treeMaker.Select(treeMaker.Ident(
                names.fromString("this")), jcVariableDecl.getName()), treeMaker.Ident(jcVariableDecl.getName()));
        statements.append(aThis);
        JCTree.JCBlock block = treeMaker.Block(0, statements.toList());

        // 生成入參
        JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER),
                jcVariableDecl.getName(), jcVariableDecl.vartype, null);
        List<JCTree.JCVariableDecl> parameters = List.of(param);

        // 生成返回對象
        JCTree.JCExpression methodType = treeMaker.Type(new Type.JCVoidType());
        return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),
                getNewMethodName(jcVariableDecl.getName()), methodType, List.nil(),
                parameters, List.nil(), block, null);

    }

    private Name getNewMethodName(Name name) {
        String s = name.toString();
        return names.fromString("get" + s.substring(0, 1).toUpperCase() + s.substring(1, name.length()));
    }

    private JCTree.JCExpressionStatement makeAssignment(JCTree.JCExpression lhs, JCTree.JCExpression rhs) {
        return treeMaker.Exec(
                treeMaker.Assign(
                        lhs,
                        rhs
                )
        );
    }
}

註冊自定義註解處理器

雖然寫了自定義處理器，但是怎樣才能讓jvm認識它呢？
需要在resources目錄中添加META-INF.services文件夾，裏面創建一個javax.annotation.processing.Processor文件；
javax.annotation.processing.Processor 這個文件裏面寫自定義註解處理器的全類名稱，多個的話，就換行寫：

com.processor.MyGetterProcessor

在主項目中添加依賴模塊

因爲我們自定義註解和處理器是在myprocessor模塊中的：
主項目中要使用自定義註解@MyGetter時，得在build.gradle中添加依賴：

compile project('myprocessor')

gradle項目的話，要讓編譯時，使用自定義註解處理器，還得指定：

annotationProcessor project(':myprocessor')

完整：

plugins {
    id 'java'
}

group 'com.misssad'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
    compile project('myprocessor')
    annotationProcessor project(':myprocessor')
    testCompile group: 'junit', name: 'junit', version: '4.12'
}

使用自定義註解

在主項目中創建一個Person類：

package com.hello;

import com.processor.MyGetter;

/**
 * @author yutao
 * @since 2020/5/9 4:50 下午
 */
@MyGetter
public class Person {

    private String name;
}

編譯

在IDEA的右側，找到gradle，在Tasks - other - compileJava

假設按照上面的步驟來的，不出意外，會報錯：

錯誤: 程序包com.sun.source.tree不存在
import com.sun.source.tree.Tree;

會報上面這樣的錯誤；

爲什麼會報這個錯誤呢？

因爲在編譯的時候，gradle找不到tools.jar。

網上有大部分解決方案是：

網上大部分做法是打開Project Settings，然後再Libraries中點擊左上角+號，把tools.jar添加上去。
但是我這樣做過，不行，沒有解決掉我的問題。即依然報錯。

gradle編譯項目找不到tools.jar問題

解決辦法是：

因爲註解處理器是寫在子模塊裏面的，所以在myprocessor模塊中的build.gradle中添加：

compile files("${System.properties['java.home']}/../lib/tools.jar")

完整的：

plugins {
    id 'java'
}

group 'com.misssad'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}

dependencies {
//    implementation fileTree(dir: 'lib', include: ['*.jar'])
    testCompile group: 'junit', name: 'junit', version: '4.12'
    compile files("${System.properties['java.home']}/../lib/tools.jar")
}

再次執行gradle任務中的compileJava任務，即可。

然後在build文件夾中找到相應的class文件，看看效果：

成功了。

參考地址：

Java中實現自定義的註解處理器（Annotation Processor）

99%的程序員都在用Lombok，原理竟然這麼簡單？我也手擼了一個

AOP 最後一塊拼圖 | AST 抽象語法樹 —— 最輕量級的AOP方法

Android自定義註解處理器