SpringBoot學習筆記

?????

SpringBoot的功能、運行原理...

一. 簡介

Spring的作用

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

Spring是如何簡化Java開發的

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

基于POJO的輕量級和最小入侵性編程
通過IOC，依賴注入(DI)和面向介面實作松耦合
基于切面(AOP)和慣例進行宣告式編程
通過切面和模板減少樣式代碼

什么是SpringBoot

SpringBoot，就是一個javaweb的開發框架，和SpringMVC類似，Spring Boot 以約定大于配置作為核心思想，

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

Java企業級應用的程序：J2EE->spring->springboot;

微服務

微服務：架構風格（服務微化）；
一個應用應該是一組小型服務；可以通過HTTP的方式進行互通；
單體應用：ALL IN ONE
微服務：每一個功能元素最終都是一個可獨立替換和獨立升級的軟體單元；
詳細參照微服務檔案

二. Hello world專案

1). 創建一個Controller類

//相當于@ResponseBody ＋ @Controller合在一起的作用
@RestController
public class HelloController {

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

2). 在main方法中運行

//Spring Boot專案的核心注解，主要目的是開啟自動配置,程式的入口
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        //在main方法中啟動一個應用，即：這個應用的入口
        SpringApplication.run(DemoApplication.class, args);
    }

}

3). 組態檔

    <dependencies>
        <!--spring-boot-starter的所有springboot依賴都是用<dependency>添加-->

        <!--web依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--單元測驗-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

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

4). 更改專案埠號

application.properties

#修改埠號
server.port=4040

5). 更改啟動時顯示的字符

只需一步：到專案下的 resources 目錄下新建一個banner.txt 即可，

圖案可以到：https://www.bootschool.net/ascii 這個網站生成，然后拷貝到檔案中即可！

三. 運行原理

1). pom.xml

父依賴

<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應用里面的所有依賴版本；-->

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

啟動器 spring-boot-starter

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

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

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

2). 主程式

默認的主啟動類

//@SpringBootApplication 來標注一個主程式類
//說明這是一個Spring Boot應用
@SpringBootApplication
public class SpringbootApplication {

   public static void main(String[] args) {
     //以為是啟動了一個方法，沒想到啟動了一個服務
      SpringApplication.run(SpringbootApplication.class, args);
   }

}

但是一個簡單的啟動類并不簡單！我們來分析一下這些注解都干了什么

@SpringBootApplication

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

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

//@SpringBootConfiguration：SpringBoot的配置類
//@Configuration：配置類上標注這個注解(配置類也是容器中的一個組件)；
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    // ......
}

@ComponentScan

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

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

@SpringBootConfiguration

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

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

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

@Component
public @interface Configuration {}

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

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

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

@EnableAutoConfiguration

@EnableAutoConfiguration ：開啟自動配置功能

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

點進注解接續查看：

@AutoConfigurationPackage ：自動配置包

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

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

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

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

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

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

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

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

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

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

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

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    //獲得classLoader ， 我們回傳可以看到這里得到的就是EnableAutoConfiguration標注的類本身
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            //去獲取一個資源 "META-INF/spring.factories"
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            //將讀取到的資源遍歷，封裝成為一個Properties
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryClassName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryName = var9[var11];
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

4、發現一個多次出現的檔案：spring.factories，全域搜索它

spring.factories

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

SpringBoot所有的自動配置都是在啟動時的時候掃描并加載，spring.factories所有的自動配置類都在這里買呢，但不一定生效，要判斷條件是否成立，只要匯入了對性的start，就有對應的啟動器了，然后就可以自動裝配成功，

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

結論：

SpringBoot在啟動的時候從類路徑下的META-INF/spring.factories中獲取EnableAutoConfiguration指定的值
將這些值作為自動配置類匯入容器，自動配置類就生效，幫我們進行自動配置作業；
整個J2EE的整體解決方案和自動配置都在springboot-autoconfigure的jar包中；
它會給容器中匯入非常多的自動配置類（xxxAutoConfiguration）, 就是給容器中匯入這個場景需要的所有組件，并配置好這些組件；
有了自動配置類，免去了我們手動撰寫配置注入功能組件等的作業；

3). SpringApplication

SpringApplication.run分析

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

SpringApplication

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

1、推斷應用的型別是普通的專案還是Web專案
2、查找并加載所有可用初始化器，設定到initializers屬性中
3、找出所有的應用程式監聽器，設定到listeners屬性中
4、推斷并設定main方法的定義類，找到運行的主類

查看構造器：

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

run方法流程分析

跟著原始碼和這幅圖就可以一探究竟了！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/105925.html

標籤：Java

上一篇：CodeForces-1152C-Neko does Maths

下一篇：springboot~使用自定義的aspect

SpringBoot學習筆記0.2