（Thinking in Java）第20章注解

劉玉平發布于2019-08-16 10:39 / 488人閱讀

摘要：而這可以通過注解辦到，在代碼中以指令語言的形式化方法來為代碼提供更多信息。有注解的說明這個成員變量是一個列名，然后根據注解信息來生成相應的語句。也就是說把注解信息提取了出來。

注解是向代碼中添加信息的一種方法，并且在之后還可以使用這些數據
就比如這個方法是用來剝香蕉的，但是我們看就是一串代碼，我們沒辦法在代碼里寫一段指令說“我這個程序是用來剝香蕉的”，當然除了注釋。而這可以通過注解辦到，在代碼中以Java指令語言的形式化方法來為代碼提供更多信息。

一、基本語法 1.定義注解

package tij.annotation;

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

public class AnnotationTest {

}
class Testable {
    void execute() {
        System.out.println("Executing...");
    }
    @Test
    void testExecute() {
        execute();
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface Test {}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface UseCase {
    public int id();
    public String description() default "no description";
}

class PasswordUtils {
    @UseCase(id = 47, description = "Passwords must contain at least one numeric")
    public boolean validatePassword(String password) {
        return (password.matches("w*dw*"));
    }

    @UseCase(id = 48)
    public String encryptPassword(String password) {
        return new StringBuilder(password).reverse().toString();
    }

    @UseCase(id = 49, description = "New passwords can"t equal previously used ones")
    public boolean checkForNewPassword(List prevPasswords,
            String password) {
        return !prevPasswords.contains(password);
    }
}

這是個注解的簡單應用，通過這些注解，我們在閱讀代碼的時候可以更清晰的獲取更多信息

2.元注解

二、編寫注解處理器

package tij.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class AnnotationTest {
    public static void trackUseCases(List useCases, Class cl) {
        for (Method m : cl.getDeclaredMethods()) {
            UseCase uc = m.getAnnotation(UseCase.class);
            if (uc != null) {
                System.out.println(
                        "Found Use Case:" + uc.id() + " " + uc.description());
            }
            useCases.remove(new Integer(uc.id()));
        }
        for (int i : useCases) {
            System.out.println("Warning:Missing use case-" + i);
        }
    }

    public static void main(String[] args) {
        List useCases = new ArrayList();
        Collections.addAll(useCases, 47, 48, 49, 50);
        trackUseCases(useCases, PasswordUtils.class);
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface UseCase {
    public int id();
    public String description() default "no description";
}

class PasswordUtils {
    @UseCase(id = 47, description = "Passwords must contain at least one numeric")
    public boolean validatePassword(String password) {
        return (password.matches("w*dw*"));
    }

    @UseCase(id = 48)
    public String encryptPassword(String password) {
        return new StringBuilder(password).reverse().toString();
    }

    @UseCase(id = 49, description = "New passwords can"t equal previously used ones")
    public boolean checkForNewPassword(List prevPasswords,
            String password) {
        return !prevPasswords.contains(password);
    }
}

因為注解是Java語言之一，也正是因為有可以讀取注解的方法，所以注解才強于直接注釋。
在上面的例子中我們可以看出，可以將各個方法的注解信息讀取出來

1.注解元素

就像之前的id和dicription一樣，這叫做注解元素，可用類型如下：

2.默認值的限制

就是注解元素必須有一個確認的值，沒有不行，空也不行，那假如就是空的就是不存在咋整呢。
所以我們只能定義一些特殊的值來解決

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface SimulatingNull{
    public int id() default -1;
    public String decription() default "";
}

3.生成外部文件

package tij.annotation;

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

public class AnnotationTest {

    public static void main(String[] args) {}
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface DBTable {
    public String name() default "";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Constraints {
    boolean primaryKey() default false;
    boolean allowNull() default true;
    boolean unique() default false;
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface SQLString {
    int value() default 0;
    String name() default "";
    Constraints constraints() default @Constraints;
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface SQLInteger {
    String name() default "";
    Constraints constraints() default @Constraints;
}

@DBTable(name = "MEMBER")
class Member {
    @SQLString(30)
    String firstName;
    @SQLString(50)
    String lastName;
    @SQLString
    Integer age;
    @SQLString(value = 30, constraints = @Constraints(primaryKey = true))
    String handle;
    static int memberCount;
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public Integer getAge() {
        return age;
    }
    public String getHandle() {
        return handle;
    }
    public String toString() {
        return handle;
    }
    
}

其實這段代碼很好的舉了個注解運用的例子，
@Target(ElementType.TYPE)這個東西告訴編譯器，這條注解要用在類聲明上，就像DBTable一樣，這個注解放在了class Member之前
@Target(ElementType.FIELD)這個東西告訴編譯器，這條注解要放在域聲明之前。
另外，如果只有一個名字叫做value的元素需要賦值的時候，就不需要“key=value”這種賦值，不用key，默認的。
不過，為了每個類型都設計一個注解未免太麻煩了，我們可以這么做

enum Type{
    String,Integer,Float;
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableColumn {
    Type type() default Type.String;
    Constraints constraints() default @Constraints;
}

這樣就用一個注解就可以套上各種類型，不過這樣就不能針對不同類型設計具有針對性的注解元素了

我們還可以為一個元素打上倆注解，這沒什么，就是亂了點

4.注解不支持繼承

不讓繼承，別逼逼

5.實現處理器

package tij.annotation;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class AnnotationTest {

    public static void main(String[] args) {
        DBTable dbTable = Member.class.getAnnotation(DBTable.class);
        String tableName = dbTable.name();
        List columnDefs = new ArrayList();

        for (Field field : Member.class.getFields()) {
            System.out.println(field.getName());
            String columnName = null;
            Annotation[] anns = field.getDeclaredAnnotations();
            if (anns.length < 1)
                continue;// 沒檢測得到注解，說明這個參數并不是一個數據庫表的列
            if (anns[0] instanceof SQLInteger) {
                SQLInteger sInt = (SQLInteger) anns[0];
                if (sInt.name().length() < 1)
                    columnName = field.getName();
                else
                    columnName = sInt.name();
                columnDefs.add(columnName + " INT"
                        + getConstraints(sInt.constraints()));
            }
            if (anns[0] instanceof SQLString) {
                SQLString sString = (SQLString) anns[0];
                if (sString.name().length() < 1)
                    columnName = field.getName();
                else
                    columnName = sString.name();
                columnDefs.add(columnName + " VARCHAR(" + sString.value() + ")"
                        + getConstraints(sString.constraints()));
            }
        }
        StringBuilder createCommand = new StringBuilder(
                "CREATE TABLE " + tableName + "(");
        for (String columnDef : columnDefs) {
            createCommand.append("
	" + columnDef + ",");
        }
        String tableCreate = createCommand.substring(0,
                createCommand.length() - 1) + ");";
        System.out.println("Table Creation SQL for" + Member.class + " is:
"
                + tableCreate);
    }

    private static String getConstraints(Constraints con) {
        String constraints = "";
        if (!con.allowNull())
            constraints += " NOT NULL ";
        if (con.primaryKey())
            constraints += " PRIMARY KEY ";
        if (con.unique())
            constraints += " UNIQUE ";
        return constraints;
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface DBTable {
    public String name() default "";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Constraints {
    boolean primaryKey() default false;
    boolean allowNull() default true;
    boolean unique() default false;
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface SQLString {
    int value() default 0;
    String name() default "";
    Constraints constraints() default @Constraints;
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface SQLInteger {
    String name() default "";
    Constraints constraints() default @Constraints;
}

@DBTable(name = "MEMBER")
class Member {
    @SQLString(30)
    public String firstName;
    @SQLString(50)
    public String lastName;
    @SQLString
    public Integer age;
    @SQLString(value = 30, constraints = @Constraints(primaryKey = true))
    public String handle;
    static int memberCount;
    public String getFirstName() {
        return firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public Integer getAge() {
        return age;
    }
    public String getHandle() {
        return handle;
    }
    public String toString() {
        return handle;
    }

}

這段代碼超棒，實際的告訴你這些注解到底怎么用，有什么用。有注解的說明這個成員變量是一個列名，然后根據注解信息來生成相應的SQL語句。也就是說把注解信息提取了出來。

三、使用apt處理注解

說實話，沒看懂

package tij.annotation;

import java.io.IOException;
import java.io.PrintWriter;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;

import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
import com.sun.mirror.apt.AnnotationProcessorFactory;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.declaration.ParameterDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;

public class AnnotationTest {
    public static void main(String[] args) {}

}

@ExtractInterface("IMultipier")
class Multiplier {

    public int multiply(int x, int y) {
        int total = 0;
        for (int i = 0; i < x; i++) {
            total = add(total, y);
        }
        return total;
    }
    private int add(int x, int y) {
        return x + y;
    }
    public static void main(String[] args) {
        Multiplier m = new Multiplier();
        System.out.println("11*16=" + m.multiply(11, 16));
    }

}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
@interface ExtractInterface {
    public String value();
}

class InterfaceExtractorProcessor implements AnnotationProcessor {
    private final AnnotationProcessorEnvironment env;
    private ArrayList interfaceMethods = new ArrayList();
    public InterfaceExtractorProcessor(AnnotationProcessorEnvironment env) {
        this.env = env;
    }
    @Override
    public void process() {
        for (TypeDeclaration typeDec1 : env.getSpecifiedTypeDeclarations()) {
            ExtractInterface annot = typeDec1
                    .getAnnotation(ExtractInterface.class);
            if (annot == null)
                break;
            for (MethodDeclaration m : typeDec1.getMethods())
                if (m.getModifiers().contains(Modifier.STATIC)
                        && !(m.getModifiers().contains(Modifier.STATIC)))
                    interfaceMethods.add(m);
            if (interfaceMethods.size() > 0) {
                try {
                    PrintWriter writer = env.getFiler()
                            .createSourceFile(annot.value());
                    writer.println("package"
                            + typeDec1.getPackage().getQualifiedName() + ";");
                    writer.println("public interface " + annot.value() + " {");
                    for (MethodDeclaration m : interfaceMethods) {
                        writer.print(" public ");
                        writer.print(m.getReturnType() + " ");
                        writer.print(m.getSimpleName() + " (");
                        int i = 0;
                        for (ParameterDeclaration parm : m.getParameters()) {
                            writer.print(parm.getType() + " "
                                    + parm.getSimpleName());
                            if (++i < m.getParameters().size())
                                writer.print(", ");
                        }
                        writer.println(");");
                    }
                    writer.println("}");
                    writer.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }
    }
}

class InterfaceExtractorProcessorFactory implements AnnotationProcessorFactory {

    @Override
    public AnnotationProcessor getProcessorFor(
            Set atds,
            AnnotationProcessorEnvironment env) {
        return new InterfaceExtractorProcessor(env);
    }

    @Override
    public Collection supportedAnnotationTypes() {
        return Collections.singleton("annotations.ExtractInterface");
    }

    @Override
    public Collection supportedOptions() {
        return Collections.emptySet();
    }

}

四、沒看懂= =真的 五、基于注解的單元測試

QNMLGB的不看了老子

end

GPU云服務器云服務器 thinking-in-小記 thinking-in小記明解c語言第9章 java 包注解

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/70182.html

（Thinking in Java）第11章持有對象

摘要：迭代器解決了這個問題。刪除后于是我們可以寫一個方法，接受一個類型，然后讓他調用方法，這就不需要考慮這個是個還是了，也就是說，可以將遍歷容器的操作與序列底層的結構分離，迭代器統一了對容器類的訪問方式。十二和兩種遍歷的方法，與迭代器方法。一、泛型和類型安全的容器 package tij.hoding; import java.util.ArrayList; public class ...

v1 2019-08-15 11:10 評論0 收藏0
（Thinking in Java）第13章字符串

摘要：四上的操作看五格式化輸出運用和語言很相似和是等價的喲類格式化說明符轉換六正則表達式網上教程學七掃描輸入新增了類。一、不可變String String類型的對象是不可變的，所有的改變實際上都是創建了一個新的String對象，另外當String作為傳入參數的時候，其實實際上傳入的是這個引用的一個拷貝，這個方法結束了之后這個傳入的引用也就消失了，原來的那個String不會受到方法內的影響而...

feng409 2019-08-15 11:10 評論0 收藏0
（Thinking in Java）第14章類型信息

摘要：通過運行時類型信息，程序能夠使用基類的指針或引用來檢查這些指針或引用所指的對象的實際派生類型。編程應該盡量面向接口編程，應該對類型信息盡量的少了解二對象看書，書上寫得好靜態語句塊在這個類被加載的時候運行。一、為什么需要RTTI Run-Time Type Information。通過運行時類型信息，程序能夠使用基類的指針或引用來檢查這些指針或引用所指的對象的實際派生類型。編程應該盡量...

tomorrowwu 2019-08-15 11:11 評論0 收藏0
（Thinking in Java）第10章內部類

摘要：內部類中也可以取得這個外部類對象引用。創建成員內部類對象的時候需要外部類對象。另外在方法中的內部類不能加等權限修飾符，只能加和修飾符?？梢栽诮涌趦炔慷x內部類，而且他們即使沒有修飾，也會自動變成的。 Thinking in Java撈干貨，寫筆記一、成員內部類 1.最基本使用 public class Demo { class Contents{ privat...

Brenner 2019-08-15 11:03 評論0 收藏0
（Thinking in Java）第9章接口

摘要：但如果導出類還有抽象方法，那這個類還應該加上聲明為抽象類。并且接口具有繼承的一系列特點，如向上轉型等等。接口中的方法是自動是的。 Thinking in Java 好書全是干貨一、抽象類和抽象方法抽象方法：這種方法只有聲明而沒有方法體，下面是抽象方法生命所采用的語法 abstract void f(); 包含抽象方法的類叫做抽象類，如果一個類包含一個或多個抽象方法，該類必須被限定為...

CoorChice 2019-08-15 11:10 評論0 收藏0