java中的註解（Annotation）學習記錄

原創 Mr_wilson_liu 2020-06-13 05:04

Java 註解（Annotation）

Java 註解（Annotation）又稱 Java 標註，是 JDK5.0 引入的一種註釋機制。

Java 語言中的類、方法、變量、參數和包等都可以被標註。和 Javadoc 不同，Java 標註可以通過反射獲取標註內容。在編譯器生成類文件時，標註可以被嵌入到字節碼中。Java 虛擬機可以保留標註內容，在運行時可以獲取到標註內容 。 當然它也支持自定義 Java 標註。

理解 Annotation 的關鍵，是理解 Annotation 的語法和用法；理解 Annotation 的語法和用法之後，再看 Annotation 的框架圖，可能有更深刻體會。下面開始對 Annotation 進行說明。（本文數據來源於菜鳥教程）

內置的註解

Java 定義了一套註解，共有 7 個，3 個在 java.lang 中，剩下 4 個在 java.lang.annotation 中。

作用在代碼的註解是

  • @Override - 檢查該方法是否是重載方法。如果發現其父類，或者是引用的接口中並沒有該方法時，會報編譯錯誤。
  • @Deprecated - 標記過時方法。如果使用該方法，會報編譯警告。
  • @SuppressWarnings - 指示編譯器去忽略註解中聲明的警告。

作用在其他註解的註解(或者說 元註解)是:

  • @Retention - 標識這個註解怎麼保存，是隻在代碼中，還是編入class文件中，或者是在運行時可以通過反射訪問。
  • @Documented - 標記這些註解是否包含在用戶文檔中。
  • @Target - 標記這個註解應該是哪種 Java 成員。
  • @Inherited - 標記這個註解是繼承於哪個註解類(默認 註解並沒有繼承於任何子類)

從 Java 7 開始，額外添加了 3 個註解:

  • @SafeVarargs - Java 7 開始支持，忽略任何使用參數爲泛型變量的方法或構造函數調用產生的警告。
  • @FunctionalInterface - Java 8 開始支持，標識一個匿名函數或函數式接口。
  • @Repeatable - Java 8 開始支持，標識某註解可以在同一個聲明上使用多次。

1、Annotation 架構

從中，我們可以看出：

(01) 1 個 Annotation 和 1 個 RetentionPolicy 關聯。

可以理解爲：每1個Annotation對象，都會有唯一的RetentionPolicy屬性。

(02) 1 個 Annotation 和 1~n 個 ElementType 關聯。

可以理解爲：對於每 1 個 Annotation 對象，可以有若干個 ElementType 屬性。

(03) Annotation 有許多實現類，包括：Deprecated, Documented, Inherited, Override 等等。

Annotation 的每一個實現類，都 "和 1 個 RetentionPolicy 關聯" 並且 " 和 1~n 個 ElementType 關聯"。

下面，我先介紹框架圖的左半邊(如下圖)，即 Annotation, RetentionPolicy, ElementType；然後在就 Annotation 的實現類進行舉例說明。

2、Annotation 組成部分

java Annotation 的組成中，有 3 個非常重要的主幹類。它們分別是：

Annotation.java

package java.lang.annotation;
public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    String toString();

    Class<? extends Annotation> annotationType();
}

ElementType.java

package java.lang.annotation;

public enum ElementType {
    TYPE,               /* 類、接口（包括註釋類型）或枚舉聲明  */

    FIELD,              /* 字段聲明（包括枚舉常量）  */

    METHOD,             /* 方法聲明  */

    PARAMETER,          /* 參數聲明  */

    CONSTRUCTOR,        /* 構造方法聲明  */

    LOCAL_VARIABLE,     /* 局部變量聲明  */

    ANNOTATION_TYPE,    /* 註釋類型聲明  */

    PACKAGE             /* 包聲明  */
}

RetentionPolicy.java

package java.lang.annotation;
public enum RetentionPolicy {
    SOURCE,            /* Annotation信息僅存在於編譯器處理期間，編譯器處理完之後就沒有該Annotation信息了  */

    CLASS,             /* 編譯器將Annotation存儲於類對應的.class文件中。默認行爲  */

    RUNTIME            /* 編譯器將Annotation存儲於class文件中，並且可由JVM讀入 */
}

說明：

(01) Annotation 就是個接口。

"每 1 個 Annotation" 都與 "1 個 RetentionPolicy" 關聯，並且與 "1～n 個 ElementType" 關聯。可以通俗的理解爲：每 1 個 Annotation 對象，都會有唯一的 RetentionPolicy 屬性；至於 ElementType 屬性，則有 1~n 個。

(02) ElementType 是 Enum 枚舉類型，它用來指定 Annotation 的類型。

"每 1 個 Annotation" 都與 "1～n 個 ElementType" 關聯。當 Annotation 與某個 ElementType 關聯時，就意味着：Annotation有了某種用途。例如，若一個 Annotation 對象是 METHOD 類型，則該 Annotation 只能用來修飾方法。

(03) RetentionPolicy 是 Enum 枚舉類型，它用來指定 Annotation 的策略。通俗點說，就是不同 RetentionPolicy 類型的 Annotation 的作用域不同。

"每 1 個 Annotation" 都與 "1 個 RetentionPolicy" 關聯。

  • a) 若 Annotation 的類型爲 SOURCE，則意味着：Annotation 僅存在於編譯器處理期間，編譯器處理完之後，該 Annotation 就沒用了。 例如，" @Override" 標誌就是一個 Annotation。當它修飾一個方法的時候，就意味着該方法覆蓋父類的方法；並且在編譯期間會進行語法檢查！編譯器處理完後，"@Override" 就沒有任何作用了。
  • b) 若 Annotation 的類型爲 CLASS，則意味着：編譯器將 Annotation 存儲於類對應的 .class 文件中，它是 Annotation 的默認行爲。
  • c) 若 Annotation 的類型爲 RUNTIME，則意味着：編譯器將 Annotation 存儲於 class 文件中，並且可由JVM讀入。

這時，只需要記住"每 1 個 Annotation" 都與 "1 個 RetentionPolicy" 關聯，並且與 "1～n 個 ElementType" 關聯。學完後面的內容之後，再回頭看這些內容，會更容易理解。

3、java 自帶的 Annotation

理解了上面的 3 個類的作用之後，我們接下來可以講解 Annotation 實現類的語法定義了。

1）Annotation 通用定義

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation1 {
}

說明：

上面的作用是定義一個 Annotation，它的名字是 MyAnnotation1。定義了 MyAnnotation1 之後，我們可以在代碼中通過 "@MyAnnotation1" 來使用它。 其它的，@Documented, @Target, @Retention, @interface 都是來修飾 MyAnnotation1 的。下面分別說說它們的含義：

(01) @interface

使用 @interface 定義註解時，意味着它實現了 java.lang.annotation.Annotation 接口，即該註解就是一個Annotation。

定義 Annotation 時，@interface 是必須的。

注意：它和我們通常的 implemented 實現接口的方法不同。Annotation 接口的實現細節都由編譯器完成。通過 @interface 定義註解後，該註解不能繼承其他的註解或接口。

(02) @Documented

類和方法的 Annotation 在缺省情況下是不出現在 javadoc 中的。如果使用 @Documented 修飾該 Annotation，則表示它可以出現在 javadoc 中。

定義 Annotation 時，@Documented 可有可無；若沒有定義，則 Annotation 不會出現在 javadoc 中。

(03) @Target(ElementType.TYPE)

前面我們說過，ElementType 是 Annotation 的類型屬性。而 @Target 的作用，就是來指定 Annotation 的類型屬性。

@Target(ElementType.TYPE) 的意思就是指定該 Annotation 的類型是 ElementType.TYPE。這就意味着，MyAnnotation1 是來修飾"類、接口（包括註釋類型）或枚舉聲明"的註解。

定義 Annotation 時，@Target 可有可無。若有 @Target，則該 Annotation 只能用於它所指定的地方；若沒有 @Target，則該 Annotation 可以用於任何地方。

(04) @Retention(RetentionPolicy.RUNTIME)

前面我們說過，RetentionPolicy 是 Annotation 的策略屬性，而 @Retention 的作用，就是指定 Annotation 的策略屬性。

@Retention(RetentionPolicy.RUNTIME) 的意思就是指定該 Annotation 的策略是 RetentionPolicy.RUNTIME。這就意味着，編譯器會將該 Annotation 信息保留在 .class 文件中，並且能被虛擬機讀取。

定義 Annotation 時，@Retention 可有可無。若沒有 @Retention，則默認是 RetentionPolicy.CLASS。

2）java自帶的Annotation

通過上面的示例，我們能理解：@interface 用來聲明 Annotation，@Documented 用來表示該 Annotation 是否會出現在 javadoc 中， @Target 用來指定 Annotation 的類型，@Retention 用來指定 Annotation 的策略。

理解這一點之後，我們就很容易理解 java 中自帶的 Annotation 的實現類，即 Annotation 架構圖的右半邊。如下圖：

java 常用的 Annotation：

@Deprecated  -- @Deprecated 所標註內容，不再被建議使用。
@Override    -- @Override 只能標註方法，表示該方法覆蓋父類中的方法。
@Documented  -- @Documented 所標註內容，可以出現在javadoc中。
@Inherited   -- @Inherited只能被用來標註“Annotation類型”，它所標註的Annotation具有繼承性。
@Retention   -- @Retention只能被用來標註“Annotation類型”，而且它被用來指定Annotation的RetentionPolicy屬性。
@Target      -- @Target只能被用來標註“Annotation類型”，而且它被用來指定Annotation的ElementType屬性。
@SuppressWarnings -- @SuppressWarnings 所標註內容產生的警告，編譯器會對這些警告保持靜默。

由於 "@Deprecated 和 @Override" 類似，"@Documented, @Inherited, @Retention, @Target" 類似；下面，我們只對 @Deprecated, @Inherited, @SuppressWarnings 這 3 個 Annotation 進行說明。

2.1) @Deprecated

@Deprecated 的定義如下：

@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Deprecated {
}

說明：

  • (01) @interface -- 它的用來修飾 Deprecated，意味着 Deprecated 實現了 java.lang.annotation.Annotation 接口；即 Deprecated 就是一個註解。 (02) @Documented -- 它的作用是說明該註解能出現在 javadoc 中。
  • (03) @Retention(RetentionPolicy.RUNTIME) -- 它的作用是指定 Deprecated 的策略是 RetentionPolicy.RUNTIME。這就意味着，編譯器會將Deprecated 的信息保留在 .class 文件中，並且能被虛擬機讀取。
  • (04) @Deprecated 所標註內容，不再被建議使用。

例如，若某個方法被 @Deprecated 標註，則該方法不再被建議使用。如果有開發人員試圖使用或重寫被 @Deprecated 標示的方法，編譯器會給相應的提示信息。示例如下:

DeprecatedTest.java

import java.util.Date;
import java.util.Calendar;

public class DeprecatedTest {
    // @Deprecated 修飾 getString1(),表示 它是建議不被使用的函數
    @Deprecated
    private static void getString1(){
        System.out.println("Deprecated Method");
    }
   
    private static void getString2(){
        System.out.println("Normal Method");
    }
   
    // Date是日期/時間類。java已經不建議使用該類了
    private static void testDate() {
        Date date = new Date(113, 8, 25);
        System.out.println(date.getYear());
    }
    // Calendar是日期/時間類。java建議使用Calendar取代Date表示"日期/時間"
    private static void testCalendar() {
        Calendar cal = Calendar.getInstance();
        System.out.println(cal.get(Calendar.YEAR));
    }
   
    public static void main(String[] args) {
        getString1();
        getString2();
        testDate();
        testCalendar();
    }
}

說明：

上面是 eclipse 中的截圖，比較類中 "getString1() 和 getString2()" 以及 "testDate() 和 testCalendar()" 。

(01) getString1() 被 @Deprecated 標註，意味着建議不再使用 getString1(); 所以 getString1() 的定義和調用時，都會一橫線。這一橫線是eclipse() 對 @Deprecated 方法的處理。

getString2() 沒有被 @Deprecated 標註，它的顯示正常。

(02) testDate() 調用了 Date 的相關方法，而 java 已經建議不再使用 Date 操作日期/時間。因此，在調用 Date的API 時，會產生警告信息，途中的 warnings。

testCalendar() 調用了 Calendar 的 API 來操作日期/時間，java 建議用 Calendar 取代 Date。因此，操作 Calendar 不會產生 warning。

2.2) @Inherited

@Inherited 的定義如下：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Inherited {
}

說明：

  • (01) @interface -- 它的用來修飾 Inherited，意味着 Inherited 實現了 java.lang.annotation.Annotation 接口；即 Inherited 就是一個註解。
  • (02) @Documented -- 它的作用是說明該註解能出現在 javadoc 中。
  • (03) @Retention(RetentionPolicy.RUNTIME) -- 它的作用是指定 Inherited 的策略是 RetentionPolicy.RUNTIME。這就意味着，編譯器會將 Inherited 的信息保留在 .class 文件中，並且能被虛擬機讀取。
  • (04) @Target(ElementType.ANNOTATION_TYPE) -- 它的作用是指定 Inherited 的類型是 ANNOTATION_TYPE。這就意味着，@Inherited 只能被用來標註 "Annotation 類型"。
  • (05) @Inherited 的含義是，它所標註的Annotation將具有繼承性。

假設，我們定義了某個 Annotaion，它的名稱是 MyAnnotation，並且 MyAnnotation 被標註爲 @Inherited。現在，某個類 Base 使用了

MyAnnotation，則 Base 具有了"具有了註解 MyAnnotation"；現在，Sub 繼承了 Base，由於 MyAnnotation 是 @Inherited的(具有繼承性)，所以，Sub 也 "具有了註解 MyAnnotation"。

@Inherited 的使用示例:

InheritableSon.java

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

/**
 * 自定義的Annotation。
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@interface Inheritable
{
}

@Inheritable
class InheritableFather
{
    public InheritableFather() {
        // InheritableBase是否具有 Inheritable Annotation
        System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
    }
}

/**
 * InheritableSon 類只是繼承於 InheritableFather，
 */
public class InheritableSon extends InheritableFather
{
    public InheritableSon() {
        super();    // 調用父類的構造函數
        // InheritableSon類是否具有 Inheritable Annotation
        System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
    }
   
    public static void main(String[] args)
    {
        InheritableSon is = new InheritableSon();
    }
}

運行結果：

InheritableFather:true
InheritableSon:true

現在，我們對 InheritableSon.java 進行修改：註釋掉 "Inheritable 的 @Inherited 註解"。

InheritableSon.java

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

/**
 * 自定義的Annotation。
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
//@Inherited
@interface Inheritable
{
}

@Inheritable
class InheritableFather
{
    public InheritableFather() {
        // InheritableBase是否具有 Inheritable Annotation
        System.out.println("InheritableFather:"+InheritableFather.class.isAnnotationPresent(Inheritable.class));
    }
}

/**
 * InheritableSon 類只是繼承於 InheritableFather，
 */
public class InheritableSon extends InheritableFather
{
    public InheritableSon() {
        super();    // 調用父類的構造函數
        // InheritableSon類是否具有 Inheritable Annotation
        System.out.println("InheritableSon:"+InheritableSon.class.isAnnotationPresent(Inheritable.class));
    }
   
    public static void main(String[] args)
    {
        InheritableSon is = new InheritableSon();
    }
}

運行結果：

InheritableFather:true
InheritableSon:false

對比上面的兩個結果，我們發現：當註解 Inheritable 被 @Inherited 標註時，它具有繼承性。否則，沒有繼承性。

2.3) @SuppressWarnings

@SuppressWarnings 的定義如下：

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

說明：

(01) @interface -- 它的用來修飾 SuppressWarnings，意味着 SuppressWarnings 實現了 java.lang.annotation.Annotation 接口；即 SuppressWarnings 就是一個註解。

(02) @Retention(RetentionPolicy.SOURCE) -- 它的作用是指定 SuppressWarnings 的策略是 RetentionPolicy.SOURCE。這就意味着，SuppressWarnings 信息僅存在於編譯器處理期間，編譯器處理完之後 SuppressWarnings 就沒有作用了。

(03) @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE}) -- 它的作用是指定 SuppressWarnings 的類型同時包括TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE。

  • TYPE 意味着，它能標註"類、接口（包括註釋類型）或枚舉聲明"。
  • FIELD 意味着，它能標註"字段聲明"。
  • METHOD 意味着，它能標註"方法"。
  • PARAMETER 意味着，它能標註"參數"。
  • CONSTRUCTOR 意味着，它能標註"構造方法"。
  • LOCAL_VARIABLE 意味着，它能標註"局部變量"。

(04) String[] value(); 意味着，SuppressWarnings 能指定參數

(05) SuppressWarnings 的作用是，讓編譯器對"它所標註的內容"的某些警告保持靜默。例如，"@SuppressWarnings(value={"deprecation", "unchecked"})" 表示對"它所標註的內容"中的 "SuppressWarnings 不再建議使用警告"和"未檢查的轉換時的警告"保持沉默。示例如下：

SuppressWarningTest.java

import java.util.Date;

public class SuppressWarningTest {

    //@SuppressWarnings(value={"deprecation"})
    public static void doSomething(){
        Date date = new Date(113, 8, 26);
        System.out.println(date);
    }

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

說明：

(01) 左邊的圖中，沒有使用 @SuppressWarnings(value={"deprecation"}) , 而 Date 屬於 java 不再建議使用的類。因此，調用 Date 的 API 時，會產生警告。而右邊的途中，使用了 @SuppressWarnings(value={"deprecation"})。因此，編譯器對"調用 Date 的 API 產生的警告"保持沉默。

補充：SuppressWarnings 常用的關鍵字的表格

deprecation  -- 使用了不贊成使用的類或方法時的警告
unchecked    -- 執行了未檢查的轉換時的警告，例如當使用集合時沒有用泛型 (Generics) 來指定集合保存的類型。
fallthrough  -- 當 Switch 程序塊直接通往下一種情況而沒有 Break 時的警告。
path         -- 在類路徑、源文件路徑等中有不存在的路徑時的警告。
serial       -- 當在可序列化的類上缺少 serialVersionUID 定義時的警告。
finally      -- 任何 finally 子句不能正常完成時的警告。
all          -- 關於以上所有情況的警告。

4、Annotation 的作用

Annotation 是一個輔助類，它在 Junit、Struts、Spring 等工具框架中被廣泛使用。

我們在編程中經常會使用到的 Annotation 作用有：

1）編譯檢查

Annotation 具有"讓編譯器進行編譯檢查的作用"。

例如，@SuppressWarnings, @Deprecated 和 @Override 都具有編譯檢查作用。

(01) 關於 @SuppressWarnings 和 @Deprecated，已經在"第3部分"中詳細介紹過了。這裏就不再舉例說明了。

(02) 若某個方法被 @Override 的標註，則意味着該方法會覆蓋父類中的同名方法。如果有方法被 @Override 標示，但父類中卻沒有"被 @Override 標註"的同名方法，則編譯器會報錯。示例如下：

OverrideTest.java

public class OverrideTest {

    /**
     * toString() 在java.lang.Object中定義；
     * 因此，這裏用 @Override 標註是對的。
     */
    @Override
    public String toString(){
        return "Override toString";
    }

    /**
     * getString() 沒有在OverrideTest的任何父類中定義；
     * 但是，這裏卻用 @Override 標註，因此會產生編譯錯誤！
     */
    @Override
    public String getString(){
        return "get toString";
    }
   
    public static void main(String[] args) {
    }
}

上面是該程序在 eclipse 中的截圖。從中，我們可以發現 "getString()" 函數會報錯。這是因爲 "getString() 被 @Override 所標註，但在OverrideTest 的任何父類中都沒有定義 getString1() 函數"。

"將 getString() 上面的 @Override註釋掉"，即可解決該錯誤。

2) 在反射中使用 Annotation

在反射的 Class, Method, Field 等函數中，有許多於 Annotation 相關的接口。

這也意味着，我們可以在反射中解析並使用 Annotation。

AnnotationTest.java
import java.lang.annotation.Annotation;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Inherited;
import java.lang.reflect.Method;

/**
 * Annotation在反射函數中的使用示例
 */
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String[] value() default "unknown";
}

/**
 * Person類。它會使用MyAnnotation註解。
 */
class Person {
   
    /**
     * empty()方法同時被 "@Deprecated" 和 "@MyAnnotation(value={"a","b"})"所標註
     * (01) @Deprecated，意味着empty()方法，不再被建議使用
     * (02) @MyAnnotation, 意味着empty() 方法對應的MyAnnotation的value值是默認值"unknown"
     */
    @MyAnnotation
    @Deprecated
    public void empty(){
        System.out.println("\nempty");
    }
   
    /**
     * sombody() 被 @MyAnnotation(value={"girl","boy"}) 所標註，
     * @MyAnnotation(value={"girl","boy"}), 意味着MyAnnotation的value值是{"girl","boy"}
     */
    @MyAnnotation(value={"girl","boy"})
    public void somebody(String name, int age){
        System.out.println("\nsomebody: "+name+", "+age);
    }
}

public class AnnotationTest {

    public static void main(String[] args) throws Exception {
       
        // 新建Person
        Person person = new Person();
        // 獲取Person的Class實例
        Class<Person> c = Person.class;
        // 獲取 somebody() 方法的Method實例
        Method mSomebody = c.getMethod("somebody", new Class[]{String.class, int.class});
        // 執行該方法
        mSomebody.invoke(person, new Object[]{"lily", 18});
        iteratorAnnotations(mSomebody);
       

        // 獲取 somebody() 方法的Method實例
        Method mEmpty = c.getMethod("empty", new Class[]{});
        // 執行該方法
        mEmpty.invoke(person, new Object[]{});        
        iteratorAnnotations(mEmpty);
    }
   
    public static void iteratorAnnotations(Method method) {

        // 判斷 somebody() 方法是否包含MyAnnotation註解
        if(method.isAnnotationPresent(MyAnnotation.class)){
            // 獲取該方法的MyAnnotation註解實例
            MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
            // 獲取 myAnnotation的值，並打印出來
            String[] values = myAnnotation.value();
            for (String str:values)
                System.out.printf(str+", ");
            System.out.println();
        }
       
        // 獲取方法上的所有註解，並打印出來
        Annotation[] annotations = method.getAnnotations();
        for(Annotation annotation : annotations){
            System.out.println(annotation);
        }
    }
}

運行結果：

somebody: lily, 18
girl, boy, 
@com.skywang.annotation.MyAnnotation(value=[girl, boy])

empty
unknown, 
@com.skywang.annotation.MyAnnotation(value=[unknown])
@java.lang.Deprecated()

3) 根據 Annotation 生成幫助文檔

通過給 Annotation 註解加上 @Documented 標籤，能使該 Annotation 標籤出現在 javadoc 中。

4) 能夠幫忙查看查看代碼

通過 @Override, @Deprecated 等，我們能很方便的瞭解程序的大致結構。

另外，我們也可以通過自定義 Annotation 來實現一些功能。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Java中線程的創建方式

繼承 Thread 類 Thread 類本質上是實現了 Runnable 接口的一個實例，代表一個線程的實例。 啓動線程的唯一方法就是通過 Thread 類的 start()實例方法。 start()方法是一個 native 方法，它將

原創 2024-05-04 21:31:13

Java集合中的Set

Set 有去重的特性，該體系集合用於存儲無序(存入和取出的順序不一定相同)元素，值不能重複。對象的相等性本質是對象hashCode值（java是依據對象的內存地址計算出的此序號）判斷的，如果想要讓兩個不同的對象視爲相等的，就必須覆蓋Obje

原創 2024-05-02 23:34:26

Java中的List

List 是Java中非常常用的數據類型。 List 是有序的 Collection。 Java List 一共三個實現類：分別是 ArrayList、 Vector 和 LinkedList。 ArrayList（數組） Array

原創 2024-05-01 21:31:27

通義靈碼實戰系列：一個新項目如何快速啓動，如何維護遺留系統代碼庫？

作者：別象 進入 2024 年，AI 熱度持續上升，翻閱科技區的文章，AI 可謂是軍書十二卷，卷卷有爺名。而麥肯錫最近的研究報告顯示，軟件工程是 AI 影響最大的領域之一，AI 已經成爲了軟件工程的必選項，也有研究稱開發者每天的事務性工作可

原創 2024-04-30 21:12:20

Apache DolphinScheduler支持Flink嗎？

隨着大數據技術的快速發展，很多企業開始將Flink引入到生產環境中，以滿足日益複雜的數據處理需求。而作爲一款企業級的數據調度平臺，Apache DolphinScheduler也跟上了時代步伐，推出了對Flink任務類型的支持。 Flink

原創 2024-04-30 11:49:27

Spring AI 搶先體驗，5 分鐘玩轉 Java AI 應用開發

作者：劉軍 Spring AI 是 Spring 官方社區項目，旨在簡化 Java AI 應用程序開發，讓 Java 開發者像使用 Spring 開發普通應用一樣開發 AI 應用。 Spring Cloud Alibaba AI 以 Spr

原創 2024-04-29 21:12:12

1 名工程師輕鬆管理 20 個工作流，創業企業用 Serverless 讓數據處理流程提效

作者：嶽洋、陳德全、劉靜娜 北京語勢科技有限公司成立於 2023 年 6 月，語勢科技定位爲“智能投資時代的主題入口”，在資管行業從以機構爲核心轉向以用戶爲核心的變革時代，通過打造主題投資引擎，賦能普惠投資一體化，打造以投資者和資管機構爲主

原創 2024-04-28 21:12:22

哈哈哈哈或

在Java編程中，簡潔高效的實現往往涉及幾個關鍵原則和技能。例如，使用簡單的代碼結構來提高代碼訪問性和可維護性，這意味着代碼應該追求清晰、簡潔且模式匿名，因爲過度模式匿名會導致複雜度增長，影響代碼的維護性和效率。 其中，簡潔高效還包攜

原創 2024-04-28 00:40:41

Java編程工具：簡潔高效實現

Java編程工具：簡潔高效實現Java編程工具：簡潔高效實現Java編程工具：簡潔高效實現

原創 2024-04-27 00:41:09

Java word通過html設置樣式（Spire Docx）

  Java  word通過html設置樣式（Spire Docx） <dependencies>   <!-- Apache POI dependency for Word --> <dependency>

原創 2024-04-26 23:42:09

從零開始學架構V2-初識架構設計-1

一、架構設計的主要目的 爲了解決軟件系統複雜度帶來的問題 二、複雜性來源 軟件的架構設計是一個非常複雜的過程；基於業務&技術現狀、公司成本、團隊規模、團隊技術能力、近三年業務發展規模預測、技術發展趨勢等條件篩選出合適的技術、編寫多種架構設計

原創 2024-04-25 23:56:25

高德地圖爬蟲實踐：Java多線程併發處理策略

背景介紹 高德地圖是一款基於互聯網和移動互聯網的地圖與導航應用，提供了包括地圖瀏覽、公交查詢、駕車導航、步行導航等在內的多種功能。其龐大的用戶羣體和豐富的地圖數據成爲了各行各業進行位置服務、地理信息分析等應用的首選。 爬蟲實踐需求 在

原創 2024-04-25 23:26:44

三十分鐘入門基礎Go（Java小子版）

前言 Go語言定義 Go（又稱 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thompson 開發的一種靜態、強類型、編譯型語言。Go 語言語法與 C 相近，但功能上有：內存安

原創 2024-04-25 23:17:43

流水線運行出錯排查難？AI 來幫你

“我的企業有幾千條流水線，每次流水線運行出錯，都要投入不少的技術人員進去排查，需要花費不少的時間。” 遇到這種情況，怎麼解決。在 AI 爆火的今天，AI 如何助力 DevOps 效率提升？ 雲效與阿里雲通義大模型合作，推出了流水線智能排查能

原創 2024-04-24 21:12:07

西安站開營！AI 編碼助手通義靈碼幫大學生“整活兒”

如何更好地與 AI 爲伴，做時代的先進開發者？4 月 17 日，阿里雲推出的 AI 編程助手通義靈碼與雲工開物“高校訓練營”走進西安多所高校開啓實操培訓，結合 AI 輔助編程的發展背景、通義靈碼的具體能力和應用實操，幫助在校大學生了解人工智

原創 2024-04-24 21:12:06