Spring Boot（一）：入門篇

1、什麼是Spring Boot

Spring Boot 是由 Pivotal 團隊提供的全新框架，其設計目的是用來簡化新 Spring 應用的初始搭建以及開發過程。該框架使用了特定的方式來進行配置，從而使開發人員再也不須要定義樣板化的配置。用個人話來理解，就是 Spring Boot 其實不是什麼新的框架，它默認配置了不少框架的使用方式，就像 Maven 整合了全部的 Jar 包，Spring Boot 整合了全部的框架。

一、簡化spring應用開發的一個框架；

二、spring技術棧的一個大整合；

三、J2EE開發的一站式解決方案；

2、使用Spring Boot有什麼好處

其實就是簡單、快速、方便！

平時若是咱們須要搭建一個Spring Web項目的時候須要怎麼作呢？

• 配置web.xml，加載spring和springMVC
• 配置數據庫鏈接、配置spring事務
• 配置加載配置文件的讀取，開啓註解
• 配置日誌文件
• ...
• 配置完成以後部署Tomcat調試
• ...

如今很是流行微服務，若是我這個項目僅僅只是須要發送一個郵件，若是個人項目僅僅是生產一個積分；我都須要這樣折騰一遍!

可是若是使用 Spring Boot 呢？
很簡單，我僅僅只須要很是少的幾個配置就能夠迅速方便的搭建起來一套 Web 項目或者是構建一個微服務！

使用 Spring Boot 到底有多爽，用下面這幅圖來表達

3、簡單實例

一、IDEA構建項目

（1） 選擇 File -> New —> Project… 彈出新建項目的框

（2） 選擇 Spring Initializr，Next 也會出現上述相似的配置界面，Idea 幫咱們作了集成

（3） 填寫相關內容後，點擊 Next 選擇依賴的包再點擊 Next，最後肯定信息無誤點擊 Finish。

二、項目結構介紹

如上圖所示，Spring Boot 的基礎結構共三個文件:

• src/main/java 程序開發以及主程序入口
• src/main/resources 配置文件
• src/test/java 測試程序

三、實現Spring Boot HelloWorld

（1）maven配置

給maven 的settings.xml配置文件的profiles標籤添加

<profile>
  <id>jdk-1.8</id>
  <activation>
    <activeByDefault>true</activeByDefault>
    <jdk>1.8</jdk>
  </activation>
  <properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
  </properties>
</profile>

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

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

（3）編寫一個主程序；啓動Spring Boot應用

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

    public static void main(String[] args) {

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

（4）編寫相關的Controller、Service

@Controller
public class HelloController {

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

@RestController 的意思就是 Controller 裏面的方法都以json格式輸出，不用再寫什麼jackjson配置的了。

（5）運行主程序測試

（6）如何作單元測試

打開的 src/test/ 下的測試入口，編寫簡單的 http 請求來測試；使用 mockmvc 進行，利用 MockMvcResultHandlers.print() 打印出執行結果。

@RunWith(SpringRunner.class)
@SpringBootTest
public class HelloTests {
    private MockMvc mvc;

    @Before
    public void setUp() throws Exception {
        mvc = MockMvcBuilders.standaloneSetup(new HelloWorldController()).build();
    }

    @Test
    public void getHello() throws Exception {
        mvc.perform(MockMvcRequestBuilders.get("/hello").accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().string(equalTo("Hello World")));
    }
}

（7）簡化部署

·   <!-- 這個插件，能夠將應用打包成一個可執行的jar包；-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

將這個應用打成jar包，直接使用java -jar的命令進行執行

四、Hello World探究

（1）POM文件

pom.xml 文件中默認有兩個模塊：

spring-boot-starter 核心模塊，包括自動配置支持、日誌和YAML，若是引入了 spring-boot-starter-web web模塊能夠去掉此配置，由於 spring-boot-starter-web 自動依賴了spring-boot-starter。

spring-boot-starter-test 測試模塊，包括JUnit、Hamcrest、Mockito。

父項目

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
</parent>

他的父項目是
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>1.5.9.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
他來真正管理Spring Boot應用裏面的全部依賴版本；

啓動器

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

spring-boot-starter：spring-boot場景啓動器；幫咱們導入了web模塊正常運行所依賴的組件；

Spring Boot將全部的功能場景都抽取出來，作成一個個的starters（啓動器），只須要在項目裏面引入這些starter相關場景的全部依賴都會導入進來。要用什麼功能就導入什麼場景的啓動器。

（2）主程序類，主入口類

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

    public static void main(String[] args) {

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

@**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 {
}

@**SpringBootConfiguration**:Spring Boot的配置類；

標註在某個類上，表示這是一個Spring Boot的配置類；

@**Configuration**:配置類上來標註這個註解；

配置類 -----  配置文件；配置類也是容器中的一個組件；@Component

@**EnableAutoConfiguration**：開啓自動配置功能；

之前咱們須要配置的東西，Spring Boot幫咱們自動配置；@**EnableAutoConfiguration**告訴SpringBoot開啓自動配置功能；這樣自動配置才能生效；

@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}

@**AutoConfigurationPackage**：自動配置包

​        @**Import**(AutoConfigurationPackages.Registrar.class)：

​        Spring的底層註解@Import，給容器中導入一個組件；導入的組件由AutoConfigurationPackages.Registrar.class；

==將主配置類（@SpringBootApplication標註的類）的所在包及下面全部子包裏面的全部組件掃描到Spring容器；==

​    @**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；

4、配置文件

一、配置文件簡介

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

二、YAML語法：

（1）基本語法

k:(空格)v：表示一對鍵值對（空格必須有）；

以**空格**的縮進來控制層級關係；只要是左對齊的一列數據，都是同一個層級的

server:
    port: 8081
    path: /hello

屬性和值也是大小寫敏感；

（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

 

•  數組（List、Set）：

用- 值表示數組中的一個元素

pets:
 - cat
 - dog
 - pig

三、配置文件值注入

（1）yml配置文件

person:
    lastName: hello
    age: 18
    boss: false
    birth: 2017/12/12
    maps: {k1: v1,k2: 12}
    lists:
      - lisi
      - zhaoliu
    dog:
      name: 小狗
      age: 12

（2）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;

咱們能夠導入配置文件處理器，之後編寫配置就有提示了

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

（3）@Value獲取值和@ConfigurationProperties獲取值比較

配置文件yml仍是properties他們都能獲取到值；

若是說，咱們只是在某個業務邏輯中須要獲取一下配置文件中的某項值，使用@Value；

若是說，咱們專門編寫了一個javaBean來和配置文件進行映射，咱們就直接使用@ConfigurationProperties；
（4）配置文件注入值數據校驗

@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;

（5）@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;

@**ImportResource**：導入Spring的配置文件，讓配置文件裏面的內容生效；

Spring Boot裏面沒有Spring的配置文件，咱們本身編寫的配置文件，也不能自動識別；

想讓Spring的配置文件生效，加載進來；@**ImportResource**標註在一個配置類上

@ImportResource(locations = {"classpath:beans.xml"})
導入Spring的配置文件讓其生效

不來編寫Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


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

SpringBoot推薦給容器中添加組件的方式；推薦使用全註解的方式

• 配置類**@Configuration**------>Spring配置文件
• 使用**@Bean**給容器中添加組件

/** * @Configuration：指明當前類是一個配置類；就是來替代以前的Spring配置文件 * * 在配置文件中用<bean><bean/>標籤添加組件 * */
@Configuration
public class MyAppConfig {

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

四、配置文件佔位符

（1）隨機數

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

（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

五、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  #指定屬於哪一個環境

（3）激活指定profile

• 在配置文件中指定  spring.profiles.active=dev
• ​命令行：

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

​        能夠直接在測試的時候，配置傳入命令行參數

• 虛擬機參數；

​        -Dspring.profiles.active=dev

六、配置文件加載位置

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

七、外部配置加載順序

**==SpringBoot也能夠從如下位置加載配置； 優先級從高到低；高優先級的配置覆蓋低優先級的配置，全部的配置會造成互補配置==**

**一、命令行參數**

全部的配置均可以在命令行上進行指定

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

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

二、來自java:comp/env的JNDI屬性

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

四、操做系統環境變量

五、RandomValuePropertySource配置的random.*屬性值

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

==**優先加載帶profile**==

**六、jar包外部的application-{profile}.properties或application.yml(帶spring.profile)配置文件**

**七、jar包內部的application-{profile}.properties或application.yml(帶spring.profile)配置文件**

==**再來加載不帶profile**==

**八、jar包外部的application.properties或application.yml(不帶spring.profile)配置文件**

**九、jar包內部的application.properties或application.yml(不帶spring.profile)配置文件**

十、@Configuration註解類上的@PropertySource

 十一、經過SpringApplication.setDefaultProperties指定的默認屬性

全部支持的配置加載來源；

[參考官方文檔]

八、自動配置原理

配置文件到底能寫什麼？怎麼寫？自動配置原理；

[配置文件能配置的屬性參照]

（1）SpringBoot啓動的時候加載主配置類，開啓了自動配置功能 ==@EnableAutoConfiguration==

（2）@EnableAutoConfiguration 做用：

• 利用EnableAutoConfigurationImportSelector給容器中導入一些組件？
• 能夠查看selectImports()方法的內容；
• List<String> configurations = getCandidateConfigurations(annotationMetadata,      attributes);獲取候選的配置

SpringFactoriesLoader.loadFactoryNames()
掃描全部jar包類路徑下  META-INF/spring.factories
把掃描到的這些文件的內容包裝成properties對象
從properties中獲取到EnableAutoConfiguration.class類（類名）對應的值，而後把他們添加在容器中

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

每個這樣的  xxxAutoConfiguration類都是容器中的一個組件，都加入到容器中；用他們來作自動配置；

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

（4）以**HttpEncodingAutoConfiguration（Http編碼自動配置）**爲例解釋自動配置原理：

@Configuration //表示這是一個配置類，之前編寫的配置文件同樣，也能夠給容器中添加組件
@EnableConfigurationProperties(HttpEncodingProperties.class)//啓動指定類的ConfigurationProperties功能；將配置文件中對應的值和HttpEncodingProperties綁定起來；並把HttpEncodingProperties加入到IOC容器中
@ConditionalOnWebApplication //spring底層@Conditional註解，根據不一樣的條件，若是知足指定的條件，整個配置類裏面的配置就會失效；判斷當前應用是不是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中回去
    @ConditionalOnEncodingFilter(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;
    }
}

根據當前不一樣的條件判斷，決定這個配置類是否生效？

一但這個配置類生效；這個配置類就會給容器中添加各類組件；這些組件的屬性是從對應的properties類中獲取的，這些類裏面的每個屬性又是和配置文件綁定的；

（5）全部在配置文件中能配置的屬性都是在xxxxProperties類中封裝着；配置文件能配置什麼就能夠參照某個功能對應的這個屬性類

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

   public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

**精髓**

• springboot啓動會加載大量的自動配置類
• 咱們看咱們須要的功能有沒有springboot默認寫好的自動配置類；
• 咱們再來看這個自動配置類中到底配置了哪些組件（只要咱們要用的組件有，咱們就不須要再來配置了）
• 給容器中自動配置類添加組件的時候，會動從properties類中獲取某些屬性，咱們就能夠在配置文件中指定這些屬性的值；

xxxxAutoConfigurartion：自動配置類；

給容器中添加組件

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

九、細節

@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', '3、快速入門

5、日誌

一、SpringBoot選用 SLF4j和logback

之後開發的時候，日誌記錄方法的調用，不該該來直接調用日誌的實現類，而是調用日誌抽象層裏面的方法；

給系統裏面導入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");
  }
}

二、遺留問題

a（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

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

如何讓系統中全部的日誌都統一到slf4j？

（1）將系統中其它日誌框架先排除出去

（2）用中間包來替換原有的日誌框架

（3）導入slf4j其它的實現

三、SpringBoot日誌關係

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

SpringBoot使用它來作日誌功能；

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

四、底層依賴關係

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

（2）Spring Boot也把其餘的日誌都替換成了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();

（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>

**==SpringBoot能自動適配全部的日誌，並且底層使用slf4j+logback的方式記錄日誌，引入其餘框架的時候，只須要把這個框架依賴的日誌框架排除掉便可；**

五、日誌使用

（1）默認配置

Spring Boot默認幫咱們配置好了日誌

//記錄器
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日誌...")
}

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

 （2）指定配置

給類路徑下放上每一個日誌框架本身的配置文件便可；SpringBoot就不使用他默認配置的了。

logback.xml：直接就被日誌框架識別了；

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

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
  	能夠指定某段配置只在某個環境下生效
</springProfile>

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
    <!--
        日誌輸出格式：
			%d表示日期時間，
			%thread表示線程名，
			%-5level：級別從左顯示5個字符寬度
			%logger{50} 表示logger名字最長50個字符，不然按照句點分割。 
			%msg：日誌消息，
			%n是換行符
        -->
    <layout class="ch.qos.logback.classic.PatternLayout">
        <springProfile name="dev">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
        </springProfile>
        <springProfile name="!dev">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
        </springProfile>
    </layout>
</appender>

若是使用logback.xml做爲日誌配置文件，還要使用profile功能，會有如下錯誤：

no applicable action for [springProfile]

六、切換日誌框架

能夠按照slf4j的日誌適配圖，進行相關的切換；

slf4j+log4j的方式：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
    </exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
</dependency>

切換爲log4j2：

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

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

6、總結

使用 Spring Boot 能夠很是方便、快速搭建項目，使咱們不用關心框架之間的兼容性，適用版本等各類問題，咱們想使用任何東西，僅僅添加一個配置就能夠，因此使用 Spring Boot 很是適合構建微服務。