SpringBoot基础以及原理分析

墨蓝 2022-01-30 14:45 270阅读 0赞

## **一、SpringBoot简介** ##

**1.1 原有Spring优缺点分析**  
**1.1.1 Spring的优点分析**  
Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise  
JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单  
的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。  
**1.1.2 Spring的缺点分析**  
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配  
置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入  
了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。  
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编  
写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。  
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要  
分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开  
发进度。

## **1.2 SpringBoot的概述** ##

**1.2.1 SpringBoot解决上述Spring的缺点**  
SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑  
业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短  
了项目周期。  
**1.2.2 SpringBoot的特点**  
为基于Spring的开发提供更快的入门体验  
开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求  
提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等  
SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式  
**1.2.3 SpringBoot的核心功能**  
起步依赖  
起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依  
赖，这些东西加在一起即支持某项功能。  
简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。  
自动配置  
Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定  
Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

## 二、SpringBoot快速入门 ##

**2.1 代码实现**  
**2.1.1 创建Maven工程**  
使用idea工具创建一个maven工程，该工程为普通的jar工程即可  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 1]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 2]![在这里插入图片描述][20190519202345901.png]**2.1.2 添加SpringBoot的起步依赖**  
SpringBoot要求，项目要继承SpringBoot的起步依赖spring-boot-starter-parent

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

SpringBoot要集成SpringMVC进行Controller的开发，所以项目要导入web的启动依赖

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

**2.1.3 编写SpringBoot引导类**  
要通过SpringBoot提供的引导类起步SpringBoot才可以进行访问

package cn.itcast.springboot_helloworld;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class SpringbootHelloworldApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(SpringbootHelloworldApplication.class, args);
        }
    
    }

**2.1.4 编写Controller**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 3]在引导类MySpringBootApplication同级包或者子级包中创建controller

package cn.itcast.springboot_helloworld.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * 测试的controller
     */
    @RestController
    public class HelloWorld {
    
    
        /**
         * 测试方法
         *
         * @return
         */
        @RequestMapping("/hello")
        public String Hello() {
    
            return "Hello SpringBoot";
        }
    }

**2.1.5 测试**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 4]通过日志发现，Tomcat started on port(s): 8080 (http) with context path ‘’  
tomcat已经起步，端口监听8080，web应用的虚拟工程名称为空  
打开浏览器访问url地址为：[http://localhost:8080/hello][http_localhost_8080_hello]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 5]

## 2.2 快速入门解析 ##

**2.2.2 SpringBoot代码解析**

@SpringBootApplication：标注SpringBoot的启动类，该注解具备多种功能（后面详细剖析）
    SpringApplication.run(MySpringBootApplication.class) 代表运行SpringBoot的启动类，参数为SpringBoot
    启动类的字节码对象

**2.2.3 SpringBoot工程热部署**  
我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大  
量的时间，我们可以在修改代码后不重启就能生效，在 pom.xml 中添加如下配置就可以实现这样的功能，我们称  
之为热部署。

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

**注意：IDEA进行SpringBoot热部署失败原因**  
出现这种情况，并不是热部署配置问题，其根本原因是因为Intellij IEDA默认情况下不会自动编译，需要对IDEA进  
行自动编译的设置，如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 6]然后 Shift+Ctrl+Alt+/，选择Registry  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 7]

## 三、SpringBoot原理分析 ##

**3.1 起步依赖原理分析**  
**3.1.1 分析spring-boot-starter-parent**  
按住Ctrl点击pom.xml中的spring-boot-starter-parent，跳转到了spring-boot-starter-parent的pom.xml，xml配  
置如下（只摘抄了部分重点配置）：

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

按住Ctrl点击pom.xml中的spring-boot-starter-dependencies，跳转到了spring-boot-starter-dependencies的  
pom.xml，xml配置如下（只摘抄了部分重点配置）：

<properties>
    	<activemq.version>5.15.3</activemq.version>
    	<antlr2.version>2.7.7</antlr2.version>
    	<appengine-sdk.version>1.9.63</appengine-sdk.version>
    	<artemis.version>2.4.0</artemis.version>
    	<aspectj.version>1.8.13</aspectj.version>
    	<assertj.version>3.9.1</assertj.version>
    	<atomikos.version>4.0.6</atomikos.version>
    	<bitronix.version>2.1.4</bitronix.version>
    	<build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
    	<byte-buddy.version>1.7.11</byte-buddy.version>
    	... ... ...
    	</properties>
    	<dependencyManagement>
    	<dependencies>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot</artifactId>
    		<version>2.0.1.RELEASE</version>
    	</dependency>
    	<dependency>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-test</artifactId>
    		<version>2.0.1.RELEASE</version>
    	</dependency>
    	... ... ...
    	</dependencies>
    	</dependencyManagement>
    	<build>
    	<pluginManagement>
    	<plugins>
    		<plugin>
    			<groupId>org.jetbrains.kotlin</groupId>
    			<artifactId>kotlin-maven-plugin</artifactId>
    			<version>${kotlin.version}</version>
    		</plugin>
    		<plugin>
    			<groupId>org.jooq</groupId>
    			<artifactId>jooq-codegen-maven</artifactId>
    			<version>${jooq.version}</version>
    		</plugin>
    		<plugin>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-maven-plugin</artifactId>
    			<version>2.0.1.RELEASE</version>
    		</plugin>
    	... ... ...
    	</plugins>
    	</pluginManagement>
    </build>

从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递  
**3.1.2 分析spring-boot-starter-web**  
按住Ctrl点击pom.xml中的spring-boot-starter-web，跳转到了spring-boot-starter-web的pom.xml，xml配置如下（只摘抄了部分重点配置）：

<?xml version="1.0" encoding="UTF-8"?>
    <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
    	http://maven.apache.org/xsd/maven-4.0.0.xsd"
    	xmlns="http://maven.apache.org/POM/4.0.0"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starters</artifactId>
    		<version>2.0.1.RELEASE</version>
    	</parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-web</artifactId>
    		<version>2.0.1.RELEASE</version>
    		<name>Spring Boot Web Starter</name>
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter</artifactId>
    			<version>2.0.1.RELEASE</version>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-json</artifactId>
    			<version>2.0.1.RELEASE</version>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-tomcat</artifactId>
    			<version>2.0.1.RELEASE</version>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.hibernate.validator</groupId>
    			<artifactId>hibernate-validator</artifactId>
    			<version>6.0.9.Final</version>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>5.0.5.RELEASE</version>
    			<scope>compile</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>5.0.5.RELEASE</version>
    			<scope>compile</scope>
    		</dependency>
    	</dependencies>
    </project>

从上面的spring-boot-starter-web的pom.xml中我们可以发现，spring-boot-starter-web就是将web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”，这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的作用。  
**3.2 自动配置原理解析**  
按住Ctrl点击查看启动类MySpringBootApplication上的注解@SpringBootApplication

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

注解@SpringBootApplication的源码

@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 {
    		/**
    		* Exclude specific auto-configuration classes such that they will never be
    		applied.
    		* @return the classes to exclude
    		*/
    		@AliasFor(annotation = EnableAutoConfiguration.class)
    		Class<?>[] exclude() default {};
    		... ... ...
    }

其中，  
@SpringBootConfiguration：等同与@Configuration，既标注该类是Spring的一个配置类  
@EnableAutoConfiguration：SpringBoot自动配置功能开启。  
按住Ctrl点击查看注解@EnableAutoConfiguration

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    ... ... ...
    }

其中，@Import(AutoConfigurationImportSelector.class) 导入了AutoConfigurationImportSelector类  
按住Ctrl点击查看AutoConfigurationImportSelector源码

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    ... ... ...
    	List<String> configurations = getCandidateConfigurations(annotationMetadata,
    	attributes);
    			configurations = removeDuplicates(configurations);
    			Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    			checkExcludedClasses(configurations, exclusions);
    			configurations.removeAll(exclusions);
    			configurations = filter(configurations, autoConfigurationMetadata);
    			fireAutoConfigurationImportEvents(configurations, exclusions);
    			return StringUtils.toStringArray(configurations);
    	}
    		protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
    		AnnotationAttributes attributes) {
    				List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
    				getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    				return configurations;
    		}

其中，SpringFactoriesLoader.loadFactoryNames 方法的作用就是从META-INF/spring.factories文件中读取指定类对应的类名称列表  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 8]spring.factories 文件中有关自动配置的配置信息如下

... ... ...
    org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConf
    iguration,\
    org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration
    ,\
    org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfigu
    ration,\
    org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
    ... ... ...

上面配置文件存在大量的以Configuration为结尾的类名称，这些类就是存有自动配置信息的类，而  
SpringApplication在获取这些类名后再加载  
我们以ServletWebServerFactoryAutoConfiguration为例来分析源码：

@Configuration
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    @ConditionalOnClass(ServletRequest.class)
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @EnableConfigurationProperties(ServerProperties.class)
    @Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
    ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
    ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
    ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
    public class ServletWebServerFactoryAutoConfiguration {
    ... ... ...
    }

prefix = “server” 表示SpringBoot配置文件中的前缀，SpringBoot会将配置文件中以server开始的属性映射到该类的字段中。映射关系如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 9]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019051920222529.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190519202244790.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190519202302133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0,size_16,color_FFFFFF,t_70
[20190519202345901.png]: /images/20220130/850d4a66e7714310b6318f64b6eb98c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 3]: /images/20220130/06e04f9e1adc422db86e6114feda65b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 4]: /images/20220130/b597bc07d93c4484bfd15fb8026ff1f3.png
[http_localhost_8080_hello]: http://localhost:8080/hello
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 5]: /images/20220130/36dd4692d06e481f88eb5a0656243945.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 6]: /images/20220130/5da441810b474b86a9b33d88ca431faf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 7]: /images/20220130/1935bd3dc7624bdf909a3e0b62f9f2c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 8]: /images/20220130/91620563189c41538c63efe2923fa0e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3MjE1NDc0_size_16_color_FFFFFF_t_70 9]: /images/20220130/121e1e2556154185a92c0ddf71e6b937.png