深刻理解 Java 註解

時間  2019-12-06
標籤 深刻 理解 java 註解 欄目 Java 简体版
原文   原文鏈接

本文內容基於 JDK8。註解是 JDK5 引入的，後續 JDK 版本擴展了一些內容，本文中沒有明確指明版本的註解都是 JDK5 就已經支持的註解。html

:notebook: 本文已歸檔到：「blog」java

:keyboard: 本文中的示例代碼已歸檔到：「javacore」git

簡介

註解的形式

Java 中，註解是以 @ 字符開始的修飾符。以下：程序員

@Override
void mySuperMethod() { ... }
複製代碼

註解能夠包含命名或未命名的屬性，而且這些屬性有值。github

@Author(
   name = "Benjamin Franklin",
   date = "3/27/2003"
)
class MyClass() { ... }
複製代碼

若是隻有一個名爲 value 的屬性，那麼名稱能夠省略，如：正則表達式

@SuppressWarnings("unchecked")
void myMethod() { ... }
複製代碼

若是註解沒有屬性，則稱爲標記註解。如：@Override。編程

什麼是註解

從本質上來講，註解是一種標籤，其實質上能夠視爲一種特殊的註釋，若是沒有解析它的代碼，它並不比普通註釋強。api

解析一個註解每每有兩種形式：數組

  • 編譯期直接的掃描 - 編譯器的掃描指的是編譯器在對 java 代碼編譯字節碼的過程當中會檢測到某個類或者方法被一些註解修飾，這時它就會對於這些註解進行某些處理。這種狀況只適用於 JDK 內置的註解類。
  • 運行期的反射 - 若是要自定義註解，Java 編譯器沒法識別並處理這個註解，它只能根據該註解的做用範圍來選擇是否編譯進字節碼文件。若是要處理註解，必須利用反射技術，識別該註解以及它所攜帶的信息，而後作相應的處理。

註解的做用

註解有許多用途：安全

  • 編譯器信息 - 編譯器可使用註解來檢測錯誤或抑制警告。
  • 編譯時和部署時的處理 - 程序能夠處理註解信息以生成代碼，XML 文件等。
  • 運行時處理 - 能夠在運行時檢查某些註解並處理。

做爲 Java 程序員，多多少少都曾經歷過被各類配置文件（xml、properties）支配的恐懼。過多的配置文件會使得項目難以維護。我的認爲，使用註解以減小配置文件或代碼，是註解最大的用處。

註解的代價

凡事有得必有失，註解技術一樣如此。使用註解也有必定的代價：

  • 顯然，它是一種侵入式編程，那麼，天然就存在着增長程序耦合度的問題。
  • 自定義註解的處理須要在運行時，經過反射技術來獲取屬性。若是註解所修飾的元素是類的非 public 成員，也能夠經過反射獲取。這就違背了面向對象的封裝性。
  • 註解所產生的問題，相對而言，更難以 debug 或定位。

可是，正所謂瑕不掩瑜，註解所付出的代價，相較於它提供的功能而言，仍是能夠接受的。

註解的應用範圍

註解能夠應用於類、字段、方法和其餘程序元素的聲明。

JDK8 開始，註解的應用範圍進一步擴大，如下是新的應用範圍：

類實例初始化表達式：

new @Interned MyObject();
複製代碼

類型轉換：

myString = (@NonNull String) str;
複製代碼

實現接口的聲明：

class UnmodifiableList<T> implements @Readonly List<@Readonly T> {}
複製代碼

拋出異常聲明：

void monitorTemperature() throws @Critical TemperatureException {}
複製代碼

內置註解

JDK 中內置瞭如下註解：

  • @Override
  • @Deprecated
  • @SuppressWarnnings
  • @SafeVarargs（JDK7 引入）
  • @FunctionalInterface（JDK8 引入）

@Override

@Override 用於代表被修飾方法覆寫了父類的方法。

若是試圖使用 @Override 標記一個實際上並無覆寫父類的方法時，java 編譯器會告警。

@Override 示例：

public class OverrideAnnotationDemo {

    static class Person {
        public String getName() {
            return "getName";
        }
    }


    static class Man extends Person {
        @Override
        public String getName() {
            return "override getName";
        }

        /** * 放開下面的註釋，編譯時會告警 */
       /* @Override public String getName2() { return "override getName2"; } */
    }

    public static void main(String[] args) {
        Person per = new Man();
        System.out.println(per.getName());
    }
}
複製代碼

@Deprecated

@Deprecated 用於標明被修飾的類或類成員、類方法已經廢棄、過期，不建議使用。

@Deprecated 有必定的延續性：若是咱們在代碼中經過繼承或者覆蓋的方式使用了過期的類或類成員，即便子類或子方法沒有標記爲 @Deprecated，但編譯器仍然會告警。

注意： @Deprecated 這個註解類型和 javadoc 中的 @deprecated 這個 tag 是有區別的：前者是 java 編譯器識別的；然後者是被 javadoc 工具所識別用來生成文檔（包含程序成員爲何已通過時、它應當如何被禁止或者替代的描述）。

@Deprecated 示例：

public class DeprecatedAnnotationDemo {
    static class DeprecatedField {
        @Deprecated
        public static final String DEPRECATED_FIELD = "DeprecatedField";
    }


    static class DeprecatedMethod {
        @Deprecated
        public String print() {
            return "DeprecatedMethod";
        }
    }


    @Deprecated
    static class DeprecatedClass {
        public String print() {
            return "DeprecatedClass";
        }
    }

    public static void main(String[] args) {
        System.out.println(DeprecatedField.DEPRECATED_FIELD);

        DeprecatedMethod dm = new DeprecatedMethod();
        System.out.println(dm.print());


        DeprecatedClass dc = new DeprecatedClass();
        System.out.println(dc.print());
    }
}
//Output:
//DeprecatedField
//DeprecatedMethod
//DeprecatedClass
複製代碼

@SuppressWarnnings

@SuppressWarnings 用於關閉對類、方法、成員編譯時產生的特定警告。

@SuppressWarning 不是一個標記註解。它有一個類型爲 String[] 的數組成員，這個數組中存儲的是要關閉的告警類型。對於 javac 編譯器來說，對 -Xlint 選項有效的警告名也一樣對 @SuppressWarings 有效，同時編譯器會忽略掉沒法識別的警告名。

@SuppressWarning 示例：

@SuppressWarnings({"rawtypes", "unchecked"})
public class SuppressWarningsAnnotationDemo {
    static class SuppressDemo<T> {
        private T value;

        public T getValue() {
            return this.value;
        }

        public void setValue(T var) {
            this.value = var;
        }
    }

    @SuppressWarnings({"deprecation"})
    public static void main(String[] args) {
        SuppressDemo d = new SuppressDemo();
        d.setValue("南京");
        System.out.println("地名：" + d.getValue());
    }
}
複製代碼

@SuppressWarnings 註解的常見參數值的簡單說明：

  • deprecation - 使用了不同意使用的類或方法時的警告；
  • unchecked - 執行了未檢查的轉換時的警告，例如當使用集合時沒有用泛型 (Generics) 來指定集合保存的類型;
  • fallthrough - 當 Switch 程序塊直接通往下一種狀況而沒有 Break 時的警告;
  • path - 在類路徑、源文件路徑等中有不存在的路徑時的警告;
  • serial - 當在可序列化的類上缺乏 serialVersionUID 定義時的警告;
  • finally - 任何 finally 子句不能正常完成時的警告;
  • all - 全部的警告。
@SuppressWarnings({"uncheck", "deprecation"})
public class InternalAnnotationDemo {

    /** * @SuppressWarnings 標記消除當前類的告警信息 */
    @SuppressWarnings({"deprecation"})
    static class A {
        public void method1() {
            System.out.println("call method1");
        }

        /** * @Deprecated 標記當前方法爲廢棄方法，不建議使用 */
        @Deprecated
        public void method2() {
            System.out.println("call method2");
        }
    }

    /** * @Deprecated 標記當前類爲廢棄類，不建議使用 */
    @Deprecated
    static class B extends A {
        /** * @Override 標記顯示指明當前方法覆寫了父類或接口的方法 */
        @Override
        public void method1() { }
    }

    public static void main(String[] args) {
        A obj = new B();
        obj.method1();
        obj.method2();
    }
}
複製代碼

@SafeVarargs

@SafeVarargs 在 JDK7 中引入。

@SafeVarargs 的做用是：告訴編譯器，在可變長參數中的泛型是類型安全的。可變長參數是使用數組存儲的，而數組和泛型不能很好的混合使用。

簡單的說，數組元素的數據類型在編譯和運行時都是肯定的，而泛型的數據類型只有在運行時才能肯定下來。所以，當把一個泛型存儲到數組中時，編譯器在編譯階段沒法確認數據類型是否匹配，所以會給出警告信息；即若是泛型的真實數據類型沒法和參數數組的類型匹配，會致使 ClassCastException 異常。

@SafeVarargs 註解使用範圍：

  • @SafeVarargs 註解能夠用於構造方法。
  • @SafeVarargs 註解能夠用於 static 或 final 方法。

@SafeVarargs 示例：

public class SafeVarargsAnnotationDemo {
    /** * 此方法實際上並不安全，不使用此註解，編譯時會告警 */
    @SafeVarargs
    static void wrongMethod(List<String>... stringLists) {
        Object[] array = stringLists;
        List<Integer> tmpList = Arrays.asList(42);
        array[0] = tmpList; // 語法錯誤，可是編譯不告警
        String s = stringLists[0].get(0); // 運行時報 ClassCastException
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");

        List<String> list2 = new ArrayList<>();
        list.add("1");
        list.add("2");

        wrongMethod(list, list2);
    }
}
複製代碼

以上代碼，若是不使用 @SafeVarargs ，編譯時會告警

[WARNING] /D:/Codes/ZP/Java/javacore/codes/basics/src/main/java/io/github/dunwu/javacore/annotation/SafeVarargsAnnotationDemo.java: 某些輸入文件使用了未經檢查或不安全的操做。
[WARNING] /D:/Codes/ZP/Java/javacore/codes/basics/src/main/java/io/github/dunwu/javacore/annotation/SafeVarargsAnnotationDemo.java: 有關詳細信息, 請使用 -Xlint:unchecked 從新編譯。
複製代碼

@FunctionalInterface

@FunctionalInterface 在 JDK8 引入。

@FunctionalInterface 用於指示被修飾的接口是函數式接口。

須要注意的是，若是一個接口符合"函數式接口"定義，不加 @FunctionalInterface 也不要緊；但若是編寫的不是函數式接口，卻使用 @FunctionInterface，那麼編譯器會報錯。

什麼是函數式接口？

函數式接口(Functional Interface)就是一個有且僅有一個抽象方法，可是能夠有多個非抽象方法的接口。函數式接口能夠被隱式轉換爲 lambda 表達式。

函數式接口的特色：

  • 接口有且只能有個一個抽象方法（抽象方法只有方法定義，沒有方法體）。
  • 不能在接口中覆寫 Object 類中的 public 方法（寫了編譯器也會報錯）。
  • 容許有 default 實現方法。

示例：

public class FunctionalInterfaceAnnotationDemo {

    @FunctionalInterface
    public interface Func1<T> {
        void printMessage(T message);
    }

    /** * @FunctionalInterface 修飾的接口中定義兩個抽象方法，編譯時會報錯 * @param <T> */
    /*@FunctionalInterface public interface Func2<T> { void printMessage(T message); void printMessage2(T message); }*/

    public static void main(String[] args) {
        Func1 func1 = message -> System.out.println(message);
        func1.printMessage("Hello");
        func1.printMessage(100);
    }
}
複製代碼

元註解

JDK 中雖然內置了幾個註解，但這遠遠不能知足開發過程當中遇到的變幻無窮的需求。因此咱們須要自定義註解，而這就須要用到元註解。

元註解的做用就是用於定義其它的註解。

Java 中提供瞭如下元註解類型：

  • @Retention
  • @Target
  • @Documented
  • @Inherited（JDK8 引入）
  • @Repeatable（JDK8 引入）

這些類型和它們所支持的類在 java.lang.annotation 包中能夠找到。下面咱們看一下每一個元註解的做用和相應分參數的使用說明。

@Retention

@Retention 指明瞭註解的保留級別。

@Retention 源碼：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    RetentionPolicy value();
}
複製代碼

RetentionPolicy 是一個枚舉類型，它定義了被 @Retention 修飾的註解所支持的保留級別：

  • RetentionPolicy.SOURCE - 標記的註解僅在源文件中有效，編譯器會忽略。
  • RetentionPolicy.CLASS - 標記的註解在 class 文件中有效，JVM 會忽略。
  • RetentionPolicy.RUNTIME - 標記的註解在運行時有效。

@Retention 示例：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    public String name() default "fieldName";
    public String setFuncName() default "setField";
    public String getFuncName() default "getField";
    public boolean defaultDBValue() default false;
}
複製代碼

@Documented

@Documented 表示不管什麼時候使用指定的註解，都應使用 Javadoc（默認狀況下，註釋不包含在 Javadoc 中）。更多內容能夠參考：Javadoc tools page。

@Documented 示例：

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Column {
    public String name() default "fieldName";
    public String setFuncName() default "setField";
    public String getFuncName() default "getField";
    public boolean defaultDBValue() default false;
}
複製代碼

@Target

@Target 指定註解能夠修飾的元素類型。

@Target 源碼：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    ElementType[] value();
}
複製代碼

ElementType 是一個枚舉類型，它定義了被 @Target 修飾的註解能夠應用的範圍：

  • ElementType.ANNOTATION_TYPE - 標記的註解能夠應用於註解類型。
  • ElementType.CONSTRUCTOR - 標記的註解能夠應用於構造函數。
  • ElementType.FIELD - 標記的註解能夠應用於字段或屬性。
  • ElementType.LOCAL_VARIABLE - 標記的註解能夠應用於局部變量。
  • ElementType.METHOD - 標記的註解能夠應用於方法。
  • ElementType.PACKAGE - 標記的註解能夠應用於包聲明。
  • ElementType.PARAMETER - 標記的註解能夠應用於方法的參數。
  • ElementType.TYPE - 標記的註解能夠應用於類的任何元素。

@Target 示例：

@Target(ElementType.TYPE)
public @interface Table {
    /** * 數據表名稱註解，默認值爲類名稱 * @return */
    public String tableName() default "className";
}

@Target(ElementType.FIELD)
public @interface NoDBColumn {}
複製代碼

@Inherited

@Inherited 表示註解類型能夠被繼承（默認狀況下不是這樣）。

表示自動繼承註解類型。 若是註解類型聲明中存在 @Inherited 元註解，則註解所修飾類的全部子類都將會繼承此註解。

注意：@Inherited 註解類型是被標註過的類的子類所繼承。類並不從它所實現的接口繼承註解，方法並不從它所覆寫的方法繼承註解。

此外，當 @Inherited 類型標註的註解的 @Retention 是 RetentionPolicy.RUNTIME，則反射 API 加強了這種繼承性。若是咱們使用 java.lang.reflect 去查詢一個 @Inherited 類型的註解時，反射代碼檢查將展開工做：檢查類和其父類，直到發現指定的註解類型被發現，或者到達類繼承結構的頂層。

@Inherited
public @interface Greeting {
    public enum FontColor{ BULE,RED,GREEN};
    String name();
    FontColor fontColor() default FontColor.GREEN;
}
複製代碼

@Repeatable

@Repeatable 表示註解能夠重複使用。

以 Spring @Scheduled 爲例：

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Schedules {
	Scheduled[] value();
}

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {
  // ...
}
複製代碼

應用示例：

public class TaskRunner {

    @Scheduled("0 0/15 * * * ?")
    @Scheduled("0 0 12 * ?")
    public void task1() {}
}
複製代碼

自定義註解

使用 @interface 自定義註解時，自動繼承了 java.lang.annotation.Annotation 接口，由編譯程序自動完成其餘細節。在定義註解時，不能繼承其餘的註解或接口。@interface 用來聲明一個註解，其中的每個方法其實是聲明瞭一個配置參數。方法的名稱就是參數的名稱，返回值類型就是參數的類型（返回值類型只能是基本類型、Class、String、enum）。能夠經過 default 來聲明參數的默認值。

這裏，我會經過實現一個名爲 RegexValid 的正則校驗註解工具來展現自定義註解的全步驟。

1. 註解的定義

註解的語法格式以下：

public @interface 註解名 {定義體}
複製代碼

咱們來定義一個註解：

@Documented
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface RegexValid {}
複製代碼

說明：

經過上一節對於元註解 @Target、@Retention、@Documented 的說明，這裏就很容易理解了。

  • 上面的代碼中定義了一個名爲 @RegexValid 的註解。
  • @Documented 表示 @RegexValid 應該使用 javadoc。
  • @Target({ElementType.FIELD, ElementType.PARAMETER}) 表示 @RegexValid 能夠在類成員或方法參數上修飾。
  • @Retention(RetentionPolicy.RUNTIME) 表示 @RegexValid 在運行時有效。

此時，咱們已經定義了一個沒有任何屬性的註解，若是到此爲止，它僅僅是一個標記註解。做爲正則工具，沒有屬性可什麼也作不了。接下來，咱們將爲它添加註解屬性。

2. 註解屬性

註解屬性的語法形式以下：

[訪問級別修飾符] [數據類型] 名稱() default 默認值;
複製代碼

例如，咱們要定義在註解中定義一個名爲 value 的字符串屬性，其默認值爲空字符串，訪問級別爲默認級別，那麼應該定義以下：

String value() default "";
複製代碼

注意：在註解中，咱們定義屬性時，屬性名後面須要加 ()。

定義註解屬性有如下要點：

  • 註解屬性只能使用 public 或默認訪問級別（即不指定訪問級別修飾符）修飾。

  • 註解屬性的數據類型有限制要求。支持的數據類型以下：

    • 全部基本數據類型（byte、char、short、int、long、float、double、boolean）
    • String 類型
    • Class 類
    • enum 類型
    • Annotation 類型
    • 以上全部類型的數組

  • 註解屬性必須有肯定的值，建議指定默認值。註解屬性只能經過指定默認值或使用註解時指定屬性值，相較之下，指定默認值的方式更爲可靠。註解屬性若是是引用類型，不能夠爲 null。這個約束使得註解處理器很難判斷註解屬性是默認值，或是使用註解時所指定的屬性值。爲此，咱們設置默認值時，通常會定義一些特殊的值，例如空字符串或者負數。

  • 若是註解中只有一個屬性值，最好將其命名爲 value。由於，指定屬性名爲 value，在使用註解時，指定 value 的值能夠不指定屬性名稱。

// 這兩種方式效果相同
@RegexValid("^((\\+)?86\\s*)?((13[0-9])|(15([0-3]|[5-9]))|(18[0,2,5-9]))\\d{8}$")
@RegexValid(value = "^((\\+)?86\\s*)?((13[0-9])|(15([0-3]|[5-9]))|(18[0,2,5-9]))\\d{8}$")
複製代碼

示例：

瞭解了註解屬性的定義要點，讓咱們來爲 @RegexValid 註解定義幾個屬性。

@Documented
@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface RegexValid {
    enum Policy {
        // @formatter:off
        EMPTY(null),
        DATE("^(?:(?!0000)[0-9]{4}([-/.]?)(?:(?:0?[1-9]|1[0-2])\\1(?:0?[1-9]|1[0-9]|2[0-8])|(?:0?[13-9]|1[0-2])\\1"
            + "(?:29|30)|(?:0?[13578]|1[02])\\1(?:31))|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|"
            + "(?:0[48]|[2468][048]|[13579][26])00)([-/.]?)0?2\\2(?:29))$"),
        MAIL("^[A-Za-z0-9](([_\\.\\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\\.\\-]?[a-zA-Z0-9]+)*)\\.([A-Za-z]{2,})$");
        // @formatter:on

        private String policy;

        Policy(String policy) {
            this.policy = policy;
        }

        public String getPolicy() {
            return policy;
        }
    }

    String value() default "";
    Policy policy() default Policy.EMPTY;
}
複製代碼

說明：

在上面的示例代碼中，咱們定義了兩個註解屬性：String 類型的 value 屬性和 Policy 枚舉類型的 policy 屬性。Policy 枚舉中定義了幾個默認的正則表達式，這是爲了直接使用這幾個經常使用表達式去正則校驗。考慮到，咱們可能須要本身傳入一些自定義正則表達式去校驗其餘場景，因此定義了 value 屬性，容許使用者傳入正則表達式。

至此，@RegexValid 的聲明已經結束。可是，程序仍不知道如何處理 @RegexValid 這個註解。咱們還須要定義註解處理器。

3. 註解處理器

若是沒有用來讀取註解的方法和工做，那麼註解也就不會比註釋更有用處了。使用註解的過程當中，很重要的一部分就是建立於使用註解處理器。JDK5 擴展了反射機制的 API，以幫助程序員快速的構造自定義註解處理器。

java.lang.annotation.Annotation 是一個接口，程序能夠經過反射來獲取指定程序元素的註解對象，而後經過註解對象來獲取註解裏面的元數據。

Annotation 接口源碼以下：

public interface Annotation {
    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}
複製代碼

除此以外，Java 中支持註解處理器接口 java.lang.reflect.AnnotatedElement ，該接口表明程序中能夠接受註解的程序元素，該接口主要有以下幾個實現類：

  • Class - 類定義
  • Constructor - 構造器定義
  • Field - 累的成員變量定義
  • Method - 類的方法定義
  • Package - 類的包定義

java.lang.reflect 包下主要包含一些實現反射功能的工具類。實際上，java.lang.reflect 包全部提供的反射 API 擴充了讀取運行時註解信息的能力。當一個註解類型被定義爲運行時的註解後，該註解才能是運行時可見，當 class 文件被裝載時被保存在 class 文件中的註解纔會被虛擬機讀取。 AnnotatedElement 接口是全部程序元素（Class、Method 和 Constructor）的父接口，因此程序經過反射獲取了某個類的AnnotatedElement 對象以後，程序就能夠調用該對象的以下四個個方法來訪問註解信息：

  • getAnnotation - 返回該程序元素上存在的、指定類型的註解，若是該類型註解不存在，則返回 null。
  • getAnnotations - 返回該程序元素上存在的全部註解。
  • isAnnotationPresent - 判斷該程序元素上是否包含指定類型的註解，存在則返回 true，不然返回 false。
  • getDeclaredAnnotations - 返回直接存在於此元素上的全部註釋。與此接口中的其餘方法不一樣，該方法將忽略繼承的註釋。（若是沒有註釋直接存在於此元素上，則返回長度爲零的一個數組。）該方法的調用者能夠隨意修改返回的數組；這不會對其餘調用者返回的數組產生任何影響。

瞭解了以上內容，讓咱們來實現 @RegexValid 的註解處理器：

import java.lang.reflect.Field;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexValidUtil {
    public static boolean check(Object obj) throws Exception {
        boolean result = true;
        StringBuilder sb = new StringBuilder();
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            // 判斷成員是否被 @RegexValid 註解所修飾
            if (field.isAnnotationPresent(RegexValid.class)) {
                RegexValid valid = field.getAnnotation(RegexValid.class);

                // 若是 value 爲空字符串，說明沒有注入自定義正則表達式，改用 policy 屬性
                String value = valid.value();
                if ("".equals(value)) {
                    RegexValid.Policy policy = valid.policy();
                    value = policy.getPolicy();
                }

                // 經過設置 setAccessible(true) 來訪問私有成員
                field.setAccessible(true);
                Object fieldObj = null;
                try {
                    fieldObj = field.get(obj);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
                if (fieldObj == null) {
                    sb.append("\n")
                        .append(String.format("%s 類中的 %s 字段不能爲空！", obj.getClass().getName(), field.getName()));
                    result = false;
                } else {
                    if (fieldObj instanceof String) {
                        String text = (String) fieldObj;
                        Pattern p = Pattern.compile(value);
                        Matcher m = p.matcher(text);
                        result = m.matches();
                        if (!result) {
                            sb.append("\n").append(String.format("%s 不是合法的 %s ！", text, field.getName()));
                        }
                    } else {
                        sb.append("\n").append(
                            String.format("%s 類中的 %s 字段不是字符串類型，不能使用此註解校驗！", obj.getClass().getName(), field.getName()));
                        result = false;
                    }
                }
            }
        }

        if (sb.length() > 0) {
            throw new Exception(sb.toString());
        }
        return result;
    }
}
複製代碼

說明：

以上示例中的註解處理器，執行步驟以下：

  1. 經過 getDeclaredFields 反射方法獲取傳入對象的全部成員。
  2. 遍歷成員，使用 isAnnotationPresent 判斷成員是否被指定註解所修飾，若是不是，直接跳過。
  3. 若是成員被註解所修飾，經過 RegexValid valid = field.getAnnotation(RegexValid.class); 這樣的形式獲取，註解實例化對象，而後，就可使用 valid.value() 或 valid.policy() 這樣的形式獲取註解中設定的屬性值。
  4. 根據屬性值，進行邏輯處理。

4. 使用註解

完成了以上工做，咱們就可使用自定義註解了，示例以下：

public class RegexValidDemo {
    static class User {
        private String name;
        @RegexValid(policy = RegexValid.Policy.DATE)
        private String date;
        @RegexValid(policy = RegexValid.Policy.MAIL)
        private String mail;
        @RegexValid("^((\\+)?86\\s*)?((13[0-9])|(15([0-3]|[5-9]))|(18[0,2,5-9]))\\d{8}$")
        private String phone;

        public User(String name, String date, String mail, String phone) {
            this.name = name;
            this.date = date;
            this.mail = mail;
            this.phone = phone;
        }

        @Override
        public String toString() {
            return "User{" + "name='" + name + '\'' + ", date='" + date + '\'' + ", mail='" + mail + '\'' + ", phone='"
                + phone + '\'' + '}';
        }
    }

    static void printDate(@RegexValid(policy = RegexValid.Policy.DATE) String date){
        System.out.println(date);
    }

    public static void main(String[] args) throws Exception {
        User user = new User("Tom", "1990-01-31", "xxx@163.com", "18612341234");
        User user2 = new User("Jack", "2019-02-29", "sadhgs", "183xxxxxxxx");
        if (RegexValidUtil.check(user)) {
            System.out.println(user + "正則校驗經過");
        }
        if (RegexValidUtil.check(user2)) {
            System.out.println(user2 + "正則校驗經過");
        }
    }
}
複製代碼

小結

參考資料

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程