SpringBoot 基本介紹--依賴管理和自動配置--

Spring Boot 是什麼?

1 第一句話: Spring Boot 可以輕松建立獨立的、生産級的基于Spring 的應用程式

2 第二句話: Spring Boot 直接嵌入Tomcat、Jetty 或Undertow ，可以"直接運作" Spring-Boot 應用程式

SpringBoot 快速入門

需求/圖解說明

● 建構一個SpringBoot 項目，浏覽器發送/hello 請求[http://localhost:8080/hello]，響應 Hello，SpringBoot

完成步驟

1. 确認開發環境是jdk 8 或以上，maven 在3.5+

2. 建立maven 項目

我都部落格已經介紹過了這裡就不再示範 連結

3. pom.xml 引入SpringBoot 父工程和web 項目場景啟動器

XML複制代碼<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wyxdu</groupId>
    <artifactId>quickstart</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 導入springboot 父工程，規定的寫法-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.3</version>
    </parent>
    <!--導入web項目場景啟動器: 會自動導入和web開發相關的所有依賴[庫/jar]
    後面還會說spring-boot-starter-web 到底引入哪些相關依賴
    -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

    </dependencies>
</project>
           

建立MainApp.java SpringBoot 應用主程式

java複制代碼@SpringBootApplication
public class MainApp {
public static void main(String[] args) {
        //啟動SpringBoot 應用程式
        SpringApplication.run(MainApp.class, args);
    }
}
           

建立HelloController.java 控制器

java複制代碼@Controller
public class HelloController {

    //傳回hello,springboot
    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "hello~, SpringBoot";
    }
}
           

運作MainApp.java 完成測試

java複制代碼public class MainApp {

    public static void main(String[] args) {

        //啟動springboot應用程式/項目
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);
}
           

浏覽器http://localhost:8080/hello

快速入門小結

1. SpringBoot 比較傳統的SSM 開發， 簡化整合步驟, 提高開發效率

2. 簡化了Maven 項目的pom.xml 依賴導入, 可以說是一鍵導入, 如圖.

3. 引入一個spring-boot-starter-web, 到底發生了什麼?

4. 内置Tomcat , 簡化伺服器的配置

5.等等

Spring SpringMVC SpringBoot 的關系

梳理關系

1. 他們的關系大概是: Spring Boot > Spring > Spring MVC

2. Spring MVC 隻是Spring 處理WEB 層請求的一個子產品/元件, Spring MVC 的基石是Servlet

3. Spring 的核心是IOC 和AOP, IOC 提供了依賴注入的容器, AOP 解決了面向切面程式設計

4. Spring Boot 是為了簡化開發, 推出的封神架構(約定優于配置[COC]，簡化了Spring 項目

的配置流程), SpringBoot 包含很多元件/架構，Spring 就是最核心的内容之一，也包SpringMVC

5. Spring 家族，有衆多衍生架構群組件例如boot、security、jpa 等, 他們的基礎都是Spring

如何了解-約定優于配置

1、約定優于配置(Convention over Configuration/COC)，又稱按約定程式設計，是一種軟體設計規範, 本質上是對系統、類庫或架構中一些東西假定一個大衆化合理的預設值(預設值)

2、例如在模型中存在一個名為User 的類，那麼對應到資料庫會存在一個名為user 的表，隻有在偏離這個約定時才需要做相關的配置(例如你想将表名命名為t_user 等非user 時才需要寫關于這個名字的配置)

3、簡單來說就是假如你所期待的配置與約定的配置一緻，那麼就可以不做任何配置，約定不符合期待時, 才需要對約定進行替換配置

4、約定優于配置理念【解讀：為什麼要搞一個約定優于配置】

約定其實就是一種規範，遵循了規範，那麼就存在通用性，存在通用性，那麼事情就會變得相對簡單，程式員之間的溝通成本會降低，工作效率會提升，合作也會變得更加簡單

- 生活中,這樣的情況，大量存在..

依賴管理和自動配置

依賴管理

什麼是依賴管理

1. spring-boot-starter-parent 還有父項目, 聲明了開發中常用的依賴的版本号

2. 并且進行自動版本仲裁, 即如果程式員沒有指定某個依賴jar 的版本，則以父項目指定的版本為準

修改自動仲裁/預設版本号

1. 需求說明: 将SpringBoot mysql 驅動修改成5.1.49

2. 檢視spring-boot-dependencies.pom 裡面規定目前依賴的版本對應的key , 這裡是

mysql.version

3. 修改springboot2\01_quickstart\pom.xml 重寫配置, 當更新Maven 時，就依賴到新的

mysql 驅動.

XML複制代碼<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wyxdu</groupId>
    <artifactId>quickstart</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--導入springboot父工程-規定寫法-->
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.5.3</version>
    </parent>

    <!--這裡我們可以指定mysql.version-->
    <properties>
        <mysql.version>5.1.49</mysql.version>

    </properties>

    <!--導入web項目場景啟動器: 會自動導入和web開發相關的所有依賴[庫/jar]
    後面還會說spring-boot-starter-web 到底引入哪些相關依賴
    -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <!--我們自己指定mysql/驅動版本- 修改版本仲裁

        1. 方式1:顯示的導入mysql依賴, 并明确的指定<version>
        2. 方式2.在自己的pom.xml檔案中, 在<properties> 中指定mysql的key
        形如:
            <properties>
            <mysql.version>5.1.49</mysql.version>
            </properties>
        3. 為什麼可以達到修改版本仲裁: 根據依賴就近優先原則.
        -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<version>5.1.49</version>-->
        </dependency>
    </dependencies>
</project>
           

starter 場景啟動器

starter 場景啟動器基本介紹

1. 開發中我們引入了相關場景的starter，這個場景中所有的相關依賴都引入進來了，比如我們做web 開發引入了，該starter 将導入與web 開發相關的所有包

2. 依賴樹: 可以看到spring-boot-starter-web ，幫我們引入了spring-webmvc，spring-web開發子產品，還引入了spring-boot-starter-tomcat 場景，spring-boot-starter-json 場景，這些場景下面又引入了一大堆相關的包，這些依賴項可以快速啟動和運作一個項目，提高開發效率.

3. 所有場景啟動器最基本的依賴就是spring-boot-starter , 前面的依賴樹分析可以看到,這個依賴也就是SpringBoot 自動配置的核心依賴

官方提供的starter

位址: docs.spring.io/spring-boot… systems.starters

介紹

1. 在開發中我們經常會用到spring-boot-starter-xxx ，比如spring-boot-starter-web，該場景是用作web 開發，也就是說xxx 是某種開發場景。

2. 我們隻要引入starter，這個場景的所有正常需要的依賴我們都自動引入。

3. SpringBoot2 支援的所有場景如下:

docs.spring.io/spring-boot…

tems.starters

第三方starter

1. SpringBoot 也支援第三方starter

2. 第三方starter 不要從spring-boot 開始，因為這是官方spring-boot 保留的命名方式的。第三方啟動程式通常以項目名稱開頭。例如，名為thirdpartyproject 的第三方啟動程式項目通常被命名為thirdpartyproject-spring-boot-starter。

3. 也就是說：xxx-spring-boot-starter 是第三方為我們提供的簡化開發的場景啟動器

自動配置

自動配置基本介紹

1. 小夥伴還記得否，前面學習SSM 整合時，需要配置Tomcat 、配置SpringMVC、配置如何掃描包、配置字元過濾器、配置視圖解析器、檔案上傳等[如圖]，非常麻煩。而在SpringBoot 中，存在自動配置機制，提高開發效率

2. 簡單回顧以前SSM 整合的配置

SpringBoot 自動配置了哪些?

1. 自動配置Tomcat

2. 自動配置SpringMVC

3. 自動配置Web 常用功能: 比如字元過濾器, 提示: 通過擷取ioc 容器，檢視容器建立的元件來驗證,

修改MainApp.java

java複制代碼@SpringBootApplication
public class MainApp {
    public static void main(String[] args) {
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);
        //檢視容器裡面的元件
        String[] beanDefinitionNames = ioc.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
    }
}
           

-------更加直接檢視的方式-------

4. 自動配置: 預設掃描包結構!!! ， 官方文檔:

docs.spring.io/spring-boot…

如何修改預設配置

如何修改預設掃描包結構

1. 需求：要求能掃描com.hspedu 包下的HiController.java 應該如何處理?

2. 建立: springboot2\01_quickstart\src\main\java\com\wyxedu\HiController.java, 并測試，這時是通路不到的.

java複制代碼@Controller
public class HiController {
    @RequestMapping("/hi")
    @ResponseBody
    public String hi(){
        return "hi~, spring boot";
    }
}
           

3. 修改MainApp.java, 增加掃描的包, 并完成測試.

注意

@SpringBootApplication:表示這是一個springboot應用/項目

@SpringBootApplication(scanBasePackages="com.wyxdu")

解讀:scanBasePackages="com.wyxdu"指定springboot要掃描的包和子包

如果有多個包，可以這樣scanBasePackages={"com.wyxdu","xxx.yyy.zzz"}

java複制代碼@SpringBootApplication(scanBasePackages = "com.wyxdu")
public class MainApp {}
           

resources\application.properties 配置大全

SpringBoot 項目最重要也是最核心的配置檔案就是application.properties，

所有的架構配置都可以在這個配置檔案中說明- 位址: blog.csdn.net/pbrlovejava…

resources\application.properties 修改配置

● 各種配置都有預設, 可以在resources\application.properties 修改,

application.properties 檔案我們可以手動建立

#預設server.port=8080

server.port=10000

#比如: 預設spring.servlet.multipart.max-file-size=1MB

#該屬性可以指定springboot 上傳檔案大小的限制

#預設配置最終都是映射到某個類上,比如這裡配置會映射到MultipartProperties

#把光标放在該屬性，ctrl+b 就可以定位該配置映射到的類

spring.servlet.multipart.max-file-size=10MB

resources\application.properties 常用配置

因為有點多是以在甯外一篇部落格 連結

resources\application.properties 自定義配置

● 還可以在properties 檔案中自定義配置，通過@Value("${}")擷取對應屬性值

application.properties 檔案

my.website=www.baidu.com

-

//某個Bean

@Value("${my.website}")

private String bdUrl;

SpringBoot 在哪配置讀取application.properites

1、打開ConfigFileApplicationListener.java , 看一下源碼

2、測試, 如果我們把application.properties 放在resources\config 目錄下, 你會發現依然

是管用的.

3、測試完畢, 記得把恢複到原來的位置.

基本說明

1. 自動配置遵守按需加載原則：也就是說，引入了哪個場景starter 就會加載該場景關聯的jar 包，沒有引入的starter 則不會加載其關聯jar

2. SpringBoot 所有的自動配置功能都在spring-boot-autoconfigure 包裡面

3. 在SpringBoot 的自動配置包, 一般是XxxAutoConfiguration.java, 對應XxxxProperties.java, 如圖

執行個體示範

1. 以MultipartProperties , MultipartAutoConfiguration 和application.properties 來說明

容器功能

Spring 注入元件的注解

@Component、@Controller、@Service、@Repository

說明: 這些在Spring 中的傳統注解仍然有效，通過這些注解可以給容器注入元件

代碼示範

建立A.java

java複制代碼@Repository
public class A {
}
           

完成測試MainApp.java

java複制代碼
        //示範Spring中傳統的注解依然可以使用 @Controller @Service @Repository 等.

        A aBean = ioc.getBean(A.class);
        System.out.println("aBean--" + aBean);
           

@Configuration

應用執行個體

● @Configuration 應用執行個體需求

: 示範在SpringBoot, 如何通過@Configuration 建立配置類來注入元件

● 回顧傳統方式如何通過配置檔案注入元件

建立Monster.java

java複制代碼public class Monster {

    private Integer id;
    private String name;
    private Integer age;
    private String skill;

    public Monster(Integer id, String name, Integer age, String skill) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.skill = skill;
    }

    public Monster() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", skill='" + skill + '\'' +
                '}';
    }
}
           

建立resources\beans.xml

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置了Monster bean-->
    <bean id="monster03" class="com.wyxdu.springboot.bean.Monster">
        <property name="name" value="牛魔王~"></property>
        <property name="age" value="5000"></property>
        <property name="skill" value="芭蕉扇~"></property>
        <property name="id" value="1000"></property>
    </bean>
</beans>
           

完成測試MainApp.java

java複制代碼        //--示範在springboot 項目，依然可以使用spring的配置bean/注入bean/擷取bean方式 start====

        ApplicationContext ac =
               new ClassPathXmlApplicationContext("beans.xml");

        Monster monster03 = ac.getBean("monster03", Monster.class);
        System.out.println("monster03--" + monster03);
           

使用SpringBoot 的@Configuration 添加/注入元件

建立config\Cconfig\BeanConfig.java

解讀

@Configuration 辨別這是一個配置類, 等價于配置檔案

程式員可以通過@Bean 注解注入bean對象到容器

當一個類被 @Configuration 辨別，該類-Bean 也會注入容器

java複制代碼@Configuration

public class BeanConfig {

    /**
     * 解讀
     * 1. @Bean : 給容器添加元件, 就是Monster bean
     * 2. monster01() : 預設 你的方法名monster01 作為Bean的名字/id
     * 3. Monster : 注入類型, 注入bean的類型是Monster
     * 4. new Monster(200,"牛魔王",500,"瘋魔拳") 注入到容器中具體的Bean資訊
     * 5. @Bean(name = "monster_nmw") : 在配置、注入Bean指定名字/id monster_nmw
     * 6. 預設是單例注入
     * 7. 通過 @Scope("prototype")  可以每次傳回新的對象，就多例.
     */
    //@Bean(name = "monster_nmw")
    @Bean
    //@Scope("prototype")
    public Monster monster01() {
        return new Monster(200, "牛魔王", 500, "瘋魔拳");
    }
           

修改MainApp.java , 從配置檔案/容器擷取bean , 并完成測試

java複制代碼        // ===示範 @Configuration start ====

        Monster monster01 = ioc.getBean("monster01", Monster.class);
        Monster monster02 = ioc.getBean("monster01", Monster.class);

        System.out.println("monster01--" + monster01 + " " + monster01.hashCode());
        System.out.println("monster02--" + monster02 + " " + monster02.hashCode());
           

也可以通過Debug 來檢視ioc 容器是否存在monster01 Bean 執行個體

beanDefinitionMap, 隻是存放了bean 定義資訊, 真正存放Bean 執行個體的在singleonObjectis 的Map 中, 對于非單例，是每次動态反射生成的執行個體

@Configuration 注意事項和細節

配置類本身也是元件， 是以也可以擷取, 測試修改MainApp.java

java複制代碼        //===示範 配置類-bean也會注入容器 start ====

        BeanConfig bean = ioc.getBean(BeanConfig.class);
        System.out.println("bean--" + bean);

        //===示範 配置類-bean也會注入容器 end ====
           

SpringBoot2 新增特性： proxyBeanMethods 指定Full 模式和Lite 模式

修改BeanConfig.java

proxyBeanMethods：代理bean的方法

(1) Full(proxyBeanMethods = true)、【保證每個@Bean方法被調用多少次傳回的元件都是單執行個體的, 是代理方式】

(2) Lite(proxyBeanMethods = false)【每個@Bean方法被調用多少次傳回的元件都是新建立的, 是非代理方式】

(3) 特别說明: proxyBeanMethods 是在 調用@Bean方法 才生效，是以，需要先擷取BeanConfig 元件，再調用方法而不是直接通過 SpringBoot 主程式得到的容器來擷取bean, 注意觀察直接通過ioc.getBean() 擷取Bean, proxyBeanMethods 值并沒有生效

(4) 如何選擇: 元件依賴必須使用Full模式預設。如果不需要元件依賴使用 Lite模

(5) Lite模 也稱為輕量級模式，因為不檢測依賴關系，運作速度快

java複制代碼@Configuration(proxyBeanMethods = false)
public class BeanConfig {.....}
           

修改MainApp.java完成測試

java複制代碼@SpringBootApplication(scanBasePackages = "com.wyxdu")
public class MainApp {

    public static void main(String[] args) {

        //啟動springboot應用程式/項目
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);
                //===示範@Configuration(proxyBeanMethods = xxx) start

        //1. 先得到BeanConfig元件
        BeanConfig beanConfig = ioc.getBean(BeanConfig.class);
        Monster monster_01 = beanConfig.monster01();
        Monster monster_02 = beanConfig.monster01();

        System.out.println("monster_01-" + monster_01 + " " + monster_01.hashCode());
        System.out.println("monster_02-" + monster_02 + " " + monster_02.hashCode());


        //特别說明: proxyBeanMethods 是在 調用@Bean方法 才生效，是以，需要先擷取BeanConfig 元件，再調用方法
        //1. 而不是直接通過 SpringBoot 主程式得到的容器來擷取bean, 注意觀察直接通過ioc.getBean() 擷取Bean, proxyBeanMethods 值并沒有生效

        Monster monster01 = ioc.getBean("monster01", Monster.class);
        Monster monster02 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster01-" + monster01 + " " + monster01.hashCode());
        System.out.println("monster02-" + monster02 + " " + monster02.hashCode());

        //===示範@Configuration(proxyBeanMethods = xxx) end
}
           

配置類可以有多個, 就和Spring 可以有多個ioc 配置檔案是一個道理

建立BeanConfig2.java

java複制代碼@Configuration
public class BeanConfig2 {

    @Bean
    public Monster monster02() {
        return new Monster(800,"螞蟻精",80,"吃小昆蟲");
    }
}
           

修改MainApp.java完成測試

java複制代碼@SpringBootApplication(scanBasePackages = "com.wyxdu")
public class MainApp {

    public static void main(String[] args) {

        //啟動springboot應用程式/項目
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);
        //===測試可以有多個配置類 start

        Monster monster02 = ioc.getBean("monster02", Monster.class);
        Monster monster01 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster02--" + monster02);
        System.out.println("monster01--" + monster01);

        //===測試可以有多個配置類 end
}
           

@Import

示範在SpringBoot, 如何通過@Import 來注入元件

建立Cat.java

java複制代碼public class Cat {
}
           

建立Dog.java

java複制代碼public class Dog {
}
           

修改BeanConfig.java 通過@Import 注入元件

解讀

1. @Import 代碼 可以看到，可以指定 class的數組, 可以注入指定類型的Bean

public @interface Import {

Class<?>[] value()}

2. 通過@Import 方式注入了元件, 預設元件名字/id就是對應類型的全類名

java複制代碼@Import({Dog.class, Cat.class})
@Configuration
public class BeanConfig {}
           

修改MainApp.java完成測試

java複制代碼        //===測試@Import 使用 start

        Dog dogBean = ioc.getBean(Dog.class);
        Cat catBean = ioc.getBean(Cat.class);
        System.out.println("dogBean--" + dogBean);
        System.out.println("catBean--" + catBean);

        //===測試@Import 使用 end
           

@Conditional

@Conditional 介紹

1. 條件裝配：滿足Conditional 指定的條件，則進行元件注入

2. @Conditional 是一個根注解，下面有很多擴充注解

應用執行個體

1. 要求: 示範在SpringBoot, 如何通過@ConditionalOnBean 來注入元件

2. 隻有在容器中有name = monster_nmw 元件時，才注入dog01, 代碼如圖

修改beanConfig增加Dog

java複制代碼@Bean
public Dog dog01() {
return new Dog();
}
           

先測試下，目前是否能注入dog01

修改MainApp.java完成測試

java複制代碼@SpringBootApplication(scanBasePackages = "com.wyxdu")
public class MainApp {

    public static void main(String[] args) {

        //啟動springboot應用程式/項目
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);
      Dog dog01 = ioc.getBean("dog01", Dog.class);
        System.out.println("dog01--" + dog01);
}
           

增加@ConditionalOnBean注解

解讀

1. @ConditionalOnBean(name = "monster_nmw") 表示

2. 當容器中有一個Bean , 名字是monster_nmw (類型不做限制), 就注入dog01這個Dog bean

3. 如果沒有 名字是monster_nmw Bean 就不注入dog01這個Dog bean

4. 還有很多其它的條件限制注解，可以自己測試

5. @ConditionalOnMissingBean(name = "monster_nmw") 表示在容器中, 沒有 名字/id 為 monster_nmw 才注入dog01這個Bean

6. @ConditionalOnBean(name = "monster_nmw") 也可以放在配置類 表示對該配置類的所有要注入的元件，都進行條件限制.

java複制代碼    @Bean
    /**
     * 解讀
     * 1. @ConditionalOnBean(name = "monster_nmw") 表示
     * 2. 當容器中有一個Bean , 名字是monster_nmw (類型不做限制), 就注入dog01這個Dog bean
     * 3. 如果沒有 名字是monster_nmw Bean 就不注入dog01這個Dog bean
     * 4. 還有很多其它的條件限制注解，小夥伴可以自己測試
     *
     * 5. @ConditionalOnMissingBean(name = "monster_nmw") 表示在容器中,
     * 沒有 名字/id 為 monster_nmw 才注入dog01這個Bean
     *
     * 6. @ConditionalOnBean(name = "monster_nmw") 也可以放在配置類
     * 表示對該配置類的所有要注入的元件，都進行條件限制.
     *
     */
    @ConditionalOnBean(name = "monster_nmw")
    //@ConditionalOnMissingBean(name = "monster_nmw")
    public Dog dog01() {
        return new Dog();
    }
           

修改MainApp.java完成測試

java複制代碼@SpringBootApplication(scanBasePackages = "com.wyxdu")
public class MainApp {

    public static void main(String[] args) {

        //啟動springboot應用程式/項目
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);

        //===示範 @ConditionalOnBean 使用 start ====

        Dog dog01 = ioc.getBean("dog01", Dog.class);
        System.out.println("dog01--" + dog01);

        //===示範 @ConditionalOnBean 使用 end ====
}
           

@ImportResource

作用：原生配置檔案引入 , 也就是可以直接導入Spring 傳統的beans.xml ，可以認

為是SpringBoot 對Spring 容器檔案的相容 .

@ImportResource 應用執行個體

需求 : 将beans.xml 導入到BeanConfig.java 配置類， 并測試是否可以獲得beans.xml注入 / 配置的元件

建立新的BeanConfig3.java來測試

使用@ImportResource 導入beans.xml

java複制代碼@Configuration
//導入beans.xml - 就可以擷取到beans.xml 中配置bean
@ImportResource(locations = {"classpath:beans.xml","classpath:beans02.xml"})
public class BeanConfig3 {
}
           

修改MainApp.java完成測試

java複制代碼@SpringBootApplication(scanBasePackages = "com.wyxdu")
public class MainApp {

    public static void main(String[] args) {

        //啟動springboot應用程式/項目
        ConfigurableApplicationContext ioc =
                SpringApplication.run(MainApp.class, args);

        //示範@ImportResource 使用 start===

        Monster monster04 = ioc.getBean("monster04", Monster.class);
        System.out.println("monster04-" + monster04);
        System.out.println("monster04 bean 是否存在-" + ioc.containsBean("monster04"));
        
        //示範@ImportResource 使用 end===
}
           

配置綁定

一句話：使用Java 讀取到SpringBoot 核心配置檔案application.properties 的内容，

并且把它封裝到JavaBean 中

應用執行個體

1. 需求: 将application.properties 指定的k-v 和JavaBean 綁定

javascript複制代碼#設定Furn的屬性k-v
#前面的 furn01 是用于指定/差別不同的綁定對象, 這樣可以再綁定Furn bean屬性值時
#通過furn01 字首進行區分
#furn01.id 中的id 就是你要綁定的 Furn bean的屬性名
furn01.id=100
furn01.name=TV~~\u7535\u89c6\u673a
furn01.price=1000.9
           

建立Furn.java

java複制代碼@Component
@ConfigurationProperties(prefix = "furn01")
public class Furn {
    private Integer id;
    private String name;
    private Double price;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}
           

修改HelloController.java

java複制代碼    @Autowired
    Furn furn;
    @RequestMapping("/furn")
    @ResponseBody
    public Furn furn(){
        return furn;
    }
           

啟動SpringBoot 主程式，測試

配置綁定還有第2 種方式

也給示範下, 完成測試，效果一樣， 注意: 登出

@Component 需要在BeanConfig.java( 說明: 也可以是其它配置類) 配置

@EnableConfigurationProperties(Furn.class), 否則會提示錯誤

解讀

1、開啟Furn配置綁定功能

2、把Furn元件自動注冊到容器中

java複制代碼@EnableConfigurationProperties({Furn.class})
public class BeanConfig {}
           

完成測試

注意事項和細節

1. 如果application.properties 有中文, 需要轉成unicode 編碼寫入, 否則出現亂碼

#設定屬性k-v

furn01.id=100

furn01.name=\u4f60\u597d

furn01.price=45678.9

2. 使用@ConfigurationProperties(prefix = "furn01") 會提示如下資訊, 但是不會影響使用

3. 解決@ConfigurationProperties(prefix = "furn01") 提示資訊, 在pom.xml 增加依賴, 即可

XML複制代碼<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
           

4.注解配置一樣的

後面我們在來分析一下boot的底層實作機制。

作者：塵覺

原文連結：https://juejin.cn/post/7236593783831216186