SpringBoot【一】入门程序及原理分析

入门程序

入门程序编写步骤

1、创建基础项目

Spring 官方提供了非常方便的工具（快速生成的网站）让我们快速构建应用，IDEA 中也集成了这个网站。

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

创建方式一：使用 Spring Initializr 的 Web 页面创建项目，下载并导入 IDEA 开发

打开 https://start.spring.io，填写项目信息
点击 ”Generate Project“ 按钮生成项目，下载此项目
解压项目包，并用 IDEA 以 Maven 项目导入

创建方式二：使用 IDEA 直接创建项目【一般开发使用】

创建一个新项目，选择 spring initalizr，可以看到默认就是去官网的快速构建工具那里实现
填写项目信息、项目路径
选择初始化的组件（初学勾选 Web 即可）
等待项目构建成功

项目结构分析：

基础项目的创建后会自动生成以下文件：

程序的主启动类
一个 application.properties 配置文件
一个测试类
一个 pom.xml

pom.xml 分析：

<!-- 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
    <relativePath/> 
</parent>

<dependencies>
    <!-- web场景启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- springboot单元测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <!-- 剔除依赖 -->
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- 打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2、编写一个http接口

在主程序【Springboot01HelloworldApplication.class】的同级目录下，新建一个 controller 包

注意：一定要在同级目录下，否则识别不到

在包中新建一个 HelloController 类

@Controller
@RequestMapping("/hello")
public class HelloController {

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

编写完毕后，从主程序启动项目，浏览器发起请求 localhost:8080/hello/hello
结果：浏览器页面显示 hello

3、打成 jar 包

点击 maven 的 package 可以将项目打成 jar 包，打包成功会在 target 目录下生成一个 jar 包，可以在任何地方运行。

如果打包时出错，可以配置打包时跳过项目运行测试用例

<!--
    在工作中,很多情况下我们打包是不想执行测试用例的
    可能是测试用例不完事,或是测试用例会影响数据库数据
    跳过测试用例执行
-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <!--跳过项目运行测试用例-->
        <skipTests>true</skipTests>
    </configuration>
</plugin>

如何更改启动时显示的字符拼成的字母 SpringBoot，也就是 banner 图案？

在项目下的 resources 目录下新建一个 banner.txt 即可。图案可以到：https://www.bootschool.net/ascii 这个网站生成，然后拷贝到文件中。

程序运行原理

1、pom.xml

父依赖（核心依赖在父工程中）

从文件中看到它主要是依赖一个父项目，主要是管理项目的资源过滤及插件。
```
<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>2.3.1.RELEASE</version>
   <relativePath/> 
</parent>
```
点进 spring-boot-starter-parent，发现还有一个父依赖 spring-boot-dependencies，这里是真正管理 SpringBoot 应用里面所有依赖版本的地方，即 SpringBoot 的版本控制中心（仓库），所以以后导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本。
```
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.3.1.RELEASE</version>
</parent>
```
启动器

spring-boot-starter-xxx：SpringBoot 的场景启动器，比如 spring-boot-starter-web 帮我们自动导入 web 模块正常运行所依赖的组件。

SpringBoot 会将所有的功能场景都抽取出来，变成一个个的启动器（starter），如果要使用什么功能，只需要导入对应的启动器（starter）即可，所有相关的依赖都会导入进来。未来也可以自己自定义 starter。
```
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
</dependency>
```

2、主启动类

默认的主程序

// @SpringBootApplication：来标注一个主程序类，说明这是一个springboot的应用，启动类下的所有资源被导入
@SpringBootApplication
public class Springboot01HelloworldApplication {

   public static void main(String[] args) {
      // 将 springboot 启动，启动了一个服务
      SpringApplication.run(Springboot01HelloworldApplication.class, args);
   }
}

注解

@SpringBootApplication：标注在某个类上说明这个类是 SpringBoot 的主配置类， SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用。进入这个注解，可以看到上面还有很多其他注解：

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

@ComponentScan(...)：扫描当前主启动类同级的包，自动扫描并加载符合条件的组件或者bean ，将这个bean定义加载到IOC容器中

@SpringBootConfiguration：SpringBoot 的配置类，标注在某个类上，表示这是一个SpringBoot 的配置类，继续进入查看

@SpringBootConfiguration：springboot的配置类
    
    @Configuration：spring 配置类，对应Spring的xml 配置文件
    public @interface SpringBootConfiguration {}

    	@Component：说明启动类本身也是 spring 的一个组件
        public @interface Configuration {}

@EnableAutoConfiguration：开启自动配置功能，该注解告诉SpringBoot开启自动配置功能，这样自动配置才能生效，继续进入查看

@EnableAutoConfiguration：自动配置（导入）

	@AutoConfigurationPackage：自动配置包（注册包）
    //AutoConfigurationImportSelector ：自动配置导入选择器
	@Import(AutoConfigurationImportSelector.class)：自动导入选择【核心】
	public @interface EnableAutoConfiguration {...}
		
		//Spring底层注解@import ，给容器中导入一个组件
        //Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器
		@Import(AutoConfigurationPackages.Registrar.class)：自动配置 包注册
		public @interface AutoConfigurationPackage {

@Import(AutoConfigurationImportSelector.class)：自动配置导入选择器，会导入哪些组件的选择器呢？分析源码：

类中 getAutoConfigurationEntry()//获得自动配置的实体 方法调用另一个方法：getCandidateConfigurations()

//获取候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //这里的getSpringFactoriesLoaderFactoryClass（）方法
    //返回的就是我们最开始的启动自动导入配置文件的注解类：EnableAutoConfiguration
	List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), 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;
}

方法中传入的参数

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
   return EnableAutoConfiguration.class;
    //标注了EnableAutoConfiguration注解的类
}

该方法中又调用了 SpringFactoriesLoader 类的静态方法 loadFactoryNames()，进入这个静态方法 loadFactoryNames()

// 获取所有的加载配置
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    //这里它又调用了 loadSpringFactories 方法
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

进入 loadSpringFactories() 方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    //获得classLoader，我们返回可以看到这里得到的就是 EnableAutoConfiguration 标注的类本身
    ...
    //去获取一个资源 "META-INF/spring.factories"
    Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");    
    ...
    URL url = (URL)urls.nextElement();
    UrlResource resource = new UrlResource(url);
    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
    ...
}
/*
项目资源：classLoader.getResources("META-INF/spring.factories")
系统资源：ClassLoader.getSystemResources("META-INF/spring.factories")
    从这些资源中遍历了所有的 nextElement（自动配置），遍历完成之后，封装为properties供我们使用
	Properties properties = PropertiesLoaderUtils.loadProperties(resource);
	所有资源都加载到配置类中
*/

发现一个多次出现的文件：spring.factories

META-INF/spring.factories

自动配置的核心文件，所有的自动配置类都在这里了，这就是自动配置根源所在。

文件位置：spring-boot-autoconfigure-2.3.1.RELEASE.jar/META-INF/spring.factories

这些自动配置类都是 JavaConfig 配置类，而且都注入了一些 Bean。

自动配置真正实现是从 classpath 中搜寻所有的 META-INF/spring.factories 配置文件，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration 的JavaConfig 形式的 IOC 容器配置类，然后将这些都汇总成为一个实例并加载到 IOC 容器中。

问题：这么多自动配置为什么没有生效，需要导入对应的 start 才能有作用？

原因：这些自动配置类上都有核心注解 @ConditionOnXXX ，如果这里的条件都满足，该类才会生效。

总结：SpringBoot 所有的自动配置都是在启动的时候扫描并加载，spring.factories 所有的自动配置类都在这里，但是不一定生效，要判断条件是否成立，只要导入了对应的 start，就有对应的启动器了，有了启动器，自动装配就可以生效，然后就配置成功。

结论：

SpringBoot 在启动的时候从类路径下的 META-INF/spring.factories 中获取 EnableAutoConfiguration 指定的值
将这些值作为自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作；
整个 J2EE 的整体解决方案和自动配置都在 springboot-autoconfigure 的 jar 包中；
它会给容器中导入非常多的自动配置类（xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件，并配置好这些组件；
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作；

3、SpringApplication

不只是运行了一个 main 方法，而是开启了一个服务

@SpringBootApplication
public class Springboot01HelloworldApplication {

   public static void main(String[] args) {
      // 将springboot启动
      SpringApplication.run(Springboot01HelloworldApplication.class, args);
   }
}

SpringApplication 类

这个类主要做了以下四件事情：
1. 推断应用的类型是普通的项目还是 Web 项目
2. 查找并加载所有可用初始化器，设置到 initializers 属性中
3. 找出所有的应用程序监听器，设置到 listeners 属性中
4. 推断并设置 main 方法的定义类，找到运行的主类

posted @ 2020-07-07 21:12 Song-zw 阅读(169) 评论(0) 编辑收藏举报

刷新页面返回顶部

Song-zw

不积跬步，无以至千里