微服務：架構風格（服務微化）

阿新 • • 發佈：2020-08-20

1、Spring Boot 簡介
簡化Spring應用開發的一個框架；
整個Spring技術棧的一個大整合；
J2EE開發的一站式解決方案；

2、微服務
2014，martin fowler

微服務：架構風格（服務微化）

一個應用應該是一組小型服務；可以通過HTTP的方式進行互通；

單體應用：ALL IN ONE

微服務：每一個功能元素最終都是一個可獨立替換和獨立升級的軟體單元；
1
2
3
4
5
6
7
8
9
詳細參照微服務文件

中文翻譯

3、環境準備
環境約束（統一環境）

–jdk1.8：Spring Boot 推薦jdk1.7及以上；java version “1.8.0_112”

–maven3.x：maven 3.3以上版本；Apache Maven 3.3.9

–IntelliJIDEA2017：IntelliJ IDEA 2017.2.2 x64、STS

–SpringBoot 1.5.9.RELEASE：1.5.9；

（1）MAVEN設定
給maven 的settings.xml配置檔案的profiles標籤新增。
作用：告訴maven預設編譯執行採用jdk1.8。

jdk-1.8 true 1.8 1.8 1.8 1.8 1 2 3 4 5 6 7 8 9 10 11 12 （2）IDEA設定在這裡插入圖片描述整合maven進來

在這裡插入圖片描述

4、Spring Boot HelloWorld
一個功能：瀏覽器傳送hello請求，伺服器接受請求並處理，響應Hello World字串；

（1）建立一個maven工程（jar）
在這裡插入圖片描述

（2）匯入spring boot相關的依賴

org.springframework.boot
spring-boot-starter-parent
1.5.9.RELEASE

org.springframework.boot
spring-boot-starter-web

1
2
3
4
5
6
7
8
9
10
11
解決下載依賴緩慢問題

mirrorId repositoryId Human Readable Name for this Mirror. http://my.repository.com/repo/path

1 2 3 4 5 6 7 8 9 （3）編寫一個主程式；啟動Spring Boot應用 /** * @SpringBootApplication//來標註一個主程式類，說明這是一個springboot應用 */ @SpringBootApplication public class HelloWorldMainApplication { public static void main(String[] args) {

    //spring應用啟動起來
    SpringApplication.run(HelloWorldMainApplication.class,args);
}

}
1
2
3
4
5
6
7
8
9
10
11
（4）編寫相關的Controller、Service
@Controller
public class HelloController {

@ResponseBody
@RequestMapping("/hello")
public String hello(){
    return "Hello World!";
}

}

1
2
3
4
5
6
7
8
9
10
（5）執行主程式測試
在這裡插入圖片描述
一個功能：瀏覽器傳送hello請求，伺服器接收請求並相應，響應Hello World 字串；

（6）簡化部署
pom.xml中匯入

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

1
2
3
4
5
6
7
8
9
將這個應用打成jar包，直接使用java -jar的命令進行執行；
在這裡插入圖片描述
jar包內容
在這裡插入圖片描述

5、Hello World探究
（1）POM檔案
①父專案

org.springframework.boot
spring-boot-starter-parent
2.1.13.RELEASE

他的父專案是

org.springframework.boot spring-boot-dependencies 2.1.13.RELEASE ../../spring-boot-dependencies 5.15.11 2.7.7

1.9.78

2.6.4 1.9.5 ··· ···214個 ··· 3.11.1

Spring Boot的版本仲裁中心

以後我們匯入依賴預設是不需要寫版本；
沒有在dependencies裡面管理的依賴，需要我們宣告版本號；

②啟動器
spring-boot-starter：spring-boot場景啟動器；

Spring Boot將所有的功能場景都抽取出來，做成一個個的starters（啟動器），只需要在專案裡面引入這些starter相關場景的所有依賴都會匯入進來。要用什麼功能就匯入什麼場景的啟動器。

spring-boot-starter-web：幫我們匯入了web模組正常執行所依賴的元件；

spring-boot-starter-aop：幫我們匯入了AOP模組正常執行所依賴的元件；

springboot啟動器官網

org.springframework.boot spring-boot-starter-web

spring-boot-starter-web
幫我們匯入了web模組正常執行所依賴的元件

org.springframework
spring-web
5.1.14.RELEASE
compile

org.springframework
spring-webmvc
5.1.14.RELEASE
compile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
在這裡插入圖片描述
等等······

（2）主程式類，主入口類
/**

@SpringBootApplication 來標註一個主程式類，說明這是一個Spring Boot應用
*/
@SpringBootApplication//--------------------------------------
public class HelloWorldMainApplication {

public static void main(String[] args) {
```
// Spring應用啟動起來
SpringApplication.run(HelloWorldMainApplication.class,args);
```
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@SpringBootApplication: Spring Boot應用標註在某個類上說明這個類是SpringBoot的主配置類，SpringBoot就應該執行這個類的main方法來啟動SpringBoot應用；

@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 {
1
2
3
4
5
6
7
8
9
10
① @SpringBootConfiguration:Spring Boot的配置類；
標註在某個類上，表示這是一個Spring Boot的配置類；

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration//--------------------------------------
public @interface SpringBootConfiguration {

}
1
2
3
4
5
6
7
@Configuration:配置類上來標註這個註解；

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
@AliasFor(
annotation = Component.class
)
String value() default "";
}
1
2
3
4
5
6
7
8
9
10
配置類 ----- 配置檔案；配置類也是容器中的一個元件；@Component

② @EnableAutoConfiguration：開啟自動配置功能；
以前我們需要配置的東西，Spring Boot幫我們自動配置；@EnableAutoConfiguration告訴SpringBoot開啟自動配置功能；這樣自動配置才能生效；

@AutoConfigurationPackage//------------
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
1
2
3
4
5
6
7
a. @AutoConfigurationPackage：自動配置包

@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}
1
2
3
@Import(AutoConfigurationPackages.Registrar.class)：
Spring的底層註解@Import，給容器中匯入一個元件；

匯入的元件由AutoConfigurationPackages.Registrar.class；

作用：將主配置類（@SpringBootApplication標註的類）的所在包及下面所有子包裡面的所有元件掃描到Spring容器；

b. @Import(EnableAutoConfigurationImportSelector.class)；

給容器中匯入元件？

EnableAutoConfigurationImportSelector類：匯入哪些元件的選擇器；
將所有需要匯入的元件以全類名的方式返回；這些元件就會被新增到容器中；

作用：會給容器中匯入非常多的自動配置類（xxxAutoConfiguration）；就是給容器中匯入這個場景需要的所有元件，並配置好這些元件；

在這裡插入圖片描述

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

SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader)；

Spring Boot在啟動的時候從類路徑下的META-INF/spring.factories中獲取EnableAutoConfiguration指定的值，將這些值作為自動配置類匯入到容器中，自動配置類就生效，幫我們進行自動配置工作以前我們需要自己配置的東西，自動配置類都幫我們；

J2EE的整體整合解決方案和自動配置都在spring-boot-autoconfigure-1.5.9.RELEASE.jar；

6、使用Spring Initializer快速建立Spring Boot專案
1、IDEA：使用 Spring Initializer快速建立專案
IDE都支援使用Spring的專案建立嚮導快速建立一個Spring Boot專案；

選擇我們需要的模組；嚮導會聯網建立Spring Boot專案；

預設生成的Spring Boot專案；

主程式已經生成好了，我們只需要我們自己的邏輯
resources資料夾中目錄結構
static：儲存所有的靜態資源； js css images；
templates：儲存所有的模板頁面；（Spring Boot預設jar包使用嵌入式的Tomcat，預設不支援JSP頁面）；可以使用模板引擎（freemarker、thymeleaf）；
application.properties：Spring Boot應用的配置檔案；可以修改一些預設設定；
2、STS使用 Spring Starter Project快速建立專案
二、配置檔案
1、配置檔案
SpringBoot使用一個全域性的配置檔案，配置檔名是固定的；

•application.properties

•application.yml

配置檔案的作用：修改SpringBoot自動配置的預設值；SpringBoot在底層都給我們自動配置好；

YAML（YAML Ain’t Markup Language）

YAML A Markup Language：是一個標記語言

YAML isn’t Markup Language：不是一個標記語言；

標記語言：

以前的配置檔案；大多都使用的是 xxxx.xml檔案；

YAML：以資料為中心，比json、xml等更適合做配置檔案；

YAML：配置例子

server:
port: 8081
1
2
XML：

8081 1 2 3 2、YAML語法： 1、基本語法 k:(空格)v：表示一對鍵值對（空格必須有）；

以空格的縮排來控制層級關係；只要是左對齊的一列資料，都是同一個層級的

server:
port: 8081
path: /hello
1
2
3
屬性和值也是大小寫敏感；

2、值的寫法
字面量：普通的值（數字，字串，布林）
k: v：字面直接來寫；

字串預設不用加上單引號或者雙引號；

“”：雙引號；不會轉義字串裡面的特殊字元；特殊字元會作為本身想表示的意思

name: “zhangsan \n lisi”：輸出；zhangsan 換行 lisi

‘’：單引號；會轉義特殊字元，特殊字元最終只是一個普通的字串資料

name: ‘zhangsan \n lisi’：輸出；zhangsan \n lisi

物件、Map（屬性和值）（鍵值對）：
k: v：在下一行來寫物件的屬性和值的關係；注意縮排

物件還是k: v的方式

friends:
lastName: zhangsan
age: 20
1
2
3
行內寫法：

friends: {lastName: zhangsan,age: 18}
1
陣列（List、Set）：
用- 值表示陣列中的一個元素

pets:

cat
dog
pig
1
2
3
4
行內寫法

pets: [cat,dog,pig]
1
3、配置檔案值注入
配置檔案

person:
lastName: hello
age: 18
boss: false
birth: 2017/12/12
maps: {k1: v1,k2: 12}
lists:
- lisi
- zhaoliu
dog:
name: 小狗
age: 12
1
2
3
4
5
6
7
8
9
10
11
12
javaBean：

/**

將配置檔案中配置的每一個屬性的值，對映到這個元件中
@ConfigurationProperties：告訴SpringBoot將本類中的所有屬性和配置檔案中相關的配置進行繫結；

 prefix = "person"：配置檔案中哪個下面的所有屬性進行一一對映

只有這個元件是容器中的元件，才能容器提供的@ConfigurationProperties功能；

*/
@Component
@ConfigurationProperties(prefix = "person")
public class Person {

private String lastName;
private Integer age;
private Boolean boss;
private Date birth;

private Map<String,Object> maps;
private List<Object> lists;
private Dog dog;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
我們可以匯入配置檔案處理器，以後編寫配置就有提示了

	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-configuration-processor</artifactId>
		<optional>true</optional>
	</dependency>

1
2
3
4
5
6
1、properties配置檔案在idea中預設utf-8可能會亂碼
調整

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-2EMGopdv-1597758540523)(images/搜狗截圖20180130161620.png)]

2、@Value獲取值和@ConfigurationProperties獲取值比較
@ConfigurationProperties @Value
功能批量注入配置檔案中的屬性一個個指定
鬆散繫結（鬆散語法）支援不支援
SpEL 不支援支援
JSR303資料校驗支援不支援
複雜型別封裝支援不支援
配置檔案yml還是properties他們都能獲取到值；

如果說，我們只是在某個業務邏輯中需要獲取一下配置檔案中的某項值，使用@Value；

如果說，我們專門編寫了一個javaBean來和配置檔案進行對映，我們就直接使用@ConfigurationProperties；

3、配置檔案注入值資料校驗
@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {

/**
 * <bean class="Person">
 *      <property name="lastName" value="字面量/${key}從環境變數、配置檔案中獲取值/#{SpEL}"></property>
 * <bean/>
 */

//lastName必須是郵箱格式
@Email
//@Value("${person.last-name}")
private String lastName;
//@Value("#{11*2}")
private Integer age;
//@Value("true")
private Boolean boss;

private Date birth;
private Map<String,Object> maps;
private List<Object> lists;
private Dog dog;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
4、@PropertySource&@ImportResource&@Bean
@PropertySource：載入指定的配置檔案；

/**

將配置檔案中配置的每一個屬性的值，對映到這個元件中
@ConfigurationProperties：告訴SpringBoot將本類中的所有屬性和配置檔案中相關的配置進行繫結；

 prefix = "person"：配置檔案中哪個下面的所有屬性進行一一對映

只有這個元件是容器中的元件，才能容器提供的@ConfigurationProperties功能；
@ConfigurationProperties(prefix = "person")預設從全域性配置檔案中獲取值；

*/
@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
//@Validated
public class Person {

/**
 * <bean class="Person">
 *      <property name="lastName" value="字面量/${key}從環境變數、配置檔案中獲取值/#{SpEL}"></property>
 * <bean/>
 */

//lastName必須是郵箱格式
// @Email
//@Value("${person.last-name}")
private String lastName;
//@Value("#{11*2}")
private Integer age;
//@Value("true")
private Boolean boss;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@ImportResource：匯入Spring的配置檔案，讓配置檔案裡面的內容生效；

Spring Boot裡面沒有Spring的配置檔案，我們自己編寫的配置檔案，也不能自動識別；

想讓Spring的配置檔案生效，載入進來；@ImportResource標註在一個配置類上

@ImportResource(locations = {"classpath:beans.xml"})
匯入Spring的配置檔案讓其生效
1
2
不來編寫Spring的配置檔案

<bean id="helloService" class="com.atguigu.springboot.service.HelloService"></bean>

1 2 3 4 5 6 7 8 SpringBoot推薦給容器中新增元件的方式；推薦使用全註解的方式

1、配置類@Configuration------>Spring配置檔案

2、使用@Bean給容器中新增元件

/**

@Configuration：指明當前類是一個配置類；就是來替代之前的Spring配置檔案
在配置檔案中用標籤新增元件

*/
@Configuration
public class MyAppConfig {

//將方法的返回值新增到容器中；容器中這個元件預設的id就是方法名
@Bean
public HelloService helloService02(){
    System.out.println("配置類@Bean給容器中新增元件了...");
    return new HelloService();
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、配置檔案佔位符

1、隨機數
${random.value}、${random.int}、${random.long}
${random.int(10)}、${random.int[1024,65536]}

1
2
3
2、佔位符獲取之前配置的值，如果沒有可以是用:指定預設值
person.last-name=張三${random.uuid}
person.age=${random.int}
person.birth=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.lists=a,b,c
person.dog.name=${person.hello:hello}_dog
person.dog.age=15
1
2
3
4
5
6
7
8
9
5、Profile
1、多Profile檔案
我們在主配置檔案編寫的時候，檔名可以是 application-{profile}.properties/yml

預設使用application.properties的配置；

2、yml支援多文件塊方式

server:
port: 8081
spring:
profiles:
active: prod

server:
port: 8083
spring:
profiles: dev

server:
port: 8084
spring:
profiles: prod #指定屬於哪個環境
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
3、啟用指定profile
1、在配置檔案中指定 spring.profiles.active=dev

2、命令列：

java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev；

可以直接在測試的時候，配置傳入命令列引數

3、虛擬機器引數；

-Dspring.profiles.active=dev

6、配置檔案載入位置
springboot 啟動會掃描以下位置的application.properties或者application.yml檔案作為Spring boot的預設配置檔案

–file:./config/

–file:./

–classpath:/config/

–classpath:/

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

SpringBoot會從這四個位置全部載入主配置檔案；互補配置；

我們還可以通過spring.config.location來改變預設的配置檔案位置

專案打包好以後，我們可以使用命令列引數的形式，啟動專案的時候來指定配置檔案的新位置；指定配置檔案和預設載入的這些配置檔案共同起作用形成互補配置；

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties

7、外部配置載入順序
SpringBoot也可以從以下位置載入配置；優先順序從高到低；高優先順序的配置覆蓋低優先順序的配置，所有的配置會形成互補配置

1.命令列引數

所有的配置都可以在命令列上進行指定

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc

多個配置用空格分開； --配置項=值

2.來自java:comp/env的JNDI屬性

3.Java系統屬性（System.getProperties()）

4.作業系統環境變數

5.RandomValuePropertySource配置的random.*屬性值

由jar包外向jar包內進行尋找；

優先載入帶profile

6.jar包外部的application-{profile}.properties或application.yml(帶spring.profile)配置檔案

7.jar包內部的application-{profile}.properties或application.yml(帶spring.profile)配置檔案

再來載入不帶profile

8.jar包外部的application.properties或application.yml(不帶spring.profile)配置檔案

9.jar包內部的application.properties或application.yml(不帶spring.profile)配置檔案

10.@Configuration註解類上的@PropertySource

11.通過SpringApplication.setDefaultProperties指定的預設屬性

所有支援的配置載入來源；

參考官方文件

8、自動配置原理
配置檔案到底能寫什麼？怎麼寫？自動配置原理；

配置檔案能配置的屬性參照

1、自動配置原理：
1）、SpringBoot啟動的時候載入主配置類，開啟了自動配置功能 @EnableAutoConfiguration

2）、@EnableAutoConfiguration 作用：

利用EnableAutoConfigurationImportSelector給容器中匯入一些元件？

可以檢視selectImports()方法的內容；

List configurations = getCandidateConfigurations(annotationMetadata, attributes);獲取候選的配置

SpringFactoriesLoader.loadFactoryNames()
掃描所有jar包類路徑下 META-INF/spring.factories
把掃描到的這些檔案的內容包裝成properties物件
從properties中獲取到EnableAutoConfiguration.class類（類名）對應的值，然後把他們新增在容器中

1
2
3
4
5

將類路徑下 META-INF/spring.factories 裡面配置的所有EnableAutoConfiguration的值加入到了容器中；

Auto Configure

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
每一個這樣的 xxxAutoConfiguration類都是容器中的一個元件，都加入到容器中；用他們來做自動配置；

3）、每一個自動配置類進行自動配置功能；

4）、以HttpEncodingAutoConfiguration（Http編碼自動配置）為例解釋自動配置原理；

@Configuration //表示這是一個配置類，以前編寫的配置檔案一樣，也可以給容器中新增元件
@EnableConfigurationProperties(HttpEncodingProperties.class) //啟動指定類的ConfigurationProperties功能；將配置檔案中對應的值和HttpEncodingProperties繫結起來；並把HttpEncodingProperties加入到ioc容器中

@ConditionalOnWebApplication //Spring底層@Conditional註解（Spring註解版），根據不同的條件，如果滿足指定的條件，整個配置類裡面的配置就會生效；判斷當前應用是否是web應用，如果是，當前配置類生效

@ConditionalOnClass(CharacterEncodingFilter.class) //判斷當前專案有沒有這個類CharacterEncodingFilter；SpringMVC中進行亂碼解決的過濾器；

@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true) //判斷配置檔案中是否存在某個配置 spring.http.encoding.enabled；如果不存在，判斷也是成立的
//即使我們配置檔案中不配置pring.http.encoding.enabled=true，也是預設生效的；
public class HttpEncodingAutoConfiguration {

//他已經和SpringBoot的配置檔案映射了
private final HttpEncodingProperties properties;

//只有一個有參構造器的情況下，引數的值就會從容器中拿
public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
this.properties = properties;
}

@Bean   //給容器中新增一個元件，這個元件的某些值需要從properties中獲取
@ConditionalOnMissingBean(CharacterEncodingFilter.class) //判斷容器沒有這個元件？
public CharacterEncodingFilter characterEncodingFilter() {
	CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
	filter.setEncoding(this.properties.getCharset().name());
	filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
	filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
	return filter;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
根據當前不同的條件判斷，決定這個配置類是否生效？

一但這個配置類生效；這個配置類就會給容器中新增各種元件；這些元件的屬性是從對應的properties類中獲取的，這些類裡面的每一個屬性又是和配置檔案繫結的；

5）、所有在配置檔案中能配置的屬性都是在xxxxProperties類中封裝者‘；配置檔案能配置什麼就可以參照某個功能對應的這個屬性類

@ConfigurationProperties(prefix = "spring.http.encoding") //從配置檔案中獲取指定的值和bean的屬性進行繫結
public class HttpEncodingProperties {

public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
1
2
3
4
精髓：

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

2）、我們看我們需要的功能有沒有SpringBoot預設寫好的自動配置類；

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

4）、給容器中自動配置類新增元件的時候，會從properties類中獲取某些屬性。我們就可以在配置檔案中指定這些屬性的值；

xxxxAutoConfigurartion：自動配置類；

給容器中新增元件

xxxxProperties:封裝配置檔案中相關屬性；

2、細節
1、@Conditional派生註解（Spring註解版原生的@Conditional作用）
作用：必須是@Conditional指定的條件成立，才給容器中新增元件，配置配裡面的所有內容才生效；

@Conditional擴充套件註解作用（判斷是否滿足當前指定條件）
@ConditionalOnJava 系統的java版本是否符合要求
@ConditionalOnBean 容器中存在指定Bean；
@ConditionalOnMissingBean 容器中不存在指定Bean；
@ConditionalOnExpression 滿足SpEL表示式指定
@ConditionalOnClass 系統中有指定的類
@ConditionalOnMissingClass 系統中沒有指定的類
@ConditionalOnSingleCandidate 容器中只有一個指定的Bean，或者這個Bean是首選Bean
@ConditionalOnProperty 系統中指定的屬性是否有指定的值
@ConditionalOnResource 類路徑下是否存在指定資原始檔
@ConditionalOnWebApplication 當前是web環境
@ConditionalOnNotWebApplication 當前不是web環境
@ConditionalOnJndi JNDI存在指定項
自動配置類必須在一定的條件下才能生效；

我們怎麼知道哪些自動配置類生效；

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

=========================
AUTO-CONFIGURATION REPORT

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

DispatcherServletAutoConfiguration matched:
- @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
- @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)

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

ActiveMQAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)

AopAutoConfiguration:
Did not match:
- @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
三、日誌
1、日誌框架
小張；開發一個大型系統；

1、System.out.println("")；將關鍵資料列印在控制檯；去掉？寫在一個檔案？

2、框架來記錄系統的一些執行時資訊；日誌框架； zhanglogging.jar；

3、高大上的幾個功能？非同步模式？自動歸檔？xxxx？ zhanglogging-good.jar？

4、將以前框架卸下來？換上新的框架，重新修改之前相關的API；zhanglogging-prefect.jar；

5、JDBC—資料庫驅動；

寫了一個統一的介面層；日誌門面（日誌的一個抽象層）；logging-abstract.jar；

給專案中匯入具體的日誌實現就行了；我們之前的日誌框架都是實現的抽象層；

市面上的日誌框架；

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…

日誌門面（日誌的抽象層）日誌實現
JCL（Jakarta Commons Logging） SLF4j（Simple Logging Facade for Java） jboss-logging Log4j JUL（java.util.logging） Log4j2 Logback
左邊選一個門面（抽象層）、右邊來選一個實現；

日誌門面： SLF4J；

日誌實現：Logback；

SpringBoot：底層是Spring框架，Spring框架預設是用JCL；‘

SpringBoot選用 SLF4j和logback；

2、SLF4j使用
1、如何在系統中使用SLF4j https://www.slf4j.org
以後開發的時候，日誌記錄方法的呼叫，不應該來直接呼叫日誌的實現類，而是呼叫日誌抽象層裡面的方法；

給系統裡面匯入slf4j的jar和 logback的實現jar

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(HelloWorld.class);
logger.info("Hello World");
}
}
1
2
3
4
5
6
7
8
9
圖示；

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-vKnmcTX9-1597758540525)(images/concrete-bindings.png)]

每一個日誌的實現框架都有自己的配置檔案。使用slf4j以後，配置檔案還是做成日誌實現框架自己本身的配置檔案；

2、遺留問題
a（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

統一日誌記錄，即使是別的框架和我一起統一使用slf4j進行輸出？

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-tXHBLcFk-1597758540526)(images/legacy.png)]

如何讓系統中所有的日誌都統一到slf4j；

1、將系統中其他日誌框架先排除出去；

2、用中間包來替換原有的日誌框架；

3、我們匯入slf4j其他的實現

3、SpringBoot日誌關係

org.springframework.boot
spring-boot-starter

1
2
3
4
SpringBoot使用它來做日誌功能；

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

1
2
3
4
底層依賴關係

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-nCt7jcac-1597758540527)(images/搜狗截圖20180131220946.png)]

總結：

1）、SpringBoot底層也是使用slf4j+logback的方式進行日誌記錄

2）、SpringBoot也把其他的日誌都替換成了slf4j；

3）、中間替換包？

@SuppressWarnings("rawtypes")
public abstract class LogFactory {

static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";

static LogFactory logFactory = new SLF4JLogFactory();

1
2
3
4
5
6
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-HLDNu29V-1597758540527)(images/搜狗截圖20180131221411.png)]

4）、如果我們要引入其他框架？一定要把這個框架的預設日誌依賴移除掉？

Spring框架用的是commons-logging；

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-core</artifactId>
		<exclusions>
			<exclusion>
				<groupId>commons-logging</groupId>
				<artifactId>commons-logging</artifactId>
			</exclusion>
		</exclusions>
	</dependency>

1
2
3
4
5
6
7
8
9
10
SpringBoot能自動適配所有的日誌，而且底層使用slf4j+logback的方式記錄日誌，引入其他框架的時候，只需要把這個框架依賴的日誌框架排除掉即可；

4、日誌使用；
1、預設配置
SpringBoot預設幫我們配置好了日誌；

//記錄器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
public void contextLoads() {
	//System.out.println();

	//日誌的級別；
	//由低到高   trace<debug<info<warn<error
	//可以調整輸出的日誌級別；日誌就只會在這個級別以以後的高級別生效
	logger.trace("這是trace日誌...");
	logger.debug("這是debug日誌...");
	//SpringBoot預設給我們使用的是info級別的，沒有指定級別的就用SpringBoot預設規定的級別；root級別
	logger.info("這是info日誌...");
	logger.warn("這是warn日誌...");
	logger.error("這是error日誌...");


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
日誌輸出格式：
%d表示日期時間，
%thread表示執行緒名，
%-5level：級別從左顯示5個字元寬度
%logger{50} 表示logger名字最長50個字元，否則按照句點分割。
%msg：日誌訊息，
%n是換行符
-->
%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
1
2
3
4
5
6
7
8
9
SpringBoot修改日誌的預設配置

logging.level.com.atguigu=trace

logging.path=

不指定路徑在當前專案下生成springboot.log日誌

可以指定完整的路徑；

logging.file=G:/springboot.log

在當前磁碟的根路徑下建立spring資料夾和裡面的log資料夾；使用 spring.log 作為預設檔案

logging.path=/spring/log

在控制檯輸出的日誌的格式

logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n

指定檔案中日誌輸出的格式

logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
logging.file logging.path Example Description
(none) (none) 只在控制檯輸出
指定檔名 (none) my.log 輸出日誌到my.log檔案
(none) 指定目錄 /var/log 輸出到指定目錄的 spring.log 檔案中
2、指定配置
給類路徑下放上每個日誌框架自己的配置檔案即可；SpringBoot就不使用他預設配置的了

Logging System Customization
Logback logback-spring.xml, logback-spring.groovy, logback.xml or logback.groovy
Log4j2 log4j2-spring.xml or log4j2.xml
JDK (Java Util Logging) logging.properties
logback.xml：直接就被日誌框架識別了；

logback-spring.xml：日誌框架就不直接載入日誌的配置項，由SpringBoot解析日誌配置，可以使用SpringBoot的高階Profile功能

可以指定某段配置只在某個環境下生效

1
2
3
4
5
如：

%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n %d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 如果使用logback.xml作為日誌配置檔案，還要使用profile功能，會有以下錯誤

no applicable action for [springProfile]

5、切換日誌框架
可以按照slf4j的日誌適配圖，進行相關的切換；

slf4j+log4j的方式；

org.springframework.boot spring-boot-starter-web logback-classic ch.qos.logback log4j-over-slf4j org.slf4j org.slf4j slf4j-log4j12

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
切換為log4j2

org.springframework.boot spring-boot-starter-web spring-boot-starter-logging org.springframework.boot org.springframework.boot spring-boot-starter-log4j2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 四、Web開發 1、簡介使用SpringBoot；

1）、建立SpringBoot應用，選中我們需要的模組；

2）、SpringBoot已經預設將這些場景配置好了，只需要在配置檔案中指定少量配置就可以執行起來

3）、自己編寫業務程式碼；

自動配置原理？

這個場景SpringBoot幫我們配置了什麼？能不能修改？能修改哪些配置？能不能擴充套件？xxx

xxxxAutoConfiguration：幫我們給容器中自動配置元件；
xxxxProperties:配置類來封裝配置檔案的內容；

1
2
3
2、SpringBoot對靜態資源的對映規則；
@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties implements ResourceLoaderAware {
//可以設定和靜態資源有關的引數，快取時間等
1
2
3
WebMvcAuotConfiguration：
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
if (!this.resourceProperties.isAddMappings()) {
logger.debug("Default resource handling disabled");
return;
}
Integer cachePeriod = this.resourceProperties.getCachePeriod();
if (!registry.hasMappingForPattern("/webjars/")) {
customizeResourceHandlerRegistration(
registry.addResourceHandler("/webjars/")
.addResourceLocations(
"classpath:/META-INF/resources/webjars/")
.setCachePeriod(cachePeriod));
}
String staticPathPattern = this.mvcProperties.getStaticPathPattern();
//靜態資原始檔夾對映
if (!registry.hasMappingForPattern(staticPathPattern)) {
customizeResourceHandlerRegistration(
registry.addResourceHandler(staticPathPattern)
.addResourceLocations(
this.resourceProperties.getStaticLocations())
.setCachePeriod(cachePeriod));
}
}

    //配置歡迎頁對映
	@Bean
	public WelcomePageHandlerMapping welcomePageHandlerMapping(
			ResourceProperties resourceProperties) {
		return new WelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
				this.mvcProperties.getStaticPathPattern());
	}

   //配置喜歡的圖示
	@Configuration
	@ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
	public static class FaviconConfiguration {

		private final ResourceProperties resourceProperties;

		public FaviconConfiguration(ResourceProperties resourceProperties) {
			this.resourceProperties = resourceProperties;
		}

		@Bean
		public SimpleUrlHandlerMapping faviconHandlerMapping() {
			SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
			mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
          	//所有  **/favicon.ico 
			mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
					faviconRequestHandler()));
			return mapping;
		}

		@Bean
		public ResourceHttpRequestHandler faviconRequestHandler() {
			ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
			requestHandler
					.setLocations(this.resourceProperties.getFaviconLocations());
			return requestHandler;
		}

	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
1）、所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找資源；

webjars：以jar包的方式引入靜態資源；

http://www.webjars.org/

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-5JYSuFhY-1597758540528)(images/搜狗截圖20180203181751.png)]

localhost:8080/webjars/jquery/3.3.1/jquery.js

在訪問的時候只需要寫webjars下面資源的名稱即可

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

1
2
3
4
5
6
2）、"/**" 訪問當前專案的任何資源，都去（靜態資源的資料夾）找對映

"classpath:/META-INF/resources/",
"classpath:/resources/",
"classpath:/static/",
"classpath:/public/"
"/"：當前專案的根路徑
1
2
3
4
5
localhost:8080/abc === 去靜態資原始檔夾裡面找abc

3）、歡迎頁；靜態資原始檔夾下的所有index.html頁面；被"/**"對映；

localhost:8080/ 找index頁面

4）、所有的 **/favicon.ico 都是在靜態資原始檔下找；

3、模板引擎
JSP、Velocity、Freemarker、Thymeleaf

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-wDcZFBnq-1597758540529)(images/template-engine.png)]

SpringBoot推薦的Thymeleaf；

語法更簡單，功能更強大；

1、引入thymeleaf；

org.springframework.boot
spring-boot-starter-thymeleaf
2.1.6

切換thymeleaf版本

<thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>

<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>

1
2
3
4
5
6
7
8
9
10
11
12
2、Thymeleaf使用
@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {

private static final Charset DEFAULT_ENCODING = Charset.forName("UTF-8");

private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");

public static final String DEFAULT_PREFIX = "classpath:/templates/";

public static final String DEFAULT_SUFFIX = ".html";
//

1
2
3
4
5
6
7
8
9
10
11
只要我們把HTML頁面放在classpath:/templates/，thymeleaf就能自動渲染；

使用：

1、匯入thymeleaf的名稱空間

1 2、使用thymeleaf語法； Title

成功！

這是顯示歡迎資訊 1 2 3 4 5 6 7 8 9 10 11 12 3、語法規則 1）、th:text；改變當前元素裡面的文字內容；

th：任意html屬性；來替換原生屬性的值

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-1eieXikN-1597758540530)(images/2018-02-04_123955.png)]

2）、表示式？

Simple expressions:（表示式語法）
Variable Expressions: ${...}：獲取變數值；OGNL；
1）、獲取物件的屬性、呼叫方法
2）、使用內建的基本物件：
#ctx : the context object.
#vars: the context variables.
#locale : the context locale.
#request : (only in Web Contexts) the HttpServletRequest object.
#response : (only in Web Contexts) the HttpServletResponse object.
#session : (only in Web Contexts) the HttpSession object.
#servletContext : (only in Web Contexts) the ServletContext object.

            ${session.foo}
        3）、內建的一些工具物件：

execInfo : information about the template being processed.

messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.

uris : methods for escaping parts of URLs/URIs

conversions : methods for executing the configured conversion service (if any).

dates : methods for java.util.Date objects: formatting, component extraction, etc.

calendars : analogous to #dates , but for java.util.Calendar objects.

numbers : methods for formatting numeric objects.

strings : methods for String objects: contains, startsWith, prepending/appending, etc.

objects : methods for objects in general.

bools : methods for boolean evaluation.

arrays : methods for arrays.

lists : methods for lists.

sets : methods for sets.

maps : methods for maps.

aggregates : methods for creating aggregates on arrays or collections.

ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).

Selection Variable Expressions: *{...}：選擇表示式：和${}在功能上是一樣；
	補充：配合 th:object="${session.user}：

Name: Sebastian.

Surname: Pepper.

Nationality: Saturn.

Message Expressions: #{...}：獲取國際化內容
Link URL Expressions: @{...}：定義URL；
		@{/order/process(execId=${execId},execType='FAST')}
Fragment Expressions: ~{...}：片段引用表示式
		<div th:insert="~{commons :: main}">...</div>

Literals（字面量）
Text literals: 'one text' , 'Another one!' ,…
Number literals: 0 , 34 , 3.0 , 12.3 ,…
Boolean literals: true , false
Null literal: null
Literal tokens: one , sometext , main ,…
Text operations:（文字操作）
String concatenation: +
Literal substitutions: |The name is ${name}|
Arithmetic operations:（數學運算）
Binary operators: + , - , * , / , %
Minus sign (unary operator): -
Boolean operations:（布林運算）
Binary operators: and , or
Boolean negation (unary operator): ! , not
Comparisons and equality:（比較運算）
Comparators: > , < , >= , <= ( gt , lt , ge , le )
Equality operators: == , != ( eq , ne )
Conditional operators:條件運算（三元運算子）
If-then: (if) ? (then)
If-then-else: (if) ? (then) : (else)
Default: (value) ?: (defaultvalue)
Special tokens:
No-Operation: _
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
4、SpringMVC自動配置
https://docs.spring.io/spring-boot/docs/1.5.10.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications

Spring MVC auto-configuration
Spring Boot 自動配置好了SpringMVC

以下是SpringBoot對SpringMVC的預設配置:（WebMvcAutoConfiguration）

Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans.

自動配置了ViewResolver（檢視解析器：根據方法的返回值得到檢視物件（View），檢視物件決定如何渲染（轉發？重定向？））
ContentNegotiatingViewResolver：組合所有的檢視解析器的；
如何定製：我們可以自己給容器中新增一個檢視解析器；自動的將其組合進來；
Support for serving static resources, including support for WebJars (see below).靜態資原始檔夾路徑,webjars

Static index.html support. 靜態首頁訪問

Custom Favicon support (see below). favicon.ico

自動註冊了 of Converter, GenericConverter, Formatter beans.

Converter：轉換器； public String hello(User user)：型別轉換使用Converter
Formatter 格式化器； 2017.12.17===Date；
@Bean
@ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")//在檔案中配置日期格式化的規則
public Formatter dateFormatter() {
return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化元件
}
1
2
3
4
5
自己新增的格式化器轉換器，我們只需要放在容器中即可

Support for HttpMessageConverters (see below).

HttpMessageConverter：SpringMVC用來轉換Http請求和響應的；User—Json；

HttpMessageConverters 是從容器中確定；獲取所有的HttpMessageConverter；

自己給容器中新增HttpMessageConverter，只需要將自己的元件註冊容器中（@Bean,@Component）

Automatic registration of MessageCodesResolver (see below).定義錯誤程式碼生成規則

Automatic use of a ConfigurableWebBindingInitializer bean (see below).

我們可以配置一個ConfigurableWebBindingInitializer來替換預設的；（新增到容器）

初始化WebDataBinder；
請求資料=====JavaBean；
1
2
org.springframework.boot.autoconfigure.web：web的所有自動場景；

If you want to keep Spring Boot MVC features, and you just want to add additional MVC configuration (interceptors, formatters, view controllers etc.) you can add your own @Configuration class of type WebMvcConfigurerAdapter, but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter or ExceptionHandlerExceptionResolver you can declare a WebMvcRegistrationsAdapter instance providing such components.

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

2、擴充套件SpringMVC
<mvc:view-controller path="/hello" view-name="success"/>
mvc:interceptors
mvc:interceptor
<mvc:mapping path="/hello"/>

</mvc:interceptor>
</mvc:interceptors>
1
2
3
4
5
6
7
編寫一個配置類（@Configuration），是WebMvcConfigurerAdapter型別；不能標註@EnableWebMvc;

既保留了所有的自動配置，也能用我們擴充套件的配置；

//使用WebMvcConfigurerAdapter可以來擴充套件SpringMVC的功能
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

@Override
public void addViewControllers(ViewControllerRegistry registry) {
   // super.addViewControllers(registry);
    //瀏覽器傳送 /atguigu 請求來到 success
    registry.addViewController("/atguigu").setViewName("success");
}

}
1
2
3
4
5
6
7
8
9
10
11
原理：

1）、WebMvcAutoConfiguration是SpringMVC的自動配置類

2）、在做其他自動配置時會匯入；@Import(EnableWebMvcConfiguration.class)

@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
  private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

 //從容器中獲取所有的WebMvcConfigurer
  @Autowired(required = false)
  public void setConfigurers(List<WebMvcConfigurer> configurers) {
      if (!CollectionUtils.isEmpty(configurers)) {
          this.configurers.addWebMvcConfigurers(configurers);
        	//一個參考實現；將所有的WebMvcConfigurer相關配置都來一起呼叫；  
        	@Override
         // public void addViewControllers(ViewControllerRegistry registry) {
          //    for (WebMvcConfigurer delegate : this.delegates) {
           //       delegate.addViewControllers(registry);
           //   }
          }
      }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
3）、容器中所有的WebMvcConfigurer都會一起起作用；

4）、我們的配置類也會被呼叫；

效果：SpringMVC的自動配置和我們的擴充套件配置都會起作用；

3、全面接管SpringMVC；
SpringBoot對SpringMVC的自動配置不需要了，所有都是我們自己配置；所有的SpringMVC的自動配置都失效了

我們需要在配置類中新增@EnableWebMvc即可；

//使用WebMvcConfigurerAdapter可以來擴充套件SpringMVC的功能
@EnableWebMvc
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

@Override
public void addViewControllers(ViewControllerRegistry registry) {
   // super.addViewControllers(registry);
    //瀏覽器傳送 /atguigu 請求來到 success
    registry.addViewController("/atguigu").setViewName("success");
}

}
1
2
3
4
5
6
7
8
9
10
11
12
原理：

為什麼@EnableWebMvc自動配置就失效了；

1）@EnableWebMvc的核心

@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
1
2
2）、

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
1
2
3）、

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
WebMvcConfigurerAdapter.class })
//容器中沒有這個元件的時候，這個自動配置類才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
1
2
3
4
5
6
7
8
9
10
4）、@EnableWebMvc將WebMvcConfigurationSupport元件匯入進來；

5）、匯入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；

5、如何修改SpringBoot的預設配置
模式：

1）、SpringBoot在自動配置很多元件的時候，先看容器中有沒有使用者自己配置的（@Bean、@Component）如果有就用使用者配置的，如果沒有，才自動配置；如果有些元件可以有多個（ViewResolver）將使用者配置的和自己預設的組合起來；

2）、在SpringBoot中會有非常多的xxxConfigurer幫助我們進行擴充套件配置

3）、在SpringBoot中會有很多的xxxCustomizer幫助我們進行定製配置

6、RestfulCRUD
1）、預設訪問首頁

//使用WebMvcConfigurerAdapter可以來擴充套件SpringMVC的功能
//@EnableWebMvc 不要接管SpringMVC
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

@Override
public void addViewControllers(ViewControllerRegistry registry) {
   // super.addViewControllers(registry);
    //瀏覽器傳送 /atguigu 請求來到 success
    registry.addViewController("/atguigu").setViewName("success");
}

//所有的WebMvcConfigurerAdapter元件都會一起起作用
@Bean //將元件註冊在容器
public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
    WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
        @Override
        public void addViewControllers(ViewControllerRegistry registry) {
            registry.addViewController("/").setViewName("login");
            registry.addViewController("/index.html").setViewName("login");
        }
    };
    return adapter;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2）、國際化
1）、編寫國際化配置檔案；

2）、使用ResourceBundleMessageSource管理國際化資原始檔

3）、在頁面使用fmt:message取出國際化內容

步驟：

1）、編寫國際化配置檔案，抽取頁面需要顯示的國際化訊息

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-UVZLWB6i-1597758540531)(images/搜狗截圖20180211130721.png)]

2）、SpringBoot自動配置好了管理國際化資原始檔的元件；

@ConfigurationProperties(prefix = "spring.messages")
public class MessageSourceAutoConfiguration {

/**
 * Comma-separated list of basenames (essentially a fully-qualified classpath
 * location), each following the ResourceBundle convention with relaxed support for
 * slash based locations. If it doesn't contain a package qualifier (such as
 * "org.mypackage"), it will be resolved from the classpath root.
 */
private String basename = "messages";  
//我們的配置檔案可以直接放在類路徑下叫messages.properties；

@Bean
public MessageSource messageSource() {
	ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
	if (StringUtils.hasText(this.basename)) {
        //設定國際化資原始檔的基礎名（去掉語言國家程式碼的）
		messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(
				StringUtils.trimAllWhitespace(this.basename)));
	}
	if (this.encoding != null) {
		messageSource.setDefaultEncoding(this.encoding.name());
	}
	messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);
	messageSource.setCacheSeconds(this.cacheSeconds);
	messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);
	return messageSource;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
3）、去頁面獲取國際化的值；

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-Pmss4rO4-1597758540532)(images/搜狗截圖20180211134506.png)]

Signin Template for Bootstrap

<body class="text-center">
	<form class="form-signin" action="dashboard.html">
		<img class="mb-4" th:src="@{/asserts/img/bootstrap-solid.svg}" src="asserts/img/bootstrap-solid.svg" alt="" width="72" height="72">
		<h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign in</h1>
		<label class="sr-only" th:text="#{login.username}">Username</label>
		<input type="text" class="form-control" placeholder="Username" th:placeholder="#{login.username}" required="" autofocus="">
		<label class="sr-only" th:text="#{login.password}">Password</label>
		<input type="password" class="form-control" placeholder="Password" th:placeholder="#{login.password}" required="">
		<div class="checkbox mb-3">
			<label>
      		<input type="checkbox" value="remember-me"/> [[#{login.remember}]]
    </label>
		</div>
		<button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign in</button>
		<p class="mt-5 mb-3 text-muted">© 2017-2018</p>
		<a class="btn btn-sm">中文</a>
		<a class="btn btn-sm">English</a>
	</form>

</body>

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 效果：根據瀏覽器語言設定的資訊切換了國際化；

原理：

國際化Locale（區域資訊物件）；LocaleResolver（獲取區域資訊物件）；

	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
	public LocaleResolver localeResolver() {
		if (this.mvcProperties
				.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
			return new FixedLocaleResolver(this.mvcProperties.getLocale());
		}
		AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
		localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
		return localeResolver;
	}

預設的就是根據請求頭帶來的區域資訊獲取Locale進行國際化
1
2
3
4
5
6
7
8
9
10
11
12
13
4）、點選連結切換國際化

/**

可以在連線上攜帶區域資訊
*/
public class MyLocaleResolver implements LocaleResolver {

@Override
public Locale resolveLocale(HttpServletRequest request) {
String l = request.getParameter("l");
Locale locale = Locale.getDefault();
if(!StringUtils.isEmpty(l)){
String[] split = l.split("_");
locale = new Locale(split[0],split[1]);
}
return locale;
}

@Override
public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {

}
}

@Bean
public LocaleResolver localeResolver(){
return new MyLocaleResolver();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
3）、登陸
開發期間模板引擎頁面修改以後，要實時生效

1）、禁用模板引擎的快取

禁用快取

spring.thymeleaf.cache=false
1
2
2）、頁面修改完成以後ctrl+f9：重新編譯；

登陸錯誤訊息的顯示

1 4）、攔截器進行登陸檢查攔截器

/**

登陸檢查，
*/
public class LoginHandlerInterceptor implements HandlerInterceptor {
//目標方法執行之前
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
Object user = request.getSession().getAttribute("loginUser");
if(user == null){
//未登陸，返回登陸頁面
request.setAttribute("msg","沒有許可權請先登陸");
request.getRequestDispatcher("/index.html").forward(request,response);
return false;
}else{
//已登陸，放行請求
return true;
}

}

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

}

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
註冊攔截器

//所有的WebMvcConfigurerAdapter元件都會一起起作用
@Bean //將元件註冊在容器
public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
@Override
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/").setViewName("login");
registry.addViewController("/index.html").setViewName("login");
registry.addViewController("/main.html").setViewName("dashboard");
}

        //註冊攔截器
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            //super.addInterceptors(registry);
            //靜態資源；  *.css , *.js
            //SpringBoot已經做好了靜態資源對映
            registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
                    .excludePathPatterns("/index.html","/","/user/login");
        }
    };
    return adapter;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
5）、CRUD-員工列表
實驗要求：

1）、RestfulCRUD：CRUD滿足Rest風格；

URI： /資源名稱/資源標識 HTTP請求方式區分對資源CRUD操作

普通CRUD（uri來區分操作） RestfulCRUD
查詢 getEmp emp—GET
新增 addEmp?xxx emp—POST
修改 updateEmp?id=xxx&xxx=xx emp/{id}—PUT
刪除 deleteEmp?id=1 emp/{id}—DELETE
2）、實驗的請求架構;

實驗功能請求URI 請求方式
查詢所有員工 emps GET
查詢某個員工(來到修改頁面) emp/1 GET
來到新增頁面 emp GET
新增員工 emp POST
來到修改頁面（查出員工進行資訊回顯） emp/1 GET
修改員工 emp PUT
刪除員工 emp/1 DELETE
3）、員工列表：

thymeleaf公共頁面元素抽取
1、抽取公共片段

2、引入公共片段

~{templatename::selector}：模板名::選擇器 ~{templatename::fragmentname}:模板名::片段名

3、預設效果：
insert的公共片段在div標籤中
如果使用th:insert等屬性進行引入，可以不用寫~{}：
行內寫法可以加上：[[_{}]];[({})]；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
三種引入公共片段的th屬性：

th:insert：將公共片段整個插入到宣告引入的元素中

th:replace：將宣告引入的元素替換為公共片段

th:include：將被引入的片段的內容包含進這個標籤中

引入方式

效果

Dashboard (current)

2017-12-12；2017/12/12；2017.12.12；

日期的格式化；SpringMVC將頁面提交的值需要轉換為指定的型別;

2017-12-12—Date；型別轉換，格式化;

預設日期是按照/的方式；

7）、CRUD-員工修改
修改新增二合一表單

編輯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
7、錯誤處理機制
1）、SpringBoot預設的錯誤處理機制
預設效果：

1）、瀏覽器，返回一個預設的錯誤頁面

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-3EQSkgLP-1597758540534)(images/搜狗截圖20180226173408.png)]

瀏覽器傳送請求的請求頭：

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-BkixEzKO-1597758540534)(images/搜狗截圖20180226180347.png)]

2）、如果是其他客戶端，預設響應一個json資料

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-nNlW4ipl-1597758540535)(images/搜狗截圖20180226173527.png)]

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-Imqv6a9G-1597758540536)(images/搜狗截圖20180226180504.png)]

原理：

可以參照ErrorMvcAutoConfiguration；錯誤處理的自動配置；

給容器中添加了以下元件
1
1、DefaultErrorAttributes：

幫我們在頁面共享資訊；
@Override
public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
boolean includeStackTrace) {
Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
errorAttributes.put("timestamp", new Date());
addStatus(errorAttributes, requestAttributes);
addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
addPath(errorAttributes, requestAttributes);
return errorAttributes;
}
1
2
3
4
5
6
7
8
9
10
11
2、BasicErrorController：處理預設/error請求

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {

@RequestMapping(produces = "text/html")//產生html型別的資料；瀏覽器傳送的請求來到這個方法處理
public ModelAndView errorHtml(HttpServletRequest request,
		HttpServletResponse response) {
	HttpStatus status = getStatus(request);
	Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
			request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
	response.setStatus(status.value());
    
    //去哪個頁面作為錯誤頁面；包含頁面地址和頁面內容
	ModelAndView modelAndView = resolveErrorView(request, response, status, model);
	return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
}

@RequestMapping
@ResponseBody    //產生json資料，其他客戶端來到這個方法處理；
public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
	Map<String, Object> body = getErrorAttributes(request,
			isIncludeStackTrace(request, MediaType.ALL));
	HttpStatus status = getStatus(request);
	return new ResponseEntity<Map<String, Object>>(body, status);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
3、ErrorPageCustomizer：

@Value("${error.path:/error}")
private String path = "/error";  系統出現錯誤以後來到error請求進行處理；（web.xml註冊的錯誤頁面規則）

1
2
4、DefaultErrorViewResolver：

@Override
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
Map<String, Object> model) {
ModelAndView modelAndView = resolve(String.valueOf(status), model);
if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
}
return modelAndView;
}

private ModelAndView resolve(String viewName, Map<String, Object> model) {
    //預設SpringBoot可以去找到一個頁面？  error/404
	String errorViewName = "error/" + viewName;
    
    //模板引擎可以解析這個頁面地址就用模板引擎解析
	TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
			.getProvider(errorViewName, this.applicationContext);
	if (provider != null) {
        //模板引擎可用的情況下返回到errorViewName指定的檢視地址
		return new ModelAndView(errorViewName, model);
	}
    //模板引擎不可用，就在靜態資原始檔夾下找errorViewName對應的頁面   error/404.html
	return resolveResource(errorViewName, model);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
步驟：

一但系統出現4xx或者5xx之類的錯誤；ErrorPageCustomizer就會生效（定製錯誤的響應規則）；就會來到/error請求；就會被BasicErrorController處理；

1）響應頁面；去哪個頁面是由DefaultErrorViewResolver解析得到的；

protected ModelAndView resolveErrorView(HttpServletRequest request,
HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
//所有的ErrorViewResolver得到ModelAndView
for (ErrorViewResolver resolver : this.errorViewResolvers) {
ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
if (modelAndView != null) {
return modelAndView;
}
}
return null;
}
1
2
3
4
5
6
7
8
9
10
11
2）、如果定製錯誤響應：
1）、如何定製錯誤的頁面；
1）、有模板引擎的情況下；error/狀態碼; 【將錯誤頁面命名為錯誤狀態碼.html 放在模板引擎資料夾裡面的 error資料夾下】，發生此狀態碼的錯誤就會來到對應的頁面；

我們可以使用4xx和5xx作為錯誤頁面的檔名來匹配這種型別的所有錯誤，精確優先（優先尋找精確的狀態碼.html）；

頁面能獲取的資訊；

timestamp：時間戳

status：狀態碼

error：錯誤提示

exception：異常物件

message：異常訊息

errors：JSR303資料校驗的錯誤都在這裡

2）、沒有模板引擎（模板引擎找不到這個錯誤頁面），靜態資原始檔夾下找；

3）、以上都沒有錯誤頁面，就是預設來到SpringBoot預設的錯誤提示頁面；

2）、如何定製錯誤的json資料；
1）、自定義異常處理&返回定製json資料；

@ControllerAdvice
public class MyExceptionHandler {

@ResponseBody
@ExceptionHandler(UserNotExistException.class)
public Map<String,Object> handleException(Exception e){
    Map<String,Object> map = new HashMap<>();
    map.put("code","user.notexist");
    map.put("message",e.getMessage());
    return map;
}

}
//沒有自適應效果...
1
2
3
4
5
6
7
8
9
10
11
12
13
2）、轉發到/error進行自適應響應效果處理

@ExceptionHandler(UserNotExistException.class)
public String handleException(Exception e, HttpServletRequest request){
Map<String,Object> map = new HashMap<>();
//傳入我們自己的錯誤狀態碼 4xx 5xx，否則就不會進入定製錯誤頁面的解析流程
/**
* Integer statusCode = (Integer) request
.getAttribute("javax.servlet.error.status_code");
*/
request.setAttribute("javax.servlet.error.status_code",500);
map.put("code","user.notexist");
map.put("message",e.getMessage());
//轉發到/error
return "forward:/error";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
3）、將我們的定製資料攜帶出去；
出現錯誤以後，會來到/error請求，會被BasicErrorController處理，響應出去可以獲取的資料是由getErrorAttributes得到的（是AbstractErrorController（ErrorController）規定的方法）；

1、完全來編寫一個ErrorController的實現類【或者是編寫AbstractErrorController的子類】，放在容器中；

2、頁面上能用的資料，或者是json返回能用的資料都是通過errorAttributes.getErrorAttributes得到；

容器中DefaultErrorAttributes.getErrorAttributes()；預設進行資料處理的；

自定義ErrorAttributes

//給容器中加入我們自己定義的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

@Override
public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
    Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
    map.put("company","atguigu");
    return map;
}

}
1
2
3
4
5
6
7
8
9
10
11
最終的效果：響應是自適應的，可以通過定製ErrorAttributes改變需要返回的內容，

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-eOR3x9Za-1597758540537)(images/搜狗截圖20180228135513.png)]

8、配置嵌入式Servlet容器
SpringBoot預設使用Tomcat作為嵌入式的Servlet容器；

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-IBIPdOAm-1597758540538)(images/搜狗截圖20180301142915.png)]

問題？

1）、如何定製和修改Servlet容器的相關配置；
1、修改和server有關的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；

server.port=8081
server.context-path=/crud

server.tomcat.uri-encoding=UTF-8

//通用的Servlet容器設定
server.xxx
//Tomcat的設定
server.tomcat.xxx
1
2
3
4
5
6
7
8
9
2、編寫一個EmbeddedServletContainerCustomizer：嵌入式的Servlet容器的定製器；來修改Servlet容器的配置

@Bean //一定要將這個定製器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
return new EmbeddedServletContainerCustomizer() {

    //定製嵌入式的Servlet容器相關的規則
    @Override
    public void customize(ConfigurableEmbeddedServletContainer container) {
        container.setPort(8083);
    }
};

}
1
2
3
4
5
6
7
8
9
10
11
2）、註冊Servlet三大元件【Servlet、Filter、Listener】
由於SpringBoot預設是以jar包的方式啟動嵌入式的Servlet容器來啟動SpringBoot的web應用，沒有web.xml檔案。

註冊三大元件用以下方式

ServletRegistrationBean

//註冊三大元件
@Bean
public ServletRegistrationBean myServlet(){
ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
return registrationBean;
}

1
2
3
4
5
6
7
FilterRegistrationBean

@Bean
public FilterRegistrationBean myFilter(){
FilterRegistrationBean registrationBean = new FilterRegistrationBean();
registrationBean.setFilter(new MyFilter());
registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
return registrationBean;
}
1
2
3
4
5
6
7
ServletListenerRegistrationBean

@Bean
public ServletListenerRegistrationBean myListener(){
ServletListenerRegistrationBean registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
return registrationBean;
}
1
2
3
4
5
SpringBoot幫我們自動SpringMVC的時候，自動的註冊SpringMVC的前端控制器；DIspatcherServlet；

DispatcherServletAutoConfiguration中：

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean dispatcherServletRegistration(
DispatcherServlet dispatcherServlet) {
ServletRegistrationBean registration = new ServletRegistrationBean(
dispatcherServlet, this.serverProperties.getServletMapping());
//預設攔截： / 所有請求；包靜態資源，但是不攔截jsp請求； /*會攔截jsp
//可以通過server.servletPath來修改SpringMVC前端控制器預設攔截的請求路徑

registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
registration.setLoadOnStartup(
this.webMvcProperties.getServlet().getLoadOnStartup());
if (this.multipartConfig != null) {
registration.setMultipartConfig(this.multipartConfig);
}
return registration;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2）、SpringBoot能不能支援其他的Servlet容器；

3）、替換為其他嵌入式Servlet容器
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-JhmdaVfw-1597758540539)(images/搜狗截圖20180302114401.png)]

預設支援：

Tomcat（預設使用）

org.springframework.boot spring-boot-starter-web 引入web模組預設就是使用嵌入式的Tomcat作為Servlet容器；

org.springframework.boot spring-boot-starter-web spring-boot-starter-tomcat org.springframework.boot

spring-boot-starter-jetty org.springframework.boot

org.springframework.boot spring-boot-starter-web spring-boot-starter-tomcat org.springframework.boot

spring-boot-starter-undertow org.springframework.boot

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//匯入BeanPostProcessorsRegistrar：Spring註解版；給容器中匯入一些元件
//匯入了EmbeddedServletContainerCustomizerBeanPostProcessor：
//後置處理器：bean初始化前後（建立完物件，還沒賦值賦值）執行初始化工作
public class EmbeddedServletContainerAutoConfiguration {

@Configuration
@ConditionalOnClass({ Servlet.class, Tomcat.class })//判斷當前是否引入了Tomcat依賴；
@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)//判斷當前容器沒有使用者自己定義EmbeddedServletContainerFactory：嵌入式的Servlet容器工廠；作用：建立嵌入式的Servlet容器
public static class EmbeddedTomcat {

	@Bean
	public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
		return new TomcatEmbeddedServletContainerFactory();
	}

}

/**
 * Nested configuration if Jetty is being used.
 */
@Configuration
@ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
		WebAppContext.class })
@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
public static class EmbeddedJetty {

	@Bean
	public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
		return new JettyEmbeddedServletContainerFactory();
	}

}

/**
 * Nested configuration if Undertow is being used.
 */
@Configuration
@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
public static class EmbeddedUndertow {

	@Bean
	public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
		return new UndertowEmbeddedServletContainerFactory();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
1）、EmbeddedServletContainerFactory（嵌入式Servlet容器工廠）

public interface EmbeddedServletContainerFactory {

//獲取嵌入式的Servlet容器
EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer... initializers);

}
1
2
3
4
5
6
7
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-ptUkWpaL-1597758540540)(images/搜狗截圖20180302144835.png)]

2）、EmbeddedServletContainer：（嵌入式的Servlet容器）

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-xVXvva8J-1597758540540)(images/搜狗截圖20180302144910.png)]

3）、以TomcatEmbeddedServletContainerFactory為例

@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
ServletContextInitializer... initializers) {
//建立一個Tomcat
Tomcat tomcat = new Tomcat();

//配置Tomcat的基本環節

File baseDir = (this.baseDirectory != null ? this.baseDirectory: createTempDir("tomcat"));
tomcat.setBaseDir(baseDir.getAbsolutePath());
Connector connector = new Connector(this.protocol);
tomcat.getService().addConnector(connector);
customizeConnector(connector);
tomcat.setConnector(connector);
tomcat.getHost().setAutoDeploy(false);
configureEngine(tomcat.getEngine());
for (Connector additionalConnector : this.additionalTomcatConnectors) {
tomcat.getService().addConnector(additionalConnector);
}
prepareContext(tomcat.getHost(), initializers);

//將配置好的Tomcat傳入進去，返回一個EmbeddedServletContainer；並且啟動Tomcat伺服器

return getTomcatEmbeddedServletContainer(tomcat);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
4）、我們對嵌入式容器的配置修改是怎麼生效？

ServerProperties、EmbeddedServletContainerCustomizer
1
EmbeddedServletContainerCustomizer：定製器幫我們修改了Servlet容器的配置？

怎麼修改的原理？

5）、容器中匯入了EmbeddedServletContainerCustomizerBeanPostProcessor

//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
//如果當前初始化的是一個ConfigurableEmbeddedServletContainer型別的元件
if (bean instanceof ConfigurableEmbeddedServletContainer) {
//
postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
}
return bean;
}

private void postProcessBeforeInitialization(
ConfigurableEmbeddedServletContainer bean) {
//獲取所有的定製器，呼叫每一個定製器的customize方法來給Servlet容器進行屬性賦值；
for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
customizer.customize(bean);
}
}

private Collection getCustomizers() {
if (this.customizers == null) {
// Look up does not include the parent context
this.customizers = new ArrayList(
this.beanFactory
//從容器中獲取所有這葛型別的元件：EmbeddedServletContainerCustomizer
//定製Servlet容器，給容器中可以新增一個EmbeddedServletContainerCustomizer型別的元件
.getBeansOfType(EmbeddedServletContainerCustomizer.class,
false, false)
.values());
Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
this.customizers = Collections.unmodifiableList(this.customizers);
}
return this.customizers;
}

ServerProperties也是定製器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
步驟：

1）、SpringBoot根據匯入的依賴情況，給容器中新增相應的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

2）、容器中某個元件要建立物件就會驚動後置處理器；EmbeddedServletContainerCustomizerBeanPostProcessor；

只要是嵌入式的Servlet容器工廠，後置處理器就工作；

3）、後置處理器，從容器中獲取所有的EmbeddedServletContainerCustomizer，呼叫定製器的定製方法

5）、嵌入式Servlet容器啟動原理；

什麼時候建立嵌入式的Servlet容器工廠？什麼時候獲取嵌入式的Servlet容器並啟動Tomcat；

獲取嵌入式的Servlet容器工廠：

1）、SpringBoot應用啟動執行run方法

2）、refreshContext(context);SpringBoot重新整理IOC容器【建立IOC容器物件，並初始化容器，建立容器中的每一個元件】；如果是web應用建立AnnotationConfigEmbeddedWebApplicationContext，否則：AnnotationConfigApplicationContext

3）、refresh(context);重新整理剛才建立好的ioc容器；

public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();

  // Tell the subclass to refresh the internal bean factory.
  ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

  // Prepare the bean factory for use in this context.
  prepareBeanFactory(beanFactory);

  try {
     // Allows post-processing of the bean factory in context subclasses.
     postProcessBeanFactory(beanFactory);

     // Invoke factory processors registered as beans in the context.
     invokeBeanFactoryPostProcessors(beanFactory);

     // Register bean processors that intercept bean creation.
     registerBeanPostProcessors(beanFactory);

     // Initialize message source for this context.
     initMessageSource();

     // Initialize event multicaster for this context.
     initApplicationEventMulticaster();

     // Initialize other special beans in specific context subclasses.
     onRefresh();

     // Check for listener beans and register them.
     registerListeners();

     // Instantiate all remaining (non-lazy-init) singletons.
     finishBeanFactoryInitialization(beanFactory);

     // Last step: publish corresponding event.
     finishRefresh();
  }

  catch (BeansException ex) {
     if (logger.isWarnEnabled()) {
        logger.warn("Exception encountered during context initialization - " +
              "cancelling refresh attempt: " + ex);
     }

     // Destroy already created singletons to avoid dangling resources.
     destroyBeans();

     // Reset 'active' flag.
     cancelRefresh(ex);

     // Propagate exception to caller.
     throw ex;
  }

  finally {
     // Reset common introspection caches in Spring's core, since we
     // might not ever need metadata for singleton beans anymore...
     resetCommonCaches();
  }

}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
4）、 onRefresh(); web的ioc容器重寫了onRefresh方法

5）、webioc容器會建立嵌入式的Servlet容器；createEmbeddedServletContainer();

6）、獲取嵌入式的Servlet容器工廠：

EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

從ioc容器中獲取EmbeddedServletContainerFactory 元件；TomcatEmbeddedServletContainerFactory建立物件，後置處理器一看是這個物件，就獲取所有的定製器來先定製Servlet容器的相關配置；

7）、使用容器工廠獲取嵌入式的Servlet容器：this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());

8）、嵌入式的Servlet容器建立物件並啟動Servlet容器；

先啟動嵌入式的Servlet容器，再將ioc容器中剩下沒有創建出的物件獲取出來；

IOC容器啟動建立嵌入式的Servlet容器

9、使用外接的Servlet容器
嵌入式Servlet容器：應用打成可執行的jar

優點：簡單、便攜；

缺點：預設不支援JSP、優化定製比較複雜（使用定製器【ServerProperties、自定義EmbeddedServletContainerCustomizer】，自己編寫嵌入式Servlet容器的建立工廠【EmbeddedServletContainerFactory】）；

外接的Servlet容器：外面安裝Tomcat—應用war包的方式打包；

步驟
1）、必須建立一個war專案；（利用idea建立好目錄結構）

2）、將嵌入式的Tomcat指定為provided；

org.springframework.boot spring-boot-starter-tomcat provided

public class ServletInitializer extends SpringBootServletInitializer {

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
//傳入SpringBoot應用的主程式
return application.sources(SpringBoot04WebJspApplication.class);
}

}
1
2
3
4
5
6
7
8
9
4）、啟動伺服器就可以使用；

原理
jar包：執行SpringBoot主類的main方法，啟動ioc容器，建立嵌入式的Servlet容器；

war包：啟動伺服器，伺服器啟動SpringBoot應用【SpringBootServletInitializer】，啟動ioc容器；

servlet3.0（Spring註解版）：

8.2.4 Shared libraries / runtimes pluggability：

規則：

1）、伺服器啟動（web應用啟動）會建立當前web應用裡面每一個jar包裡面ServletContainerInitializer例項：

2）、ServletContainerInitializer的實現放在jar包的META-INF/services資料夾下，有一個名為javax.servlet.ServletContainerInitializer的檔案，內容就是ServletContainerInitializer的實現類的全類名

3）、還可以使用@HandlesTypes，在應用啟動的時候載入我們感興趣的類；

流程：

1）、啟動Tomcat

2）、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META-INF\services\javax.servlet.ServletContainerInitializer：

Spring的web模組裡面有這個檔案：org.springframework.web.SpringServletContainerInitializer

3）、SpringServletContainerInitializer將@HandlesTypes(WebApplicationInitializer.class)標註的所有這個型別的類都傳入到onStartup方法的Set<Class<?>>；為這些WebApplicationInitializer型別的類建立例項；

4）、每一個WebApplicationInitializer都呼叫自己的onStartup；

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-LNBJ9fvm-1597758540541)(images/搜狗截圖20180302221835.png)]

5）、相當於我們的SpringBootServletInitializer的類會被建立物件，並執行onStartup方法

6）、SpringBootServletInitializer例項執行onStartup的時候會createRootApplicationContext；建立容器

protected WebApplicationContext createRootApplicationContext(
ServletContext servletContext) {
//1、建立SpringApplicationBuilder
SpringApplicationBuilder builder = createSpringApplicationBuilder();
StandardServletEnvironment environment = new StandardServletEnvironment();
environment.initPropertySources(servletContext, null);
builder.environment(environment);
builder.main(getClass());
ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
if (parent != null) {
this.logger.info("Root context already created (using as parent).");
servletContext.setAttribute(
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
builder.initializers(new ParentContextApplicationContextInitializer(parent));
}
builder.initializers(
new ServletContextApplicationContextInitializer(servletContext));
builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);

//呼叫configure方法，子類重寫了這個方法，將SpringBoot的主程式類傳入了進來

builder = configure(builder);

//使用builder建立一個Spring應用

SpringApplication application = builder.build();
if (application.getSources().isEmpty() && AnnotationUtils
.findAnnotation(getClass(), Configuration.class) != null) {
application.getSources().add(getClass());
}
Assert.state(!application.getSources().isEmpty(),
"No SpringApplication sources have been defined. Either override the "
+ "configure method or add an @Configuration annotation");
// Ensure error pages are registered
if (this.registerErrorPageFilter) {
application.getSources().add(ErrorPageFilterConfiguration.class);
}
//啟動Spring應用
return run(application);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
7）、Spring的應用就啟動並且建立IOC容器

public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
configureHeadlessProperty();
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
Banner printedBanner = printBanner(environment);
context = createApplicationContext();
analyzers = new FailureAnalyzers(context);
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);

   //重新整理IOC容器
  refreshContext(context);
  afterRefresh(context, applicationArguments);
  listeners.finished(context, null);
  stopWatch.stop();
  if (this.logStartupInfo) {
     new StartupInfoLogger(this.mainApplicationClass)
           .logStarted(getApplicationLog(), stopWatch);
  }
  return context;

}
catch (Throwable ex) {
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
啟動Servlet容器，再啟動SpringBoot應用

五、Docker
1、簡介
Docker是一個開源的應用容器引擎；是一個輕量級容器技術；

Docker支援將軟體編譯成一個映象；然後在映象中各種軟體做好配置，將映象釋出出去，其他使用者可以直接使用這個映象；

執行中的這個映象稱為容器，容器啟動是非常快速的。

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-u047t5xG-1597758540542)(images/搜狗截圖20180303145450.png)]

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-QOsdVoL3-1597758540543)(images/搜狗截圖20180303145531.png)]

2、核心概念
docker主機(Host)：安裝了Docker程式的機器（Docker直接安裝在作業系統之上）；

docker客戶端(Client)：連線docker主機進行操作；

docker倉庫(Registry)：用來儲存各種打包好的軟體映象；

docker映象(Images)：軟體打包好的映象；放在docker倉庫中；

docker容器(Container)：映象啟動後的例項稱為一個容器；容器是獨立執行的一個或一組應用

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-3XQvx1kJ-1597758540544)(images/搜狗截圖20180303165113.png)]

使用Docker的步驟：

1）、安裝Docker

2）、去Docker倉庫找到這個軟體對應的映象；

3）、使用Docker執行這個映象，這個映象就會生成一個Docker容器；

4）、對容器的啟動停止就是對軟體的啟動停止；

3、安裝Docker
1）、安裝linux虛擬機器
1）、VMWare、VirtualBox（安裝）；

2）、匯入虛擬機器檔案centos7-atguigu.ova；

3）、雙擊啟動linux虛擬機器;使用 root/ 123456登陸

4）、使用客戶端連線linux伺服器進行命令操作；

5）、設定虛擬機器網路；

橋接網路=選好網絡卡==接入網線；

6）、設定好網路以後使用命令重啟虛擬機器的網路

service network restart
1
7）、檢視linux的ip地址

ip addr
1
8）、使用客戶端連線linux；

2）、在linux虛擬機器上安裝docker
步驟：

1、檢查核心版本，必須是3.10及以上
uname -r
2、安裝docker
yum install docker
3、輸入y確認安裝
4、啟動docker
[root@localhost ~]# systemctl start docker
[root@localhost ~]# docker -v
Docker version 1.12.6, build 3e8e77d/1.12.6
5、開機啟動docker
[root@localhost ~]# systemctl enable docker
Created symlink from /etc/systemd/system/multi-user.target.wants/docker.service to /usr/lib/systemd/system/docker.service.
6、停止docker
systemctl stop docker
1
2
3
4
5
6
7
8
9
10
11
12
13
14
4、Docker常用命令&操作
1）、映象操作
操作命令說明
檢索 docker search 關鍵字 eg：docker search redis 我們經常去docker hub上檢索映象的詳細資訊，如映象的TAG。
拉取 docker pull 映象名:tag :tag是可選的，tag表示標籤，多為軟體的版本，預設是latest
列表 docker images 檢視所有本地映象
刪除 docker rmi image-id 刪除指定的本地映象
https://hub.docker.com/

2）、容器操作
軟體映象（QQ安裝程式）----執行映象----產生一個容器（正在執行的軟體，執行的QQ）；

步驟：

1、搜尋映象
[root@localhost ~]# docker search tomcat
2、拉取映象
[root@localhost ~]# docker pull tomcat
3、根據映象啟動容器
docker run --name mytomcat -d tomcat:latest
4、docker ps
檢視執行中的容器
5、停止執行中的容器
docker stop 容器的id
6、檢視所有的容器
docker ps -a
7、啟動容器
docker start 容器id
8、刪除一個容器
docker rm 容器id
9、啟動一個做了埠對映的tomcat
[root@localhost ~]# docker run -d -p 8888:8080 tomcat
-d：後臺執行
-p: 將主機的埠對映到容器的一個埠主機埠:容器內部的埠

10、為了演示簡單關閉了linux的防火牆
service firewalld status ；檢視防火牆狀態
service firewalld stop：關閉防火牆
11、檢視容器的日誌
docker logs container-name/container-id

更多命令參看
https://docs.docker.com/engine/reference/commandline/docker/
可以參考每一個映象的文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
3）、安裝MySQL示例
docker pull mysql
1
錯誤的啟動

[root@localhost ~]# docker run --name mysql01 -d mysql
42f09819908bb72dd99ae19e792e0a5d03c48638421fa64cce5f8ba0f40f5846

mysql退出了
[root@localhost ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
42f09819908b mysql "docker-entrypoint.sh" 34 seconds ago Exited (1) 33 seconds ago mysql01
538bde63e500 tomcat "catalina.sh run" About an hour ago Exited (143) About an hour ago compassionate_
goldstine
c4f1ac60b3fc tomcat "catalina.sh run" About an hour ago Exited (143) About an hour ago lonely_fermi
81ec743a5271 tomcat "catalina.sh run" About an hour ago Exited (143) About an hour ago sick_ramanujan

//錯誤日誌
[root@localhost ~]# docker logs 42f09819908b
error: database is uninitialized and password option is not specified
You need to specify one of MYSQL_ROOT_PASSWORD, MYSQL_ALLOW_EMPTY_PASSWORD and MYSQL_RANDOM_ROOT_PASSWORD；這個三個引數必須指定一個
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
正確的啟動

[root@localhost ~]# docker run --name mysql01 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
b874c56bec49fb43024b3805ab51e9097da779f2f572c22c695305dedd684c5f
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
b874c56bec49 mysql "docker-entrypoint.sh" 4 seconds ago Up 3 seconds 3306/tcp mysql01
1
2
3
4
5
做了埠對映

[root@localhost ~]# docker run -p 3306:3306 --name mysql02 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
ad10e4bc5c6a0f61cbad43898de71d366117d120e39db651844c0e73863b9434
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
ad10e4bc5c6a mysql "docker-entrypoint.sh" 4 seconds ago Up 2 seconds 0.0.0.0:3306->3306/tcp mysql02
1
2
3
4
5
幾個其他的高階操作

docker run --name mysql03 -v /conf/mysql:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
把主機的/conf/mysql資料夾掛載到 mysqldocker容器的/etc/mysql/conf.d資料夾裡面
改mysql的配置檔案就只需要把mysql配置檔案放在自定義的資料夾下（/conf/mysql）

docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
指定mysql的一些配置引數
1
2
3
4
5
6
六、SpringBoot與資料訪問
1、JDBC

org.springframework.boot
spring-boot-starter-jdbc

mysql
mysql-connector-java
runtime

1
2
3
4
5
6
7
8
9
spring:
datasource:
username: root
password: 123456
url: jdbc:mysql://192.168.15.22:3306/jdbc
driver-class-name: com.mysql.jdbc.Driver
1
2
3
4
5
6
效果：

預設是用org.apache.tomcat.jdbc.pool.DataSource作為資料來源；

資料來源的相關配置都在DataSourceProperties裡面；

自動配置原理：

org.springframework.boot.autoconfigure.jdbc：

1、參考DataSourceConfiguration，根據配置建立資料來源，預設使用Tomcat連線池；可以使用spring.datasource.type指定自定義的資料來源型別；

2、SpringBoot預設可以支援；

org.apache.tomcat.jdbc.pool.DataSource、HikariDataSource、BasicDataSource、
1
3、自定義資料來源型別

/**

Generic DataSource configuration.
*/
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.type")
static class Generic {

@Bean
public DataSource dataSource(DataSourceProperties properties) {
//使用DataSourceBuilder建立資料來源，利用反射建立響應type的資料來源，並且繫結相關屬性
return properties.initializeDataSourceBuilder().build();
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
4、DataSourceInitializer：ApplicationListener；

作用：

1）、runSchemaScripts();執行建表語句；

2）、runDataScripts();執行插入資料的sql語句；

預設只需要將檔案命名為：

schema-.sql、data-.sql
預設規則：schema.sql，schema-all.sql；
可以使用
schema:
- classpath:department.sql
指定位置
1
2
3
4
5
6
5、操作資料庫：自動配置了JdbcTemplate操作資料庫

2、整合Druid資料來源
匯入druid資料來源
@Configuration
public class DruidConfig {

@ConfigurationProperties(prefix = "spring.datasource")
@Bean
public DataSource druid(){
   return  new DruidDataSource();
}

//配置Druid的監控
//1、配置一個管理後臺的Servlet
@Bean
public ServletRegistrationBean statViewServlet(){
    ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
    Map<String,String> initParams = new HashMap<>();

    initParams.put("loginUsername","admin");
    initParams.put("loginPassword","123456");
    initParams.put("allow","");//預設就是允許所有訪問
    initParams.put("deny","192.168.15.21");

    bean.setInitParameters(initParams);
    return bean;
}


//2、配置一個web監控的filter
@Bean
public FilterRegistrationBean webStatFilter(){
    FilterRegistrationBean bean = new FilterRegistrationBean();
    bean.setFilter(new WebStatFilter());

    Map<String,String> initParams = new HashMap<>();
    initParams.put("exclusions","*.js,*.css,/druid/*");

    bean.setInitParameters(initParams);

    bean.setUrlPatterns(Arrays.asList("/*"));

    return  bean;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
3、整合MyBatis

org.mybatis.spring.boot
mybatis-spring-boot-starter
1.3.1

1
2
3
4
5
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-ffBUMgG1-1597758540545)(images/搜狗截圖20180305194443.png)]

步驟：

1）、配置資料來源相關屬性（見上一節Druid）

2）、給資料庫建表

3）、建立JavaBean

4）、註解版
//指定這是一個操作資料庫的mapper
@Mapper
public interface DepartmentMapper {

@Select("select * from department where id=#{id}")
public Department getDeptById(Integer id);

@Delete("delete from department where id=#{id}")
public int deleteDeptById(Integer id);

@Options(useGeneratedKeys = true,keyProperty = "id")
@Insert("insert into department(departmentName) values(#{departmentName})")
public int insertDept(Department department);

@Update("update department set departmentName=#{departmentName} where id=#{id}")
public int updateDept(Department department);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
問題：

自定義MyBatis的配置規則；給容器中新增一個ConfigurationCustomizer；

@org.springframework.context.annotation.Configuration
public class MyBatisConfig {

@Bean
public ConfigurationCustomizer configurationCustomizer(){
    return new ConfigurationCustomizer(){

        @Override
        public void customize(Configuration configuration) {
            configuration.setMapUnderscoreToCamelCase(true);
        }
    };
}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
使用MapperScan批量掃描所有的Mapper介面；
@MapperScan(value = "com.atguigu.springboot.mapper")
@SpringBootApplication
public class SpringBoot06DataMybatisApplication {

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

}
1
2
3
4
5
6
7
8
9
5）、配置檔案版
mybatis:
config-location: classpath:mybatis/mybatis-config.xml 指定全域性配置檔案的位置
mapper-locations: classpath:mybatis/mapper/*.xml 指定sql對映檔案的位置
1
2
3
更多使用參照

http://www.mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/

4、整合SpringData JPA
1）、SpringData簡介
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-OfvT7dM1-1597758540546)(images/搜狗截圖20180306105412.png)]

2）、整合SpringData JPA
JPA:ORM（Object Relational Mapping）；

1）、編寫一個實體類（bean）和資料表進行對映，並且配置好對映關係；

//使用JPA註解配置對映關係
@Entity //告訴JPA這是一個實體類（和資料表對映的類）
@Table(name = "tbl_user") //@Table來指定和哪個資料表對應;如果省略預設表名就是user；
public class User {

@Id //這是一個主鍵
@GeneratedValue(strategy = GenerationType.IDENTITY)//自增主鍵
private Integer id;

@Column(name = "last_name",length = 50) //這是和資料表對應的一個列
private String lastName;
@Column //省略預設列名就是屬性名
private String email;

1
2
3
4
5
6
7
8
9
10
11
12
13
2）、編寫一個Dao介面來操作實體類對應的資料表（Repository）

//繼承JpaRepository來完成對資料庫的操作
public interface UserRepository extends JpaRepository<User,Integer> {
}

1
2
3
4
3）、基本的配置JpaProperties

spring:
jpa:
hibernate:

更新或者建立資料表結構

  ddl-auto: update

控制檯顯示SQL

show-sql: true

1
2
3
4
5
6
7
七、啟動配置原理
幾個重要的事件回撥機制

配置在META-INF/spring.factories

ApplicationContextInitializer

SpringApplicationRunListener

只需要放在ioc容器中

ApplicationRunner

CommandLineRunner

啟動流程：

1、建立SpringApplication物件
initialize(sources);
private void initialize(Object[] sources) {
//儲存主配置類
if (sources != null && sources.length > 0) {
this.sources.addAll(Arrays.asList(sources));
}
//判斷當前是否一個web應用
this.webEnvironment = deduceWebEnvironment();
//從類路徑下找到META-INF/spring.factories配置的所有ApplicationContextInitializer；然後儲存起來
setInitializers((Collection) getSpringFactoriesInstances(
ApplicationContextInitializer.class));
//從類路徑下找到ETA-INF/spring.factories配置的所有ApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//從多個配置類中找到有main方法的主配置類
this.mainApplicationClass = deduceMainApplicationClass();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-YOPBR3BK-1597758540547)(images/搜狗截圖20180306145727.png)]

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-M3QP13bn-1597758540547)(images/搜狗截圖20180306145855.png)]

2、執行run方法
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
configureHeadlessProperty();

//獲取SpringApplicationRunListeners；從類路徑下META-INF/spring.factories
SpringApplicationRunListeners listeners = getRunListeners(args);
//回撥所有的獲取SpringApplicationRunListener.starting()方法
listeners.starting();
try {
//封裝命令列引數
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
//準備環境
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
//建立環境完成後回撥SpringApplicationRunListener.environmentPrepared()；表示環境準備完成

  Banner printedBanner = printBanner(environment);
   
   //建立ApplicationContext；決定建立web的ioc還是普通的ioc
  context = createApplicationContext();
   
  analyzers = new FailureAnalyzers(context);
   //準備上下文環境;將environment儲存到ioc中；而且applyInitializers()；
   //applyInitializers()：回撥之前儲存的所有的ApplicationContextInitializer的initialize方法
   //回撥所有的SpringApplicationRunListener的contextPrepared()；
   //
  prepareContext(context, environment, listeners, applicationArguments,
        printedBanner);
   //prepareContext執行完成以後回撥所有的SpringApplicationRunListener的contextLoaded（）；
   
   //s重新整理容器；ioc容器初始化（如果是web應用還會建立嵌入式的Tomcat）；Spring註解版
   //掃描，建立，載入所有元件的地方；（配置類，元件，自動配置）
  refreshContext(context);
   //從ioc容器中獲取所有的ApplicationRunner和CommandLineRunner進行回撥
   //ApplicationRunner先回調，CommandLineRunner再回調
  afterRefresh(context, applicationArguments);
   //所有的SpringApplicationRunListener回撥finished方法
  listeners.finished(context, null);
  stopWatch.stop();
  if (this.logStartupInfo) {
     new StartupInfoLogger(this.mainApplicationClass)
           .logStarted(getApplicationLog(), stopWatch);
  }
   //整個SpringBoot應用啟動完成以後返回啟動的ioc容器；
  return context;

ApplicationContextInitializer

public class HelloApplicationContextInitializer implements ApplicationContextInitializer {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("ApplicationContextInitializer...initialize..."+applicationContext);
}
}

1
2
3
4
5
6
7
SpringApplicationRunListener

public class HelloSpringApplicationRunListener implements SpringApplicationRunListener {

//必須有的構造器
public HelloSpringApplicationRunListener(SpringApplication application, String[] args){

}

@Override
public void starting() {
    System.out.println("SpringApplicationRunListener...starting...");
}

@Override
public void environmentPrepared(ConfigurableEnvironment environment) {
    Object o = environment.getSystemProperties().get("os.name");
    System.out.println("SpringApplicationRunListener...environmentPrepared.."+o);
}

@Override
public void contextPrepared(ConfigurableApplicationContext context) {
    System.out.println("SpringApplicationRunListener...contextPrepared...");
}

@Override
public void contextLoaded(ConfigurableApplicationContext context) {
    System.out.println("SpringApplicationRunListener...contextLoaded...");
}

@Override
public void finished(ConfigurableApplicationContext context, Throwable exception) {
    System.out.println("SpringApplicationRunListener...finished...");
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
配置（META-INF/spring.factories）

org.springframework.context.ApplicationContextInitializer=
com.atguigu.springboot.listener.HelloApplicationContextInitializer

org.springframework.boot.SpringApplicationRunListener=
com.atguigu.springboot.listener.HelloSpringApplicationRunListener
1
2
3
4
5
只需要放在ioc容器中

ApplicationRunner

@Component
public class HelloApplicationRunner implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("ApplicationRunner...run....");
}
}
1
2
3
4
5
6
7
CommandLineRunner

@Component
public class HelloCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("CommandLineRunner...run..."+ Arrays.asList(args));
}
}
1
2
3
4
5
6
7
八、自定義starter
starter：

1、這個場景需要使用到的依賴是什麼？

2、如何編寫自動配置

@Configuration //指定這個類是一個配置類
@ConditionalOnXXX //在指定條件成立的情況下自動配置類生效
@AutoConfigureAfter //指定自動配置類的順序
@Bean //給容器中新增元件

@ConfigurationPropertie結合相關xxxProperties類來繫結相關的配置
@EnableConfigurationProperties //讓xxxProperties生效加入到容器中

自動配置類要能載入
將需要啟動就載入的自動配置類，配置在META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
1
2
3
4
5
6
7
8
9
10
11
12
13
3、模式：

啟動器只用來做依賴匯入；

專門來寫一個自動配置模組；

啟動器依賴自動配置；別人只需要引入啟動器（starter）

mybatis-spring-boot-starter；自定義啟動器名-spring-boot-starter

步驟：

1）、啟動器模組

4.0.0

<groupId>com.atguigu.starter</groupId>
<artifactId>atguigu-spring-boot-starter</artifactId>
<version>1.0-SNAPSHOT</version>

<!--啟動器-->
<dependencies>

    <!--引入自動配置模組-->
    <dependency>
        <groupId>com.atguigu.starter</groupId>
        <artifactId>atguigu-spring-boot-starter-autoconfigurer</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

4.0.0

com.atguigu.starter
atguigu-spring-boot-starter-autoconfigurer
0.0.1-SNAPSHOT
jar

atguigu-spring-boot-starter-autoconfigurer
Demo project for Spring Boot

org.springframework.boot spring-boot-starter-parent 1.5.10.RELEASE

UTF-8 UTF-8 1.8

  <!--引入spring-boot-starter；所有starter的基本配置-->
  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter</artifactId>
  </dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package com.atguigu.starter;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "atguigu.hello")
public class HelloProperties {

private String prefix;
private String suffix;

public String getPrefix() {
    return prefix;
}

public void setPrefix(String prefix) {
    this.prefix = prefix;
}

public String getSuffix() {
    return suffix;
}

public void setSuffix(String suffix) {
    this.suffix = suffix;
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.atguigu.starter;

public class HelloService {

HelloProperties helloProperties;

public HelloProperties getHelloProperties() {
    return helloProperties;
}

public void setHelloProperties(HelloProperties helloProperties) {
    this.helloProperties = helloProperties;
}

public String sayHellAtguigu(String name){
    return helloProperties.getPrefix()+"-" +name + helloProperties.getSuffix();
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.atguigu.starter;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnWebApplication //web應用才生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {

@Autowired
HelloProperties helloProperties;
@Bean
public HelloService helloService(){
    HelloService service = new HelloService();
    service.setHelloProperties(helloProperties);
    return service;
}

}

微服務：架構風格（服務微化）

4、配置檔案佔位符

Auto Configure

========================= AUTO-CONFIGURATION REPORT

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

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

logging.path=

不指定路徑在當前專案下生成springboot.log日誌

可以指定完整的路徑；

logging.file=G:/springboot.log

在當前磁碟的根路徑下建立spring資料夾和裡面的log資料夾；使用 spring.log 作為預設檔案

在控制檯輸出的日誌的格式

指定檔案中日誌輸出的格式

成功！

execInfo : information about the template being processed.

messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.

uris : methods for escaping parts of URLs/URIs

conversions : methods for executing the configured conversion service (if any).

dates : methods for java.util.Date objects: formatting, component extraction, etc.

calendars : analogous to #dates , but for java.util.Calendar objects.

numbers : methods for formatting numeric objects.

strings : methods for String objects: contains, startsWith, prepending/appending, etc.

objects : methods for objects in general.

bools : methods for boolean evaluation.

arrays : methods for arrays.

lists : methods for lists.

sets : methods for sets.

maps : methods for maps.

aggregates : methods for creating aggregates on arrays or collections.

ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).

禁用快取

相關推薦

=========================
AUTO-CONFIGURATION REPORT