2. 程式人生 > 程式設計 >Spring Boot註解學習之@SpringBootApplication(一)

Spring Boot註解學習之@SpringBootApplication(一)

阿新 • • 發佈：2020-06-24

[TOC]

@SpringBootApplication

在使用 Springboot 框架進行開發的時候，通常我們會在 main 函式上新增 @SpringBootApplication 註解 ，來使應用程式能夠自動配置、元件掃描。

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}
複製程式碼

@SpringBootApplication

註解等價於預設屬性使用@Configuration，@EnableAutoConfiguration 和 @ComponentScan，

這裡可以檢視一下@SpringBootApplication註解的原始碼。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}
),@Filter
 
(
    type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    
}
複製程式碼

為什麼@SpringBootApplication註解裡沒有包含@Configuration,實際上是在@SpringBootConfiguration裡面 ：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
 

public @interface SpringBootConfiguration {
}
複製程式碼

@SpringBootConfiguration繼承自@Configuration，二者功能也一致，標註當前類是配置類， 並會將當前類內宣告的一個或多個以@Bean 註解標記的方法的例項納入到 spring 容器中，並且例項名就是方法名。

接下來再介紹一下上面提到的三種註解。

@Configuration

從 Spring3.0 開始，@Configuration 用於定義配置類，可替換 xml 配置檔案，被註解的類內部包含有一個或多個被@Bean 註解的方法，這些方法將會被 AnnotationConfigApplicationContext 或AnnotationConfigWebApplicationContext 類進行掃描，並用於構建 bean 定義，初始化 Spring 容器。

注意：@Configuration 註解修飾的配置類有如下要求：

  1. 不能是 final 型別；
  2. 不能是匿名類；
  3. 巢狀的 configuration 必須是靜態類。

@Configuration 載入 Spring 方法

1、@Configuration 配置 Spring 並啟動 Spring 容器

@Configuration標註在類上，相當於把該類作為 spring 的 xml 配置檔案中的 ，作用為：配置 spring 容器(應用上下文) 。

@Configuration
public class TestConfiguration {

    public TestConfiguration(){
        System.out.println("TestConfiguration容器啟動初始化。。。");
    }
}
複製程式碼

等價於

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">
    <bean id="testConfiguration" class="com.example.configuration.TestConfiguration"></bean>
</beans>
複製程式碼

主方法進行測試：

public class TestMain {

    public static void main(String[] args) {
        // @Configuration註解的spring容器載入方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
//        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestConfiguration.class);

        //通過載入 spring-context.xml檔案,此時將TestConfiguration上的註解取消
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-context.xml");
    }
}
複製程式碼

上述方法有兩種實現，可以分別進行測試，得到如下結果：

21:18:29.599 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration'
TestConfiguration容器啟動初始化。。。
複製程式碼
2、@Configuration 啟動容器+@Bean 註冊 bean

@Bean 標註在方法上（返回某個例項的方法），等價於 Spring 的 xml 配置檔案中：註冊 bean 物件。

bean 類：

public class TestBean {
    private String username;
    private String url;
    private String password;

    public void sayHello(){
        System.out.println("TestBean sayHello...");
    }

    public String toString(){
        return "username:"+this.username+",url:"+this.url+",password:"+this.password;
    }

    public void start(){
        System.out.println("TestBean 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("TestBean 銷燬。。。");
    }
}
複製程式碼

配置類：

@Configuration
public class TestConfiguration2 {
    public TestConfiguration2(){
        System.out.println("TestConfiguration容器啟動初始化。。。");
    }

    @Bean
    @Scope("prototype")
    public TestBean testBean(){
        return new TestBean();
    }
}
複製程式碼

主方法測試類：

public class TestMain2 {

    public static void main(String[] args) {
        // @Configuration註解的spring容器載入方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestConfiguration2.class);

        //獲取 Bean
        TestBean testBean = (TestBean) applicationContext.getBean("testBean");
        testBean.sayHello();
        System.out.println(testBean.hashCode());

        //再次獲取 bean,如果testBean方法上沒加@Scope(“prototype”)，則@Bean註解預設作用域為單例singleton作用域，所以返回的都是同一個物件
        TestBean testBean1 = (TestBean) applicationContext.getBean("testBean");
        System.out.println(testBean1.hashCode());
    }
}
複製程式碼

當 Bean 類不加 @Scope("prototype")註解時輸出結果為：

09:12:58.279 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration2'
TestConfiguration容器啟動初始化。。。
09:12:58.282 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean sayHello...
2143437117
2143437117
複製程式碼

加上 @Scope("prototype")註解時輸出結果為：

09:13:42.796 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration2'
TestConfiguration容器啟動初始化。。。
TestBean sayHello...
1989335500
1978869058
複製程式碼

結論：

  1. @Bean 註解在返回例項的方法上，如果未通過@Bean 指定 bean 名稱，則預設與標註的方法名相同；
  2. @Bean 註解預設作用域為單例 singleton 作用域，可通過 @Scope("prototype")設定為原型作用域；
  3. 既然@Bean 的作用是註冊 bean 物件，那麼完全可以使用@Component、@Controller、@Service、@Ripository 等註解註冊 bean，當然需要配置@ComponentScan 註解進行自動掃描。
3、@Configuration 啟動容器+@Component 註冊 Bean

bean 類：

package com.example.domain;

import org.springframework.stereotype.Component;

@Component
public class BeanWithComponent {

    public void sayHello(){

        System.out.println("BeanWithComponent sayHello...");
    }

    public void start(){
        System.out.println("BeanWithComponent 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("BeanWithComponent 銷燬。。。");
    }
}
複製程式碼

配置類：

@Configuration
@ComponentScan(basePackages = "com.example.domain")
public class ComfigureWithScan {

    public ComfigureWithScan(){
        System.out.println("spring容器啟動初始化。。。");
    }
}
複製程式碼

主方法測試類：

public class TestComponnet {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan.class);

        BeanWithComponent bean = (BeanWithComponent) context.getBean("beanWithComponent");
        bean.sayHello();
        System.out.println(bean);

        BeanWithComponent bean2 = (BeanWithComponent) context.getBean("beanWithComponent");
        System.out.println(bean2);
    }
}
複製程式碼

執行結果為：

10:03:56.791 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'comfigureWithScan'
spring容器啟動初始化。。。
10:03:56.796 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'beanWithComponent'
BeanWithComponent sayHello...
com.example.domain.BeanWithComponent@d706f19
com.example.domain.BeanWithComponent@d706f19
複製程式碼

從結果可以看到，使用@Component 註解+@ComponentScan 相當於使用了 @Bean 不加@Scope 註解，即得到的 bean 物件為同一個物件。

4、使用 AnnotationConfigApplicationContext 註冊 AppContext 類的兩種方法

a、配置類的註冊方式是將其傳遞給 AnnotationConfigApplicationContext 建構函式

public class TestComponnet {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan.class);

    }
}
複製程式碼

b、AnnotationConfigApplicationContext 的 register 方法傳入配置類來註冊配置類

public class TestComponnet {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(ComfigureWithScan.class);
        context.refresh();
        ApplicationContext ctx = context;

    }
}
複製程式碼

該方法其實就是對 AnnotationConfigApplicationContext建構函式的拆分使用，參考該部分的原始碼如下：

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    this.register(componentClasses);
    this.refresh();
}
複製程式碼

注意：網上關於該部分的程式碼都是這樣的：

public static void main(String[] args) {
  ApplicationContext ctx = new AnnotationConfigApplicationContext();
  ctx.register(AppContext.class)
}
複製程式碼

咱也不知道為啥他們都能測試通過，反正我本地沒法這樣編寫程式碼，咱只能換個思路來實現。這裡看一下 AnnotationConfigApplicationContext 類的結構層次圖：

關於該類的分析，後續咱再學習一下 。

5、配置 Web 應用程式(web.xml中配置 AnnotationConfigApplicationContext)

過去，您通常要利用 XmlWebApplicationContext 上下文來配置 Spring Web 應用程式，即在 Web 部署描述符檔案 web.xml 中指定外部 XML 上下文件案的路徑。XMLWebApplicationContext 是 Web 應用程式使用的預設上下文類。以下程式碼描述了 web.xml 中指向將由 ContextLoaderListener 監聽器類載入的外部 XML 上下文件案的元素。

<web-app>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <servlet>
    <servlet-name>sampleServlet</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    </servlet>
...
</web-app>
複製程式碼

現在，您要將 web.xml 中的上述程式碼更改為使用 AnnotationConfigApplicationContext 類。切記，XmlWebApplicationContext 是 Spring 為 Web 應用程式使用的預設上下文實現，因此您永遠不必在您的web.xml 檔案中顯式指定這個上下文類。現在，您將使用基於 Java 的配置，因此在配置 Web 應用程式時，需要在web.xml 檔案中指定 AnnotationConfigApplicationContext 類。上述程式碼將修改如下：

<web-app>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.
            support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            demo.AppContext
        </param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>
    <servlet>
    <servlet-name>sampleServlet</servlet-name>
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.
            support.AnnotationConfigWebApplicationContext
        </param-value>
    </init-param>
    </servlet>

...
</web-app>
複製程式碼

以上修改後的 web.xml 現在定義了 AnnotationConfigWebApplicationContext 上下文類，並將其作為上下文引數和 servlet 元素的一部分。上下文配置位置現在指向 AppContext 配置類。

組合多個配置類

在@configuration 中引入 spring 的 xml 配置檔案

配置類：

@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
public class TestConfiguration2 {
    public TestConfiguration2(){
        System.out.println("TestConfiguration2容器啟動初始化。。。");
    }

//    @Bean
//    @Scope("prototype")
//    public TestBean testBean(){
//        return new TestBean();
//    }
}
複製程式碼

bean類：

public class TestBean {

    public void sayHello(){
        
        System.out.println("TestBean sayHello...");
    }

    public void start(){
        System.out.println("TestBean 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("TestBean 銷燬。。。");
    }
}
複製程式碼

applicationContext-configuration.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
       xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:util="http://www.springframework.org/schema/util" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.0.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd" default-lazy-init="false">
    <bean id = "testBean" class="com.example.domain.TestBean"></bean>
</beans>
複製程式碼

測試類：

public class TestMain2 {

    public static void main(String[] args) {
        // @Configuration註解的spring容器載入方式，用AnnotationConfigApplicationContext替換ClassPathXmlApplicationContext
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(TestConfiguration2.class);

        //獲取 Bean
        TestBean testBean = (TestBean) applicationContext.getBean("testBean");
        testBean.sayHello();
        System.out.println(testBean);

        TestBean testBean1 = (TestBean) applicationContext.getBean("testBean");
        System.out.println(testBean1);
    }
}
複製程式碼

執行結果為：

16:35:28.837 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testConfiguration2'
TestConfiguration2容器啟動初始化。。。
16:35:28.852 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean sayHello...
com.example.domain.TestBean@78aab498
com.example.domain.TestBean@78aab498
複製程式碼

雖然這樣的組合也能達到同樣的效果，但是直接在配置類中使用@Bean 註解看起來更加簡單。

在@configuration中引入其它註解配置

修改配置類：

@Configuration
@ImportResource("classpath:applicationContext-configuration.xml")
@Import(TestConfiguration.class)
public class TestConfiguration2 {

}
複製程式碼

其他內容不變，執行結果如下：

16:40:40.239 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'com.example.configuration.TestConfiguration'
TestConfiguration容器啟動初始化。。。
16:40:40.239 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean sayHello...
com.example.domain.TestBean@12e61fe6
com.example.domain.TestBean@12e61fe6
複製程式碼
@configuration 巢狀（巢狀的 Configuration 必須是靜態類）

通過配置類巢狀的配置類，達到組合多個配置類的目的。但注意內部類必須是靜態類。

bean 類：

package com.example.domain;
@Component
public class BeanWithComponent {

    public void sayHello(){

        System.out.println("BeanWithComponent sayHello...");
    }

    public void start(){
        System.out.println("BeanWithComponent 初始化。。。");
    }

    public void cleanUp(){
        System.out.println("BeanWithComponent 銷燬。。。");
    }
}
複製程式碼
package com.example.domain;
public class DataSource {

    @Override
    public String toString() {
        return "I am DataSource";
    }
}
複製程式碼

配置類：

@Configuration
@ComponentScan(basePackages = "com.example.domain")
public class ComfigureWithScan2 {

    public ComfigureWithScan2(){
        System.out.println("spring容器啟動初始化。。。ComfigureWithScan2");
    }

    @Configuration
    static class DataConfigure{
        @Bean
        DataSource dataSource(){
            return new DataSource();
        }
    }
}
複製程式碼

測試類：

public class TestComponnet2 {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(ComfigureWithScan2.class);

        BeanWithComponent bean = (BeanWithComponent) context.getBean("beanWithComponent");
        bean.sayHello();

        DataSource dataSource = (DataSource) context.getBean("dataSource");
        System.out.println(dataSource);
    }
}
複製程式碼

執行結果為：

16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'comfigureWithScan2'
spring容器啟動初始化。。。ComfigureWithScan2
16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'beanWithComponent'
16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'com.example.configuration.ComfigureWithScan2$DataConfigure'
16:55:10.429 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'dataSource'
BeanWithComponent sayHello...
I am DataSource
複製程式碼

參考連結： www.cnblogs.com/duanxz/p/74…

@EnableAutoConfiguration

@EnableAutoConfiguration 藉助@Import 的幫助，將所有符合自動配置條件的 bean 定義載入到 Ioc 容器。

@EnableAutoConfiguration 也是一個複合Annotation，其原始碼如下:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}
複製程式碼

其中，最關鍵的要屬@Import({AutoConfigurationImportSelector.class})，藉助 AutoConfigurationImportSelector 這個類，@EnableAutoConfiguration 可以幫助 SpringBoot 應用將所有符合條件的@configuration 都載入到當前的 SpringBoot 建立並使用的 Ioc 容器。

AutoConfigurationImportSelector

在SpringBoot1.5以前，使用的是EnableAutoConfigurationImportSelector，它繼承自AutoConfigurationImportSelector，1.5以後，EnableAutoConfigurationImportSelector已經不再被建議使用，而是推薦使用AutoConfigurationImportSelector。

何時被執行

Springboot 啟動時會使用 ConfigurationClassParser 來解析被@Configuration 修飾的配置類，然後再處理這個類內部被其他註解修飾的情況，比如@Import 註解，@ComponentScan 註解，@Bean 註解等。

如果發現註解中存在@Import(ImportSelector)的情況下，就會建立一個相應的 importSelector 物件，並呼叫其 selectImports 方法，而 AutoConfigurationImportSelector就是一個 ImportSelector 的實現類。 更多關於ConfigurationClassParser 的分析，參閱文章:Spring類註冊筆記

所以 ConfigurationClassParser 會例項化一個 AutoConfigurationImportSelector 並呼叫它的 selectImports()方法。

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata,attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata,attributes);
        this.checkExcludedClasses(configurations,exclusions);
        configurations.removeAll(exclusions);
        configurations = this.filter(configurations,autoConfigurationMetadata);
        this.fireAutoConfigurationImportEvents(configurations,exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations,exclusions);
    }
}
複製程式碼

在 selectImports 方法中有呼叫 getAutoConfigurationEntry()這個方法，進去檢視該方法可以看到獲取配置類的程式碼，具體就是 getCandidateConfigurations()方法，點進去檢視其具體實現：

自動配置的關鍵類:SpringFactoriesLoader

SpringFactoriesLoader 的主要功能就是從指定的配置檔案 META/spring.factories 載入配置，spring.factories 是一個典型的 java properties 檔案，配置格式為 Key-Value 格式，只不過 Key 和 Value 都是 Java 型別的完整類名。

進入 loadFactoryNames()方法，就發現 loadFactoryNames()讀取了 ClassPath 下面的 META-INF/spring.factories 檔案。

在@EnableAutoConfiguration 的場景中，它更多是提供一種配置查詢的功能支援，即根據@EnableAutoConfiguration 的完整類名org.springframework.boot.autoconfigure.EnableAutoConfiguration 作為查詢的key,獲取對應的一組@Configuration 類。

由於文章篇幅過長，關於@Component 註解的講述放在下一章，歡迎來圍觀！

相關推薦

Spring Boot註解學習之@SpringBootApplication(一)

[TOC] @SpringBootApplication 在使用 Springboot 框架進行開發的時候，通常我們會在 main 函式上新增 @SpringBootApplication 註解 ，來使應用程式能夠自動配置、元件掃描。

Spring Boot註解學習之@SpringBootApplication(二)

@ComponentScan屬性basePackages 與 valuebasePackageClassesincludeFiltersexcludeFilters新增自定義過濾規則@Component@ComponentScanscontext:component-scanSpringBootApplication 註解中4個方法小結參考文獻

走進Spring Boot原始碼學習之路和淺談入門

作為筆者見解，Spring Boot 不算是一個全新的框架，Spring Boot 底層還是大量依賴於Spring Framework，而Spring Framework很早以前版本就已提供基於註解、Java Config而不僅是XML配置程式設計；Spring Boot採用約定

Spring Boot快速入門之（十一）：構建 RESTful Web 服務

【注】本文譯自： https://www.tutorialspoint.com/spring_boot/spring_boot_building_restful_web_services.htm

SPRING BOOT 註解之OBJECTPROVIDER原始碼追蹤

最近依舊在學習閱讀Spring Boot的原始碼，在此過程中涉及到很多在日常專案中比較少見的功能特性，對此深入研究一下，也挺有意思，這也是閱讀原始碼的魅力之一。這裡寫成文章，分享給大家。

iOS逆向學習之十一（加密、簽名）

學前須知 虛擬人物設計 為了方便我們學習iOS的簽名機制，本文設定了4個虛擬人物，分別是

Spring Boot Security Oauth2之客戶端模式及密碼模式實現

示例主要內容 1.多認證模式（密碼模式、客戶端模式） 2.token存到redis支援 3.資源保護

Spring boot註解@Async執行緒池例項詳解

這篇文章主要介紹了Spring boot註解@Async執行緒池例項詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

spring boot註解方式使用redis快取操作示例

本文例項講述了spring boot註解方式使用redis快取操作。分享給大家供大家參考，具體如下：

Spring-Boot配置檔案之application.properties常用配置

1、配置埠和專案名訪問 #指定springboot內嵌容器啟動的埠，預設使用tomcat容器時在8080埠

【Spring Boot】學習筆記轉載

SpringBoot核心技術-筆記-pdf版.zip SpringBoot課件.zip 一、Spring Boot 入門 1、Spring Boot 簡介

spring boot 解決 @RequestBody只能讀取一次的問題

　　 import com.alibaba.fastjson.JSON;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.yicheplatform.shenzhen.constant.RedisConstants;import com.yicheplatform.shenzhen.poj

spring-boot-learning 快取之redis

什麼是BSD協議： BSD是\"Berkeley Software Distribution\"的縮寫，意思是\"伯克利軟體發行版\"。

Spring Boot入門學習必知道企業常用的Starter

SpringBoot企業常用的 starter SpringBoot簡介 SpringBoot執行 SpringBoot目錄結構 整合JdbcTemplate

MySQL學習之路(一)---資料庫儲存引擎

儲存引擎是什麼？　　MySQL中的資料用各種不同的技術儲存在檔案(或者記憶體 )中。這些技術中的每一種技術都使用不同的儲存機制、索引技巧、鎖定水平並且最終提供廣泛的不同的功能和能力。通過選擇不同的技

Python學習之（一）在eclipse中搭建python的開發環境

糾結了好久，該不該開始學Python。最後還是追隨心的選擇，開始了Python的學習之旅。

spring boot 熱部署之idea

首先你要有一個能正常執行的springboot專案，然後才能進行熱部署的功能搭建 pom中新增依賴

spring boot的學習

1.Spring Boot 簡介 　　Spring誕生時是Java企業版（Java Enterprise Edition，JEE，也稱J2EE）的輕量級代替品。無需開發重量級的Enterprise JavaBean（EJB），Spring為企業級Java開發提供了一種相對簡單的方法，通過

Spring-boot註解

一、註解(annotations)列表@SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration註解。其中@ComponentScan讓springBoot掃描到Configuration類並把它加入到程式上下文。

Spring Boot入門學習

一、Spring Boot入門01 1、Spring Boot簡介 簡化Spring應用開發的一個框架； 對整個Spring技術棧的一個大整合；