2. 程式人生 > 其它 >Spring系列20：註解詳解和Spring註解增強(基礎內功)

Spring系列20：註解詳解和Spring註解增強(基礎內功)

阿新 • • 發佈：2022-03-10

有部分小夥伴反饋說前面基於註解的Spring中大量使用註解，由於對Java的註解不熟悉，有點難受。建議總結一篇的Java註解的基礎知識，那麼，它來了！

本文內容

  1. 什麼是註解？
  2. 如何定義註解
  3. 如何使用註解
  4. 如何獲取註解資訊
  5. Spring 中對註解做了什麼增強？

什麼是註解？

什麼是程式碼中寫的註釋？那是給開發者看的，但是編譯之後的位元組碼檔案中是沒有註釋資訊的，也就是說註釋對於java編譯器和JVM來說是沒有意義的，看不到！

類比註釋是給人看的，註解則是給java編譯器和JVM看的一些標識，編譯器和虛擬機器在執行的過程中可以獲取註解資訊來做一些處理。

如何定義註解

註解定義的語法如下：

public	@interface 註解類名{
    引數型別 引數名稱1() [default 引數預設值];
    引數型別 引數名稱2() [default 引數預設值];
}

引數名稱可以沒有，也可以定義多個，定義細節如下：

  • 引數型別只能是基本型別、String、Class、列舉型別、註解型別以及對應的一維陣列
  • 如果註解引數只有1個，建議定義名稱為value，方便使用時預設引數名
  • default 可以指定預設值，如果沒有預設值使用註解時必須給定引數值

定義註解時候需要考慮2個主要問題：

  • 註解可以使用在哪裡也就是使用範圍？
  • 註解保留到什麼階段，原始碼階段，還是執行階段？

java提供了一部分的元註解來解決上面的問題。

@Target指定註解的使用範圍

來看下原始碼，主要是指定了可以應用註釋型別的元素種類的陣列引數。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    // 返回可以應用註釋型別的元素種類的陣列
    ElementType[] value();
}

 
/*註解的使用範圍*/
public enum ElementType {
    /*類、介面、列舉、註解上面*/
    TYPE,
    /*欄位上*/
    FIELD,
    /*方法上*/
    METHOD,
    /*方法的引數上*/
    PARAMETER,
    /*建構函式上*/
    CONSTRUCTOR,
    /*本地變數上*/
    LOCAL_VARIABLE,
    /*註解上*/
    ANNOTATION_TYPE,
    /*包上*/
    PACKAGE,
    /*型別引數上 1.8之後*/
    TYPE_PARAMETER,
    /*型別名稱上 1.8之後*/
    TYPE_USE
}

@Retention指定註解的保留策略

指示要保留帶註釋型別的註釋多長時間。如果註釋型別宣告中不存在保留註釋，則保留策略預設為 RetentionPolicy.CLASS

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

public enum RetentionPolicy {
    // 原始碼階段，註解被編譯器丟棄。
    SOURCE,

    // 註釋將由編譯器記錄在類檔案中，但不需要在執行時由 VM 保留。這是預設行為。
    CLASS,

    // 註釋將由編譯器記錄在類檔案中，並在執行時由 VM 保留，因此可以反射性地讀取它們。
    RUNTIME
}

綜合上面2個註解，自定義一個保留到執行期的僅用在方法上的註解如下。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DemoAnnotation {
    String name() default "";
    Class targetClazz();
}

如何使用註解

使用語法

@註解類(引數1=值1,引數2=值2,引數3=值3,引數n=值n)
目標物件

使用前一節的註解來個簡單的案例

public class MyBean {
    @DemoAnnotation(name = "xxx", targetClazz = MyBean.class)
    public void m() {

    }
}

來一個綜合案例，註解位置包括類上、方法上、建構函式上、方法引數上、欄位上、本地變數上、泛型型別引數和型別名稱上。

/**
 * 綜合案例
 * @author zfd
 * @version v1.0
 * @date 2022/1/24 13:31
 * @關於我 請關注公眾號 螃蟹的Java筆記 獲取更多技術系列
 */
@StrongAnnotation(value = "用在類上", elementType = ElementType.TYPE)
public class UseStrongAnnotation<@StrongAnnotation(value = "用在型別引數上T0", elementType = ElementType.TYPE_PARAMETER) T0,
        @StrongAnnotation(value = "用在型別名稱上T1", elementType = ElementType.TYPE_USE) T1> {
    @StrongAnnotation(value = "用在欄位上", elementType = ElementType.FIELD)
    private String field;

    @StrongAnnotation(value = "構造方法上", elementType = ElementType.CONSTRUCTOR)
    public UseStrongAnnotation(@StrongAnnotation(value = "用在方法引數上", elementType = ElementType.PARAMETER) String field) {
        this.field = field;
    }

    @StrongAnnotation(value = "用在普通方法上", elementType = ElementType.METHOD)
    public void m(@StrongAnnotation(value = "方法引數上", elementType = ElementType.PARAMETER) String name) {
        @StrongAnnotation(value = "用在本地變數上", elementType = ElementType.LOCAL_VARIABLE)
        String prefix = "hello ";
        System.out.println(prefix + name);
    }

    public <@StrongAnnotation(value = "方法的型別引數T2上", elementType = ElementType.TYPE_PARAMETER) T2> void m1() {

    }
    public <@StrongAnnotation(value = "方法的型別名稱T3上", elementType = ElementType.TYPE_USE) T3> void m2() {

    }

    private Map<@StrongAnnotation(value = "Map後面的尖括號也是型別名稱", elementType = ElementType.TYPE_USE) String ,
    @StrongAnnotation(value = "Map後面的尖括號也是型別名稱", elementType = ElementType.TYPE_PARAMETER)Object> map;
}

如何獲取註解資訊

java.lang.reflect.AnnotatedElement介面表示當前在此 VM 中執行的程式的註解元素。 該介面允許以反射方式讀取註解。 此介面中方法返回的所有註解都是不可變的和可序列化的。 該介面的方法返回的陣列可以被呼叫者修改，而不影響返回給其他呼叫者的陣列。其獲取註解的主要方法如下，見名知意。

主要的實現類或介面圖如下

對應的實現的含義也很明確：

  • Package：用來表示包的資訊
  • Class：用來表示類的資訊
  • Constructor：用來表示構造方法資訊
  • Field：用來表示類中屬性資訊
  • Method：用來表示方法資訊
  • Parameter：用來表示方法引數資訊
  • TypeVariable：用來表示型別變數資訊，如：類上定義的泛型型別變數，方法上面定義的泛型型別變數

綜合案例

來一個綜合案例來解析上一節的註解使用UseStrongAnnotation。測試用例和結果如下，建議多實戰敲敲程式碼。

package com.crab.spring.ioc.demo17;

import com.sun.xml.internal.bind.v2.model.core.ID;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.Arrays;

import static org.junit.Assert.*;

/**
 * @author zfd
 * @version v1.0
 * @date 2022/1/24 13:52
 * @關於我 請關注公眾號 螃蟹的Java筆記 獲取更多技術系列
 */
public class UseStrongAnnotationTest {
    @Test
    public void test_annotated_class() {
        System.out.println("解析類上註解：");
        Arrays.stream(UseStrongAnnotation.class.getAnnotations())
                .forEach(System.out::println);
    }
    // 解析類上註解：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在類上, elementType=TYPE)

    @Test
    public void test_annotated_class_type_parameter() {
        TypeVariable<Class<UseStrongAnnotation>>[] typeParameters = UseStrongAnnotation.class.getTypeParameters();
        for (TypeVariable<Class<UseStrongAnnotation>> typeParameter : typeParameters) {
            System.out.println(typeParameter.getName() + " 1.8變數引數或變數名稱註解資訊：");
            Annotation[] annotations = typeParameter.getAnnotations();
            Arrays.stream(annotations).forEach(System.out::println);
        }
    }
    // T0 1.8變數引數或變數名稱註解資訊：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在型別引數上T0, elementType=TYPE_PARAMETER)
    // T1 1.8變數引數或變數名稱註解資訊：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在型別名稱上T1, elementType=TYPE_USE)

    @Test
    public void test_annotated_field() throws NoSuchFieldException {
        Field field = UseStrongAnnotation.class.getDeclaredField("field");
        Arrays.stream(field.getAnnotations()).forEach(System.out::println);
    }
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在欄位上, elementType=FIELD)
    

    @Test
    public void test_annotated_constructor() {
        Constructor<?> constructor = UseStrongAnnotation.class.getDeclaredConstructors()[0];
        for (Annotation annotation : constructor.getAnnotations()) {
            System.out.println(annotation);
        }
    }
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=構造方法上, elementType=CONSTRUCTO

    @Test
    public void test_annotated_normal_method() throws NoSuchMethodException {
        Method method = UseStrongAnnotation.class.getDeclaredMethod("m", String.class);
        System.out.println("方法註解：");
        for (Annotation annotation : method.getAnnotations()) {
            System.out.println(annotation);
        }
        System.out.println("方法引數註解：");
        Parameter[] parameters = method.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter.getName() + " 引數註解：");
            for (Annotation annotation : parameter.getAnnotations()) {
                System.out.println(annotation);
            }
        }
    }
    // 方法註解：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在普通方法上, elementType=METHOD)
    // 方法引數註解：
    // name 引數註解：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=方法引數上, elementType=PARAMETER)

    @Test
    public void test_annotated_map_type() throws NoSuchFieldException {
        Field field = UseStrongAnnotation.class.getDeclaredField("map");
        // 返回一個 Type 物件，該物件表示此 Field 物件表示的欄位的宣告型別。
        // 如果 Type 是引數化型別，則返回的 Type 物件必須準確反映原始碼中使用的實際型別引數。
        Type genericType = field.getGenericType();
        // 獲取返回表示此型別的實際型別引數的 Type 物件陣列
        Type[] actualTypeArguments = ((ParameterizedType) genericType).getActualTypeArguments();

        // 返回一個 AnnotatedType 物件，該物件表示使用一個型別來指定此 Field 表示的欄位的宣告型別。
        AnnotatedType annotatedType = field.getAnnotatedType();
        // 獲取此引數化型別的可能帶註釋的實際型別引數陣列
        AnnotatedType[] annotatedActualTypeArguments =
                ((AnnotatedParameterizedType) annotatedType).getAnnotatedActualTypeArguments();
        int index = 0;
        for (AnnotatedType annotatedActualTypeArgument : annotatedActualTypeArguments) {
            Type actualTypeArgument = actualTypeArguments[index++];
            System.out.println(annotatedActualTypeArgument.getType());
            System.out.println(actualTypeArgument.getTypeName() + " 型別上的註解：");
            for (Annotation annotation : annotatedActualTypeArgument.getAnnotations()) {
                System.out.println(annotation);
            }
        }

    }
    // T0 1.8變數引數或變數名稱註解資訊：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在型別引數上T0, elementType=TYPE_PARAMETER)
    // T1 1.8變數引數或變數名稱註解資訊：
    // @com.crab.spring.ioc.demo17.StrongAnnotation(value=用在型別名稱上T1, elementType=TYPE_USE)


}

@Inherited實現子類繼承父類的註解

@Inherited指示註解型別是自動繼承的。注意針對的父類的註解，介面是無效的

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

來看一個案例，父類和介面上都有可繼承的註解，觀察下子類的上的註解情況。

/**
 * 測試父類註解的繼承
 * 注意：是類，不是介面，介面無效
 * @author zfd
 * @version v1.0
 * @date 2022/1/24 17:15
 * @關於我 請關注公眾號 螃蟹的Java筆記 獲取更多技術系列
 */
public class TestInherited {

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @interface Annotation1{}

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @interface Annotation2{}


    @Annotation1
    interface Interface1{}
    @Annotation2
    static class SupperClass{}

    // 繼承 SupperClass 實現 Interface1，觀察其註解繼承情況
    static class SubClass extends SupperClass implements Interface1{}

    public static void main(String[] args) {
        for (Annotation annotation : SubClass.class.getAnnotations()) {
            System.out.println(annotation);
        }
    }
    // 輸出
    // @com.crab.spring.ioc.demo17.TestInherited$Annotation2()
    // 只繼承了父類註解 無法繼承介面上的註解
}

@Repeatable重複註解

常規情況下同一個目標上是無法使用同一個註解多個重複標記的。如果自定義註解需要實現可重複註解，則在定義的時候可以使用 @Repeatable來宣告的註解型別是可重複的。

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Repeatable {
    // 指定容器註解型別
    Class<? extends Annotation> value();
}

模擬 @ComponentScan @ComponentScans來提供一個案例。

/**
 * 測試 @Repeatable 註解重複使用
 * @author zfd
 * @version v1.0
 * @date 2022/1/24 17:30
 * @關於我 請關注公眾號 螃蟹的Java筆記 獲取更多技術系列
 */
public class TestRepeatable {
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Repeatable(ComponentScans.class)
    @interface  ComponentScan{}

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface ComponentScans{
        // 注意： 必須定義value引數，其型別是子重複註解的陣列型別
        ComponentScan[] value();
    }

    // 重複註解方式1
    @ComponentScan
    @ComponentScan
    static class MyComponent{}

    // 重複註解方式2
    @ComponentScans({@ComponentScan, @ComponentScan})
    static class MyComponentB{}

    public static void main(String[] args) {
        for (Annotation annotation : MyComponent.class.getAnnotations()) {
            System.out.println(annotation);
        }
        for (Annotation annotation : MyComponentB.class.getAnnotations()) {
            System.out.println(annotation);
        }
    }
    // 輸出
    // @com.crab.spring.ioc.demo17.TestRepeatable$ComponentScans(value=[@com.crab.spring.ioc.demo17
    // .TestRepeatable$ComponentScan(), @com.crab.spring.ioc.demo17.TestRepeatable$ComponentScan()])
    // @com.crab.spring.ioc.demo17.TestRepeatable$ComponentScans(value=[@com.crab.spring.ioc.demo17
    // .TestRepeatable$ComponentScan(), @com.crab.spring.ioc.demo17.TestRepeatable$ComponentScan()])

}

Spring 中@AliasFor對註解的增強

註解的定義引數是不能繼承，如註解A上面有註解B，但是實際在使用B註解在目標類C的過程中想要設定A的引數是做不到的。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnotationA {
    String name() default "";
    int value() default -1;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@AnnotationA
public @interface AnnotationB {
    String name() default "";
    int value() default 1;
    String aliasForName() default "";
}

@AnnotationB(name = "xxx", value = 1) // 無法設定AnnotiaonA的引數值
public class ClassC {
}

Spring 中 提供了@AliasFor 元註解，用於宣告註解屬性的別名，主要的使用場景：

  • 註解中的顯式別名：在單個註解中， @AliasFor可以在一對屬性上宣告，以表明它們是彼此可互換的別名
  • 元註解中屬性的顯式別名：如果@AliasFor的annotation屬性設定為與宣告它的註解不同的註解，則該attribute被解釋為元註解中屬性的別名（即顯式元註解屬性覆蓋）。 這可以精確控制註解層次結構中覆蓋的屬性。
  • 註解中的隱式別名：如果註解中的一個或多個屬性被宣告為相同元註解屬性的屬性覆蓋（直接或傳遞），則這些屬性將被視為彼此的一組隱式別名，從而導致類似於註解中顯式別名的行為。

原始碼簡單過一下

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface AliasFor {

	@AliasFor("attribute")
	String value() default "";

	@AliasFor("value")
	String attribute() default "";

	// 宣告別名屬性的註解型別。預設為 Annotation，這意味著別名屬性在與此屬性相同的註解中宣告。
	Class<? extends Annotation> annotation() default Annotation.class;

}

綜合案例

來使用@AliasFor 改造下 AnnotationB。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@AnnotationA
public @interface AnnotationB {
    // 註解AnnotationB內部顯式別名
    @AliasFor(value = "aliasForName")
    String name() default "";

    int value() default 1;

    // 註解AnnotationB內部顯式別名
    @AliasFor(annotation = AnnotationB.class, attribute = "name")
    String aliasForName() default "";

    // 元註解AnnotationA屬性name顯式別名
    @AliasFor(annotation = AnnotationA.class, value = "name")
    String aliasForAnnotationAName() default "";

    // 元註解AnnotationA屬性name顯式別名2
    @AliasFor(annotation = AnnotationA.class, value = "name")
    String aliasForAnnotationAName2() default "";

    // 元註解AnnotationA屬性value顯式別名
    @AliasFor(annotation = AnnotationA.class, value = "value")
    int aliasForAnnotationAValue() default -1;
}

使用AnnotationB 註解，注意：互為別名的屬性設定時只能設定其中一個，否則設定多個會報錯。

@AnnotationB(value = 100,
        name = "xx",
        aliasForAnnotationAName = "a1",
        aliasForAnnotationAValue = -100
)
public class ClassC2 {
    public static void main(String[] args) {
        //spring提供一個查詢註解的工具類AnnotatedElementUtils
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(ClassC2.class, AnnotationB.class));
        System.out.println(AnnotatedElementUtils.getMergedAnnotation(ClassC2.class, AnnotationA.class));
    }
}

輸出結果顯示AnnotationB 通過別名設定AnnotationA中屬性成功。

@com.crab.spring.ioc.demo17.AnnotationB(aliasForAnnotationAName=a1, aliasForAnnotationAName2=a1, aliasForAnnotationAValue=-100, aliasForName=xx, name=xx, value=100)
@com.crab.spring.ioc.demo17.AnnotationA(name=a1, value=-100)

總結

本文詳解了註解的概念，如何定義註解、使用註解、獲取註解；並介紹了元註解@Target、@Retention、@Inherited、@Repeatable 的使用；重點講解了Spring 中 @AliasFor 註解來為元註解屬性設定別名的增強處理。

本篇原始碼地址： https://github.com/kongxubihai/pdf-spring-series/tree/main/spring-series-ioc/src/main/java/com/crab/spring/ioc/demo17
知識分享，轉載請註明出處。學無先後，達者為先！

相關推薦

Spring系列20：註解詳解和Spring註解增強(基礎內功)

有部分小夥伴反饋說前面基於註解的Spring中大量使用註解，由於對Java的註解不熟悉，有點難受。建議總結一篇的Java註解的基礎知識，那麼，它來了！

Spring Boot 2.x基礎教程：程式內快取的使用與Cache註解詳解

隨著時間的積累，應用的使用使用者不斷增加，資料規模也越來越大，往往資料庫查詢操作會成為影響使用者使用體驗的瓶頸，此時使用快取往往是解決這一問題非常好的手段之一。Spring 3開始提供了強大的基於註解的快取支

Spring Boot 2.x基礎教程：程序內快取的使用與Cache註解詳解

隨著時間的積累，應用的使用使用者不斷增加，資料規模也越來越大，往往資料庫查詢操作會成為影響使用者使用體驗的瓶頸，此時使用快取往往是解決這一問題非常好的手段之一。Spring 3開始提供了強大的基於註解的快取支

Spring系列25：Spring AOP 切點詳解

本文內容 Spring 10種切點表示式詳解 切點的組合使用 公共切點的定義 宣告切點@Poincut

spring MVC——@Autowired、@Resource、和@Service註解詳解（轉載）

註解之前spring怎麼裝配bean 傳統的Spring做法是使用.xml檔案來對bean進行注入或者是配置aop、事務。我們先看一個不使用註解的Spring示例，在這個示例的基礎上，改成註解版本的，這樣也能看出使用與不使用註解之間的

Go 基礎系列：17. 詳解 20 個佔位符

Go 基礎系列：17. 詳解 20 個佔位符 學到什麼 什麼是佔位符？ 哪些函式支援？ 如何使用佔位符？

朱曄和你聊Spring系列S1E11：小測Spring Cloud Kubernetes @ 阿里雲K8S

有關Spring Cloud Kubernetes（以下簡稱SCK）詳見https://github.com/spring-cloud/spring-cloud-kubernetes，在本文中我們主要測試三個功能：

Spring IoC @Autowired 註解詳解

前言 本系列全部基於 Spring 5.2.2.BUILD-SNAPSHOT 版本。因為 Spring 整個體系太過於龐大，所以只會進行關鍵部分的原始碼解析。

Spring IoC 公共註解詳解

前言 本系列全部基於 Spring 5.2.2.BUILD-SNAPSHOT 版本。因為 Spring 整個體系太過於龐大，所以只會進行關鍵部分的原始碼解析。

BAT面試必問題系列：深入詳解JVM 記憶體區域及記憶體溢位分析

前言 在JVM的管控下，Java程式設計師不再需要管理記憶體的分配與釋放，這和在C和C++的世界是完全不一樣的。所以，在JVM的幫助下，Java程式設計師很少會關注記憶體洩露和記憶體溢位的問題。但是，一旦JVM發生這些情況

第五節：MySQL配置詳解和配置優化參考

一.配置說明 1.MySQL5.7預設配置 　下面配置是 mysql5.7.28 以 DevelopmentComputer 模式進行安裝。

c++：行內函數詳解和普通函式的區別

文章目錄 前言Ⅰ.常規函式Ⅱ.行內函數1.語法2.注意 Ⅲ.選擇地使用內聯思考？

蘋果 iPhone 13/Pro 系列劉海變小詳解：寬度變窄，高度增加

9 月 15 日訊息蘋果公司今天釋出的新款 iPhone 13 機型，採用了更新的 TrueDepth 攝像頭，使得正面的劉海變得更小了，這也是新機跟上代機型正面最大的區別。瞭解到，根據蘋果在釋出會上的說法，iPhone 13 機型的劉海

JPA @Id 和 @GeneratedValue 註解詳解

JPA @Id 和 @GeneratedValue 註解詳解https://blog.csdn.net/coding1994/article/details/79597057 @Id： @Id 標註用於宣告一個實體類的屬性對映為資料庫的主鍵列。該屬性通常置於屬性宣告語句之前，可與宣告語句同

【Redis 系列】redis 學習十一，redis 的哨兵模式詳解和實戰

上一次我們說到的主從複製是這樣搭建的 主機可以讀，可以寫 從機只能讀，不能寫

x86伺服器新主流：Intel Xeon E5-2600系列架構與效能詳解

x86伺服器新主流：Intel Xeon E5-2600系列架構與效能詳解 發表於: 伺服器架構 | 作者: 部落格教主

Spring MVC請求地址對映詳解：HandlerMapping

1 HandlerMapping介紹 HandlerMapping是Spring MVC的核心元件之一，用來儲存request-handler之間的對映。

Spring系列四：Bean Scopes作用域

等閒識得東風面，萬紫千紅總是春。 概述 在Spring框架中，我們可以在六個內建的spring bean作用域中建立bean，還可以定義bean範圍。在這六個範圍中，只有在使用支援Web的applicationContext時，其中四個可用。sing

Spring系列七：Spring 自動裝配

相思相見知何日？此時此夜難為情。 概述 在Spring框架中，在配置檔案中宣告bean的依賴關係是一個很好的做法，因為Spring容器能夠自動裝配協作bean之間的關係。這稱為spring自動裝配。

Spring系列五：Bean 的生命週期

換我心，為你心，始知相憶深。 概述 在本章中，我們學習Spring bean的生命週期。掌握bean生命週期的各個階段，初始化和銷燬回撥方法。我們將學習使用XML配置和註釋配置來控制bean生命週期事件。