SpringBoot入門學習

Spring再簡化：SpringBoot-jar：內嵌tomcat；微服務架構！

服務越來越多就出來了Springcloud

回顧什么是Spring

Spring是一個開源框架，2003 年興起的一個輕量級的Java 開發框架，作者：Rod Johnson 。

Spring是為了解決企業級應用開發的復雜性而創建的，簡化開發。

Spring是如何簡化Java開發的

為了降低Java開發的復雜性，Spring采用了以下4種關鍵策略：

1、基于POJO的輕量級和最小侵入性編程，所有東西都是bean；

2、通過IOC，依賴注入（DI）和面向接口實現松耦合；

3、基于切面（AOP）和慣例進行聲明式編程；

4、通過切面和模版減少樣式代碼，RedisTemplate，xxxTemplate；

什么是SpringBoot

學過javaweb的同學就知道，開發一個web應用，從最初開始接觸Servlet結合Tomcat, 跑出一個Hello Wolrld程序，是要經歷特別多的步驟；后來就用了框架Struts，再后來是SpringMVC，到了現在的SpringBoot，過一兩年又會有其他web框架出現；你們有經歷過框架不斷的演進，然后自己開發項目所有的技術也在不斷的變化、改造嗎？建議都可以去經歷一遍；

言歸正傳，什么是SpringBoot呢，就是一個javaweb的開發框架，和SpringMVC類似，對比其他javaweb框架的好處，官方說是簡化開發，約定大于配置， you can “just run”，能迅速的開發web應用，幾行代碼開發一個http接口。

所有的技術框架的發展似乎都遵循了一條主線規律：從一個復雜應用場景 衍生 一種規范框架，人們只需要進行各種配置而不需要自己去實現它，這時候強大的配置功能成了優點；發展到一定程度之后，人們根據實際生產應用情況，選取其中實用功能和設計精華，重構出一些輕量級的框架；之后為了提高開發效率，嫌棄原先的各類配置過于麻煩，于是開始提倡“約定大于配置”，進而衍生出一些一站式的解決方案。

是的這就是Java企業級應用->J2EE->spring->springboot的過程。

隨著 Spring 不斷的發展，涉及的領域越來越多，項目整合開發需要配合各種各樣的文件，慢慢變得不那么易用簡單，違背了最初的理念，甚至人稱配置地獄。Spring Boot 正是在這樣的一個背景下被抽象出來的開發框架，目的為了讓大家更容易的使用 Spring 、更容易的集成各種常用的中間件、開源軟件；

Spring Boot 基于 Spring 開發，Spirng Boot 本身并不提供 Spring 框架的核心特性以及擴展功能，只是用于快速、敏捷地開發新一代基于 Spring 框架的應用程序。也就是說，它并不是用來替代 Spring 的解決方案，而是和 Spring 框架緊密結合用于提升 Spring 開發者體驗的工具。Spring Boot 以約定大于配置的核心思想，默認幫我們進行了很多設置，多數 Spring Boot 應用只需要很少的 Spring 配置。同時它集成了大量常用的第三方庫配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 應用中這些第三方庫幾乎可以零配置的開箱即用。

簡單來說就是SpringBoot其實不是什么新的框架，它默認配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架 。

Spring Boot 出生名門，從一開始就站在一個比較高的起點，又經過這幾年的發展，生態足夠完善，Spring Boot 已經當之無愧成為 Java 領域最熱門的技術。

Spring Boot的主要優點：

• 為所有Spring開發者更快的入門
• 開箱即用，提供各種默認配置來簡化項目配置
• 內嵌式容器簡化Web項目
• 沒有冗余代碼生成和XML配置的要求

MVVM微服務架構理解

高內聚，低耦合

現在跑程序，把一切都放到war包中運行很方便部署，如果負載能力不行，我們將整個應用進行水平復制，進行擴展，然后負載均衡

現在把里邊的功能分開成模塊，想要怎么組裝就怎么組裝，把所有獨立出來的元素動態組合，需要的功能元素才去拿來組合。所以微服務架構是對功能元素進行復制，而沒有對整個應用進行復制

每個功能元素的服務都是一個可替換的，可獨立升級的軟件代碼

SpringBoot之旅先知

1.Hello，World之項目結構

Spring官方提供了非常方便的工具讓我們快速構建應用

Spring Initializr：https://start.spring.io/

**項目創建方式一：**使用Spring Initializr 的 Web頁面創建項目

1、打開 https://start.spring.io/

2、填寫項目信息

3、點擊”Generate Project“按鈕生成項目；下載此項目

4、解壓項目包，并用IDEA以Maven項目導入，一路下一步即可，直到項目導入完畢。

5、如果是第一次使用，可能速度會比較慢，包比較多、需要耐心等待一切就緒。

**項目創建方式二：**使用 IDEA 直接創建項目

1、創建一個新項目

2、選擇spring initalizr ， 可以看到默認就是去官網的快速構建工具那里實現

3、填寫項目信息

4、選擇初始化的組件（初學勾選 Web 即可）

5、填寫項目路徑

6、等待項目構建成功

項目結構分析：

通過上面步驟完成了基礎項目的創建。就會自動生成以下文件。

1、程序的主啟動類

2、一個 application.properties 配置文件

3、一個 測試類

4、一個 pom.xml

pom.xml分析

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-FwzKXMUz-1614595470344)(C:\Users\18335\AppData\Roaming\Typora\typora-user-images\image-20201116145758215.png)]

<!-- 父依賴 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.5.RELEASE</version> <relativePath/> </parent> <dependencies> <!-- web場景啟動器 --> <dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- springboot單元測試 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <!-- 剔除依賴 --> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency></dependencies> <build> <plugins> <!-- 打包插件 --> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>

在application.properties中更改端口號 server.port=8081

在同級目錄下創建banner.txt改banner

2.運行初探

SpringBoot的所有自動裝配，都是在啟動的時候掃描spring.factories文件，這個里面寫了所有自動配置的類，但是不一定生效，有一個判斷條件ConditionalOnXXX（）必須滿足里邊的條件才能配置，所以我們一般Start導入對應的啟動器，自動裝配就生效了，然后配置成功

1.pom.xml

父依賴是真正的所有依賴都已經寫好了的

其中它主要是依賴一個父項目，主要是管理項目的資源過濾及插件！

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.5.RELEASE</version> <relativePath/> <!-- lookup parent from repository --></parent>

點進去，發現還有一個父依賴

<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.2.5.RELEASE</version> <relativePath>../../spring-boot-dependencies</relativePath></parent>

這里才是真正管理SpringBoot應用里面所有依賴版本的地方，SpringBoot的版本控制中心；

以后我們導入依賴默認是不需要寫版本；但是如果導入的包沒有在依賴中管理著就需要手動配置版本了；

啟動器 spring-boot-starter

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId></dependency>

springboot-boot-starter-xxx：就是spring-boot的場景啟動器

spring-boot-starter-web：幫我們導入了web模塊正常運行所依賴的組件；

SpringBoot將所有的功能場景都抽取出來，做成一個個的starter （啟動器），只需要在項目中引入這些starter即可，所有相關的依賴都會導入進來 ， 我們要用什么功能就導入什么樣的場景啟動器即可 ；我們未來也可以自己自定義 starter；

2. 主程序

//@SpringBootApplication 來標注一個主程序類//說明這是一個Spring Boot應用@SpringBootApplicationpublic class SpringbootApplication {public static void main(String[] args) { //以為是啟動了一個方法，沒想到啟動了一個服務 SpringApplication.run(SpringbootApplication.class, args); } }

注解

@SpringBootApplication ：springboot的配置@Configuration spring配置類@Component 說明這是一個spring的組件@EnableAutoConfiguration 自動配置@AutoConfigurationPackage 自動配置包@Import({Registrar.class}) 自動配置包注冊@Import({AutoConfigurationImportSelector.class}) 自動配置導入選擇

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-4qgmbzta-1614595470347)(C:\Users\18335\AppData\Roaming\Typora\typora-user-images\image-20201116162511276.png)]

1.@SpringBootApplication

作用：標注在某個類上說明這個類是SpringBoot的主配置類 ， SpringBoot就應該運行這個類的main方法來啟動SpringBoot應用；

進入這個注解：可以看到上面還有很多其他注解！

@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilters = {@Filter( type = FilterType.CUSTOM, classes = {TypeExcludeFilter.class}), @Filter( type = FilterType.CUSTOM, classes = {AutoConfigurationExcludeFilter.class})})public @interface SpringBootApplication { // ......}

2.@ComonentScan

這個注解在Spring中很重要 ,它對應XML配置中的元素。

作用：自動掃描并加載符合條件的組件或者bean ， 將這個bean定義加載到IOC容器中

3.@SpringBootConfiguration

作用：SpringBoot的配置類 ，標注在某個類上 ， 表示這是一個SpringBoot的配置類；

我們繼續進去這個注解查看

// 點進去得到下面的 @Component @Configuration public @interfaceSpringBootConfiguration {} @Component public @interface Configuration {}

這里的 @Configuration，說明這是一個配置類 ，配置類就是對應Spring的xml 配置文件；

里面的 @Component 這就說明，啟動類本身也是Spring中的一個組件而已，負責啟動應用！

我們回到 SpringBootApplication 注解中繼續看。

@EnbleAutoConfiguration

4. @EnableAutoConfiguration ：開啟自動配置功能

以前我們需要自己配置的東西，而現在SpringBoot可以自動幫我們配置 ；@EnableAutoConfiguration告訴SpringBoot開啟自動配置功能，這樣自動配置才能生效；

點進注解接續查看：

@AutoConfigurationPackage ：自動配置包

@Import({Registrar.class}) public @interface AutoConfigurationPackage {}

@import ：Spring底層注解@import ， 給容器中導入一個組件

Registrar.class 作用：將主啟動類的所在包及包下面所有子包里面的所有組件掃描到Spring容器 ；

這個分析完了，退到上一步，繼續看

@Import({AutoConfigurationImportSelector.class}) ：給容器導入組件 ；

AutoConfigurationImportSelector ：自動配置導入選擇器，那么它會導入哪些組件的選擇器呢？我們點擊去這個類看源碼：

1、這個類中有一個這樣的方法

// 獲得候選的配置 protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) { //這里的getSpringFactoriesLoaderFactoryClass（）方法 //返回的就是我們最開始看的啟動自動導入配置文件的注解類；EnableAutoConfiguration List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader()); Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct."); return configurations;}

2、這個方法又調用了 SpringFactoriesLoader 類的靜態方法！我們進入SpringFactoriesLoader類loadFactoryNames() 方法

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) { String factoryClassName = factoryClass.getName(); //這里它又調用了 loadSpringFactories 方法 return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());}

3、我們繼續點擊查看 loadSpringFactories 方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { //獲得classLoader ， 我們返回可以看到這里得到的就是EnableAutoConfiguration標注的類本身 MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader); if (result != null) { return result; } else { try { //去獲取一個資源 "META-INF/spring.factories" Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories"); LinkedMultiValueMap result = new LinkedMultiValueMap();//將讀取到的資源遍歷，封裝成為一個Properties while(urls.hasMoreElements()) { URL url = (URL)urls.nextElement(); UrlResource resource = new UrlResource(url); Properties properties = PropertiesLoaderUtils.loadProperties(resource); Iterator var6 = properties.entrySet().iterator();while(var6.hasNext()) { Entry<?, ?> entry = (Entry)var6.next(); String factoryClassName = ((String)entry.getKey()).trim(); String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue()); int var10 = var9.length;for(int var11 = 0; var11 < var10; ++var11) { String factoryName = var9[var11]; result.add(factoryClassName,factoryName.trim()); } } }cache.put(classLoader, result); return result; } catch (IOException var13) { throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13); } } }

4、發現一個多次出現的文件：spring.factories，全局搜索它

spring.factories

我們根據源頭打開spring.factories ， 看到了很多自動配置的文件；這就是自動配置根源所在！

WebMvcAutoConfiguration

我們在上面的自動配置類隨便找一個打開看看，比如 ：WebMvcAutoConfiguration

可以看到這些一個個的都是JavaConfig配置類，而且都注入了一些Bean，可以找一些自己認識的類，看著熟悉一下！

所以，自動配置真正實現是從classpath中搜尋所有的META-INF/spring.factories配置文件 ，并將其中對應的 org.springframework.boot.autoconfigure. 包下的配置項，通過反射實例化為對應標注了 @Configuration的JavaConfig形式的IOC容器配置類 ， 然后將這些都匯總成為一個實例并加載到IOC容器中。

結論：

SpringBoot在啟動的時候從類路徑下的META-INF/spring.factories中獲取EnableAutoConfiguration指定的值

將這些值作為自動配置類導入容器 ， 自動配置類就生效 ， 幫我們進行自動配置工作；

整個J2EE的整體解決方案和自動配置都在springboot-autoconfigure的jar包中；

它會給容器中導入非常多的自動配置類 （xxxAutoConfiguration）, 就是給容器中導入這個場景需要的所有組件 ， 并配置好這些組件 ；

有了自動配置類 ，免去了我們手動編寫配置注入功能組件等的工作；

3.不簡單的方法

我最初以為就是運行了一個main方法，沒想到卻開啟了一個服務；

@SpringBootApplication public class SpringbootApplication { public static void main(String[] args) { SpringApplication.run(SpringbootApplication.class, args); }}

SpringApplication.run分析

分析該方法主要分兩部分，一部分是SpringApplication的實例化，二是run方法的執行；

SpringApplication

這個類主要做了以下四件事情：

1、推斷應用的類型是普通的項目還是Web項目

2、查找并加載所有可用初始化器 ， 設置到initializers屬性中

3、找出所有的應用程序監聽器，設置到listeners屬性中

4、推斷并設置main方法的定義類，找到運行的主類

查看構造器：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) { // ...... this.webApplicationType = WebApplicationType.deduceFromClasspath(); this.setInitializers(this.getSpringFactoriesInstances(); this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class)); this.mainApplicationClass = this.deduceMainApplicationClass();}

run方法流程分析

SpringBoot的理解

• 自動裝配
• run

3.yaml語法

1.yaml使用

SpringBoot使用一個全局的配置文件 ， 配置文件名稱是固定的

• application.properties

• • 語法結構 ：key=value

• application.yml

• • 語法結構 ：key：空格 value

**配置文件的作用 ：**修改SpringBoot自動配置的默認值，因為SpringBoot在底層都給我們自動配置好了；

1、在springboot項目中的resources目錄下新建一個文件 application.yml

2、編寫一個實體類 Dog

package com.kuang.springboot.pojo; @Component //注冊bean到容器中 public class Dog { private String name; private Integer age; //有參無參構造、get、set方法、toString()方法 }

3、思考，我們原來是如何給bean注入屬性值的！@Value，給狗狗類測試一下：

@Component //注冊bean public class Dog { @Value("阿黃") private String name; @Value("18") private Integer age;}

4、在SpringBoot的測試類下注入狗狗輸出一下；

@SpringBootTestclass DemoApplicationTests {@Autowired //將狗狗自動注入進來 Dog dog;@Test public void contextLoads() { System.out.println(dog); //打印看下狗狗對象 } }

結果成功輸出，@Value注入成功，這是我們原來的辦法對吧。

5、我們在編寫一個復雜一點的實體類：Person 類

@Component //注冊bean到容器中 public class Person { private String name; private Integer age; private Boolean happy; private Date birth; private Map<String,Object> maps; private List<Object> lists; private Dog dog; //有參無參構造、get、set方法、toString()方法 }

6、我們來使用yaml配置的方式進行注入，大家寫的時候注意區別和優勢，我們編寫一個yaml配置！

person: name: qinjiang age: 3 happy: false birth: 2000/01/01 maps: {k1: v1,k2: v2} lists: - code - girl - music dog: name: 旺財 age: 1

7、我們剛才已經把person這個對象的所有值都寫好了，我們現在來注入到我們的類中

/*@ConfigurationProperties作用：將配置文件中配置的每一個屬性的值，映射到這個組件中；告訴SpringBoot將本類中的所有屬性和配置文件中相關的配置進行綁定參數 prefix = “person” : 將配置文件中的person下面的所有屬性一一對應*/ @Component //注冊bean @ConfigurationProperties(prefix = "person") public class Person { private String name; private Integer age; private Boolean happy; private Date birth; private Map<String,Object> maps; private List<Object> lists; private Dog dog;}

8、IDEA 提示，springboot配置注解處理器沒有找到，讓我們看文檔，我們可以查看文檔，找到一個依賴！

<!-- 導入配置文件處理器，配置文件進行綁定就會有提示，需要重啟 --><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional></dependency>

9、確認以上配置都OK之后，我們去測試類中測試一下：

@SpringBootTestclass DemoApplicationTests {@Autowired Person person; //將person自動注入進來@Test public void contextLoads() { System.out.println(person); //打印person信息 } }

結果：所有值全部注入成功！

yaml配置注入到實體類完全OK！

課堂測試：

1、將配置文件的key 值 和 屬性的值設置為不一樣，則結果輸出為null，注入失敗

2、在配置一個person2，然后將 @ConfigurationProperties(prefix = “person2”) 指向我們的person2；

加載指定的配文件

**@PropertySource ：**加載指定的配置文件；

@configurationProperties：默認從全局配置文件中獲取值；

1、我們去在resources目錄下新建一個person.properties文件

name=kuangshen

2、然后在我們的代碼中指定加載person.properties文件

@PropertySource(value = "classpath:person.properties") @Component //注冊bean public class Person {@Value("${name}") private String name;...... }

3、再次輸出測試一下：指定配置文件綁定成功！

配置文件占位符

配置文件還可以編寫占位符生成隨機數

person: name: qinjiang${random.uuid} # 隨機uuid age: ${random.int} # 隨機int happy: false birth: 2000/01/01 maps: {k1: v1,k2: v2} lists: - code - girl - music dog: name: ${person.hello:other}_旺財 age: 1

2. 回顧properties配置

我們上面采用的yaml方法都是最簡單的方式，開發中最常用的；也是springboot所推薦的！那我們來嘮嘮其他的實現方式，道理都是相同的；寫還是那樣寫；配置文件除了yml還有我們之前常用的properties ， 我們沒有講，我們來嘮嘮！

【注意】properties配置文件在寫中文的時候，會有亂碼 ， 我們需要去IDEA中設置編碼格式為UTF-8；

settings–>FileEncodings 中配置；

測試步驟：

1、新建一個實體類User

@Component //注冊bean public class User { private String name; private int age; private String sex;}

2、編輯配置文件 user.properties

user1.name=kuangshen user1.age=18 user1.sex=男

3、我們在User類上使用@Value來進行注入！

@Component //注冊bean @PropertySource(value = "classpath:user.properties") public class User { //直接使用@value @Value("${user.name}") //從配置文件中取值 private String name; @Value("#{9*2}") // #{SPEL} Spring表達式 private int age; @Value("男") // 字面量 private String sex;}

4、Springboot測試

@SpringBootTestclass DemoApplicationTests {@Autowired User user;@Test public void contextLoads() { System.out.println(user); } }

結果正常輸出：

對比小結

@Value這個使用起來并不友好！我們需要為每個屬性單獨注解賦值，比較麻煩；我們來看個功能對比圖

1、@ConfigurationProperties只需要寫一次即可 ， @Value則需要每個字段都添加

2、松散綁定：這個什么意思呢? 比如我的yml中寫的last-name，這個和lastName是一樣的， - 后面跟著的字母默認是大寫的。這就是松散綁定?？梢詼y試一下

3、JSR303數據校驗 ， 這個就是我們可以在字段是增加一層過濾器驗證 ， 可以保證數據的合法性

4、復雜類型封裝，yml中可以封裝對象 ， 使用value就不支持

結論：

配置yml和配置properties都可以獲取到值 ， 強烈推薦 yml；

如果我們在某個業務中，只需要獲取配置文件中的某個值，可以使用一下 @value；

如果說，我們專門編寫了一個JavaBean來和配置文件進行一一映射，就直接@configurationProperties，不要猶豫！

3.JSR303數據校驗

Springboot中可以用@validated來校驗數據，如果數據異常則會統一拋出異常，方便異常中心統一處理。我們這里來寫個注解讓我們的name只能支持Email格式；

@Component //注冊bean @ConfigurationProperties(prefix = "person") @Validated //數據校驗 public class Person {@Email(message="郵箱格式錯誤") //name必須是郵箱格式 private String name;}

運行結果 ：default message [不是一個合法的電子郵件地址];

使用數據校驗，可以保證數據的正確性；

常見參數

@NotNull(message="名字不能為空") private String userName; @Max (value=120,message="年齡最大不能查過120") private int age; @Email(message="郵箱格式錯誤") private String email; 空檢查@Null 驗證對象是否為null@NotNull 驗證對象是否不為null, 無法查檢長度為0的字符串@NotBlank 檢查約束字符串是不是Null還有被Trim的長度是否大于0,只對字符串,且會去掉前后空格.@NotEmpty 檢查約束元素是否為NULL或者是EMPTY. Booelan檢查@AssertTrue 驗證 Boolean 對象是否為 true @AssertFalse 驗證 Boolean 對象是否為 false 長度檢查@Size(min=, max=) 驗證對象（Array,Collection,Map,String）長度是否在給定的范圍之內@Length(min=, max=) string is between min and max included. 日期檢查@Past 驗證 Date 和 Calendar 對象是否在當前時間之前 @Future 驗證 Date 和 Calendar 對象是否在當前時間之后 @Pattern 驗證 String 對象是否符合正則表達式的規則 .......等等除此以外，我們還可以自定義一些數據校驗規則

4多環境切換

不同位置優先級不同

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-2b1vOmsl-1614595470372)(C:\Users\18335\AppData\Roaming\Typora\typora-user-images\image-20201117141503882.png)]

springboot 啟動會掃描以下位置的application.properties或者application.yml文件作為Spring boot的默認配置文件：

優先級1：項目路徑下的config文件夾配置文件優先級2：項目路徑下配置文件優先級3：資源路徑下的config文件夾配置文件優先級4：資源路徑下配置文件

優先級由高到底，高優先級的配置會覆蓋低優先級的配置；

SpringBoot會從這四個位置全部加載主配置文件；互補配置；

我們在最低級的配置文件中設置一個項目訪問路徑的配置來測試互補問題；

#配置項目的訪問路徑server.servlet.context-path=/kuang

profile是Spring對不同環境提供不同配置功能的支持，可以通過激活不同的環境版本，實現快速切換環境；

多配置文件

我們在主配置文件編寫的時候，文件名可以是 application-{profile}.properties/yml , 用來指定多個環境版本；

例如：

application-test.properties 代表測試環境配置

application-dev.properties 代表開發環境配置

但是Springboot并不會直接啟動這些配置文件，它默認使用application.properties主配置文件；

我們需要通過一個配置來選擇需要激活的環境：

#比如在配置文件中指定使用dev環境，我們可以通過設置不同的端口號進行測試；#我們啟動SpringBoot，就可以看到已經切換到dev下的配置了；spring.profiles.active=dev

yaml的多文檔塊

和properties配置文件中一樣，但是使用yml去實現不需要創建多個配置文件，更加方便了 !

server: port: 8081#選擇要激活那個環境塊spring: profiles: active: prod ---server: port: 8083spring: profiles: dev #配置環境的名稱--- server: port: 8084spring: profiles: prod #配置環境的名稱

注意：如果yml和properties同時都配置了端口，并且沒有激活其他環境 ， 默認會使用properties配置文件的！

4. 自動配置深如

我們以**HttpEncodingAutoConfiguration（Http編碼自動配置）**為例解釋自動配置原理；

//表示這是一個配置類，和以前編寫的配置文件一樣，也可以給容器中添加組件； @Configuration //啟動指定類的ConfigurationProperties功能； //進入這個HttpProperties查看，將配置文件中對應的值和HttpProperties綁定起來； //并把HttpProperties加入到ioc容器中 @EnableConfigurationProperties({HttpProperties.class}) //Spring底層 @Conditional注解 //根據不同的條件判斷，如果滿足指定的條件，整個配置類里面的配置就會生效； //這里的意思就是判斷當前應用是否是web應用，如果是，當前配置類生效 @ConditionalOnWebApplication( type = Type.SERVLET) //判斷當前項目有沒有這個類CharacterEncodingFilter；SpringMVC中進行亂碼解決的過濾器；@ConditionalOnClass({CharacterEncodingFilter.class}) //判斷配置文件中是否存在某個配置：spring.http.encoding.enabled； //如果不存在，判斷也是成立的 //即使我們配置文件中不配置pring.http.encoding.enabled=true，也是默認生效的； @ConditionalOnProperty( prefix = "spring.http.encoding", value = {"enabled"}, matchIfMissing = true) public class HttpEncodingAutoConfiguration { //他已經和SpringBoot的配置文件映射了 private final Encoding properties; //只有一個有參構造器的情況下，參數的值就會從容器中拿 public HttpEncodingAutoConfiguration(HttpProperties properties) { this.properties = properties.getEncoding(); } //給容器中添加一個組件，這個組件的某些值需要從properties中獲取 @Bean @ConditionalOnMissingBean //判斷容器沒有這個組件？ public CharacterEncodingFilter characterEncodingFilter() { CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter(); filter.setEncoding(this.properties.getCharset().name()); filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST)); filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE)); return filter; } //。。。。。。。 }

一句話總結 ：根據當前不同的條件判斷，決定這個配置類是否生效！

• 一但這個配置類生效；這個配置類就會給容器中添加各種組件；
• 這些組件的屬性是從對應的properties類中獲取的，這些類里面的每一個屬性又是和配置文件綁定的；
• 所有在配置文件中能配置的屬性都是在xxxxProperties類中封裝著；
• 配置文件能配置什么就可以參照某個功能對應的這個屬性類

//從配置文件中獲取指定的值和bean的屬性進行綁定 @ConfigurationProperties(prefix = "spring.http") public class HttpProperties { // .....}

我們去配置文件里面試試前綴，看提示！

這就是自動裝配的原理！

精髓

1、SpringBoot啟動會加載大量的自動配置類

2、我們看我們需要的功能有沒有在SpringBoot默認寫好的自動配置類當中；

3、我們再來看這個自動配置類中到底配置了哪些組件；（只要我們要用的組件存在在其中，我們就不需要再手動配置了）

4、給容器中自動配置類添加組件的時候，會從properties類中獲取某些屬性。我們只需要在配置文件中指定這些屬性的值即可；

**xxxxAutoConfigurartion：自動配置類；**給容器中添加組件

xxxxProperties:封裝配置文件中相關屬性；

了解：@Conditional

了解完自動裝配的原理后，我們來關注一個細節問題，自動配置類必須在一定的條件下才能生效；

@Conditional派生注解（Spring注解版原生的@Conditional作用）

作用：必須是@Conditional指定的條件成立，才給容器中添加組件，配置配里面的所有內容才生效；

那么多的自動配置類，必須在一定的條件下才能生效；也就是說，我們加載了這么多的配置類，但不是所有的都生效了。

我們怎么知道哪些自動配置類生效？

我們可以通過啟用 debug=true屬性；來讓控制臺打印自動配置報告，這樣我們就可以很方便的知道哪些自動配置類生效；

#開啟springboot的調試類debug=true

Positive matches:（自動配置類啟用的：正匹配）

Negative matches:（沒有啟動，沒有匹配成功的自動配置類：負匹配）

Unconditional classes: （沒有條件的類）

【演示：查看輸出的日志】

掌握吸收理解原理，即可以不變應萬變！

SpringBoot web

1.導入靜態資源

@Override public void addResourceHandlers(ResourceHandlerRegistry registry) {if (!this.resourceProperties.isAddMappings()) {// 已禁用默認資源處理logger.debug("Default resource handling disabled");return;}// 緩存控制Duration cachePeriod = this.resourceProperties.getCache().getPeriod();CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();// webjars 配置if (!registry.hasMappingForPattern("/webjars/**")) {customizeResourceHandlerRegistration(registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/").setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));}// 靜態資源配置String staticPathPattern = this.mvcProperties.getStaticPathPattern();if (!registry.hasMappingForPattern(staticPathPattern)) {customizeResourceHandlerRegistration(registry.addResourceHandler(staticPathPattern).addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations())).setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));} }

使用webjars

Webjars本質就是以jar包的方式引入我們的靜態資源 ， 我們以前要導入一個靜態資源文件，直接導入即可。

使用SpringBoot需要使用Webjars，我們可以去搜索一下：

網站：https://www.webjars.org

要使用jQuery，我們只要要引入jQuery對應版本的pom依賴即可！

<dependency> <groupId>org.webjars</groupId> <artifactId>jquery</artifactId> <version>3.4.1</version></dependency>

導入完畢，查看webjars目錄結構，并訪問Jquery.js文件！

訪問：只要是靜態資源，SpringBoot就會去對應的路徑尋找資源，我們這里訪問：http://localhost:8080/webjars/jquery/3.4.1/jquery.js

在目錄中

以下四個目錄存放的靜態資源可以被我們識別：

"classpath:/META-INF/resources/"“classpath:/resources/""classpath:/static/""classpath:/public/"

原文

總結

以上是生活随笔為你收集整理的SpringBoot入门学习的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。