引言

有許多開源框架在編譯時通過註解資訊生成新的原始檔，已到達簡化樣板程式碼的書寫，比如說典型的Builder模式，或者實現框架的功能的橋接程式碼。因為我使用編譯時註解只是想要簡化樣板程式碼，下面我就以Builder模式作為示例。

Builder模式

Builder模式主要是解決建立物件過程中的必須引數和非必須引數的的傳入，以及以及傳入過程中導致物件的中間狀態暴露在外面。下面是簡單Builder模式的實現：

#User.java
package Model.builder;
public class User{
    //定義為final 的屬性必需在建構函式中初始化
    private
 
 final String id; //必需
    private final String sex; //必需
    private final String name; //必需
    private String location; //非必需
    private String email; //非必需
    private User(String id,String sex,String name){
        this.id= id ;
        this.name =name ;
        this.sex = sex;
    }

    private User(User origin){
        this
 
.id = origin.id;
        this.sex = origin.sex;
        this.name = origin .name;
        this.location = origin.location;
        this.email = origin.email;
    }

    public String getId() {
        return id;
    }

    public String getSex() {
        return sex;
    }

    public String getName
 
() {
        return name;
    }

    public String getLocation() {
        return location;
    }

    public String getEmail() {
        return email;
    }

    static class UserBuilder{
        private User target;
        public UserBuilder(String id ,String sex,String name){
            target = new User(id, sex, name);
        }

        public UserBuilder location(String location){
            target.location = location;
            return this;
        }

        public UserBuilder email(String email){
            target.email = email;
            return this;
        }

        public User build(){
            return new User(target);
        }
    }
}

如果我們要使用上面的builder建立行的User物件的話,像下面這樣呼叫
User user = new User.UserBuilder(“123”,”man”,”sosky”).email(“[email protected]”).location(“xxxxxx”).build()
像這樣鏈式的呼叫寫起來思路很清晰（雖然這裡並沒有很複雜的邏輯，但是如果這裡是多執行緒下網路通訊和UI操作，這樣寫的話邏輯就非常容易理清了，可以參考一下Rxjava的鏈式API），並且避免了User物件中間狀態暴露。

程式碼雖然好用，但是除了規定那些是必需的成員變數，那些是非必需的成員變數，其他的程式碼完全就是重複的樣板程式碼。因此我們就可以採用編譯時註解幫我們處理這些樣板程式碼，只需要我們規定那些是必需的成員變數就行了；

註解的宣告如下：

package Annotation;
//標記builder屬性
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.CLASS)
public @interface toBuilder {
    boolean essential();
}

package Annotation;
//標記builder類
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface BuilderClass {

}

我們像這樣定義了一個註解，其中essential表示是否是必需的成員變數，如果是必需的話我們就需要在新的原始檔中定義為final的變數，並在建構函式中初始化它；

註解直譯器宣告：

package Annotation;


import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.JavaFileObject;
import java.io.IOException;
import java.io.Writer;
import java.util.List;
import java.util.Set;


/**
 * toBuilder註解解析器
 */
@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes({"Annotation.toBuilder","Annotation.BuilderClass"})
public class toBuilderProcess extends AbstractProcessor{
    private Filer filer;
    private String className;

    //essential為真的屬性名
    private List<String> fields_t;
    //essential為假的屬性名
    private List<String> fields_f;
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        filer = processingEnv.getFiler();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        //標記的類
        Set<? extends Element> classAnnotated = roundEnv.getElementsAnnotatedWith(BuilderClass.class);
        for (Element classelement :classAnnotated){
            className = classelement.getSimpleName().toString();
        }
        //標記的成員變數
        Set<? extends Element> fieldAnnotated = roundEnv.getElementsAnnotatedWith(toBuilder.class);
        for (Element field: fieldAnnotated){
            if(field.getAnnotation(toBuilder.class).essential()) {
                fields_t.add(field.getSimpleName().toString());
            }else{
                fields_f.add(field.getSimpleName().toString());
            }
        }
        //建立原始檔
        createFile();

        return true;
    }


    private void createFile() {

        StringBuilder cls = new StringBuilder();
        cls.append("package Annotation;\n\npublic class ")
                .append(className)
             。。。。。。。
             原始檔內容，根據之前註解資訊拼接字串；
        try {
            JavaFileObject sourceFile = filer.createSourceFile("Annotation." + className);
            Writer writer = sourceFile.openWriter();
            writer.write(cls.toString());
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

只有我們就可以通過javac使用編譯後的註解解析器了：
javac -encoding UTF-8 -cp {註解器和註解的包路徑，或者class路徑} -processor {包名.註解器名} -d out\production -s src\ src\Annotation*.java
在這裡注意一下 javac -s標誌的含義，是指定原始檔位置，而我們在註解器中JavaFileObject sourceFile = filer.createSourceFile(“Annotation.” + className); sourceFile物件的Writer的輸出位置就是其指定的路徑，如果沒有- s標誌的話，預設會生成的原始檔會生成到-d 指定的路徑下。我寫的時候遇到了原始檔生成位置不對的坑，就是這個原因。

結語

當然現在有很多IDE外掛能幫我們自動生成Builder程式碼，這只是一個例子，有很多其他樣板程式碼，或者因為小小的不同，需要重複寫的業務邏輯程式碼，都可以用這個方法簡化。更重要的假如我們的框架能夠通過不同註解配置其功能，這樣的高度自定義的框架使用編譯時註解是最為合適的了。