SpringBoot为什么可以开箱即用

最新推荐文章于 2023-04-15 08:44:01 发布

初ོ心ꦿ℘.

最新推荐文章于 2023-04-15 08:44:01 发布

阅读量1.1k

点赞数

分类专栏： SpringBoot

本文链接：https://blog.csdn.net/weixin_45585410/article/details/103300871

版权

SpringBoot 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

SpringBoot为什么可以开箱即用

SpringBoot的场景启动器

SpringBoot启动main()方法

每一个自动配置类如何进行自动配置

SpringBoot的场景启动器

Spring Boot提供了很多场景启动器，都是以spring-boot-starter-xx作为命名的。

spring-boot-starter-logging ：使用 Spring Boot 默认的日志框架 Logback。
spring-boot-starter-log4j ：添加 Log4j 的支持。
spring-boot-starter-web ：支持 Web 应用开发，包含 Tomcat 和 spring-mvc。
spring-boot-starter-tomcat ：使用 Spring Boot 默认的 Tomcat 作为应用服务器。
spring-boot-starter-jetty ：使用 Jetty 而不是默认的 Tomcat 作为应用服务器。
spring-boot-starter-test ：包含常用的测试所需的依赖，如 JUnit、Hamcrest、Mockito 和 spring-test 等。
spring-boot-starter-aop ：包含 spring-aop 和 AspectJ 来支持面向切面编程（AOP）。
spring-boot-starter-security ：包含 spring-security。
spring-boot-starter-jdbc ：支持使用 JDBC 访问数据库。
spring-boot-starter-redis ：支持使用 Redis。

通过 Spring Boot，创建新的 Spring 应用变得非常容易，首先，我们先创建一个 pom文件。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.tkxt</groupId>
    <artifactId>tkxt</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>tkxt</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- 导入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>
    <!-- 项目打包成jar -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

新创建的pom 文件中导入了spring-boot-starter-parent文件，在spring-boot-starter-parent文件中又导入了spring-boot-dependencies文件。spring-boot-dependencies中定义了我们常用的版本号，spring-boot-dependencies相当于SpringBoot的版本仲裁中心，以后导入的依赖默认是不需要写版本的，除非没有在spring-boot-dependencies文件中指定版本。

<?xml version="1.0" encoding="utf-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.2.0.RELEASE</version>
  <packaging>pom</packaging>
  <name>Spring Boot Dependencies</name>
  <description>Spring Boot Dependencies</description>
  <url>https://projects.spring.io/spring-boot/#</url>
  <properties>
    <activemq.version>5.15.10</activemq.version>
    <antlr2.version>2.7.7</antlr2.version>
    <appengine-sdk.version>1.9.76</appengine-sdk.version>
    <artemis.version>2.10.1</artemis.version>
    <aspectj.version>1.9.4</aspectj.version>
    <assertj.version>3.13.2</assertj.version>
    <atomikos.version>4.0.6</atomikos.version>
    <awaitility.version>4.0.1</awaitility.version>
    <bitronix.version>2.1.4</bitronix.version>
    <build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
    <commons-codec.version>1.13</commons-codec.version>
    <commons-dbcp2.version>2.7.0</commons-dbcp2.version>
    <commons-lang3.version>3.9</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.7.0</commons-pool2.version>

例如web模块：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 帮助我们导入web模块正常运行所依赖的组件 -->
</dependency>

Spring boot将所有的功能场景，抽取出来做成一个个独立的starters启动器。只要在项目里面引入了starters 这些场景启动器，所有依赖都会自动导入进来而且版本有Springboot控制。

SpringBoot启动main()方法

TkxtApplication类为SpringBoot应用的入口类，用@SpringBootApplication注解标注

/**
 * @SpringBootApplication:标注这是一个主程序类。
 */
@SpringBootApplication
public class TkxtApplication {
    
	//SpringBoot应用启动方法
    public static void main(String[] args) {
        SpringApplication.run(TkxtApplication.class, args);
    }

@SpringBootApplication：该注解标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用。

@SpringBootApplication = (默认属性)@Configuration + @EnableAutoConfiguration + @ComponentScan。

@ComponentScan注解介绍

@Filter注解介绍

@SpringBootConfiguration注解介绍

@EnableAutoConfiguration注解介绍

@Target，@Retention，@Documented和@Inherited注解在 java中的元注解中介绍过。

@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}
)}
)
@ConfigurationPropertiesScan
public @interface SpringBootApplication {

@ComponentScan

该注解的作用就是根据定义的扫描路径，把符合扫描规则的类装配到spring容器中，相当于之前的 <context:component-scan>。使用过spring框架的小伙伴都知道，spring里有四大注解：@Service,@Repository,@Component,@Controller用来定义一个bean.@ComponentScan注解就是用来自动扫描被这些注解标识的类，最终生成ioc容器里的bean．可以通过设置@ComponentScan　basePackages，includeFilters，excludeFilters属性来动态确定自动扫描范围，类型已经不扫描的类型．默认情况下:它扫描所有类型，并且扫描范围是@ComponentScan注解所在配置类包及子包的类。

属性	作用
basePackages与value	用于指定包的路径，进行扫描
basePackageClasses	用于指定某个类的包的路径进行扫描
nameGenerator	bean的名称的生成器
useDefaultFilters	是否开启对@Component，@Repository，@Service，@Controller的类进行检测
includeFilters	包含的过滤条件
excludeFilters	排除的过滤条件

@Filter

过滤器的扫描条件：

FilterType.ANNOTATION 按照注解的方式进行扫描.后面classes属性,为注解的类型,如:

//将标有@Controller注解的类排除在外不会加载到容器中来
@Filter(type=FilterType.ANNOTATION,classes= {Controller.class})

FilterType.ASSIGNABLE_TYPE,按照指定的类,进行过滤,后面的classes属性的值为"类名.class".如:

//只会加载BookService,以及BookService的子类或者其实现类
@Filter(type=FilterType.ASSIGNABLE_TYPE,classes= {BookService.class})

FilterType.CUSTOM,按照自己自定义的方式来进行过滤和筛选

//MyTypeFilter即为自己定义的匹配方法,其中MyTypeFilter类中的match方法的返回值为true时,为符合过滤条件,如果返回为false,则不符合过滤条件
@Filter(type=FilterType.CUSTOM,classes{MyTypeFilter.class})

@SpringBootConfiguration

SpringBoot的配置类，标注在某个类上表示这个类是SpringBoot的配置类。@SpringBootConfiguration继承自@Configuration，二者功能也一致，标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中，并且实例名就是方法名。

@EnableAutoConfiguration

开启自动配置功能，这样SpringBoot就可以帮我们自动配置。

@AutoConfigurationPackage注解介绍

@Import注解介绍

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

@AutoConfigurationPackage

自动配置类。将主配置类（@SpringBootApplication标注的类）的所在包及所有子包里面的组件扫描到spring容器中。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
// 通过Registrar类中的registerBeanDefinitions方法获取包名

@Import

@Import注解的作用是给spring容器导入组件，AutoConfigurationImportSelector类通过selectImports方法将所以需要导入的组件以全类名的方式返回，这些组件会被加载到spring容器中。AutoConfigurationImportSelector会给spring容器中导入非常多自动配置类的配置类（xxxAutoConfiguration）。

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

SpringBoot是如何知道导入那些自动配置类呢？其实SpringBoot在启动的时候会从类路径下的MEA-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作。

EnableAutoConfiguration指定的值

JAVAEE的整体解决方案和自动配置都在spring-boot-autoconfigure-2.2.0.RELEASE.jar

每一个自动配置类如何进行自动配置

以HttpEncodingAutoConfiguration自动配置类为例说一说自动配置类

@Configuration(
    proxyBeanMethods = false
)
// 表示这是一个配置类，和以前编写的配置文件作用一样，也可以给容器中添加组件
@EnableConfigurationProperties({HttpProperties.class})
// 启用指定类的ConfigurationProperties功能，将配置文件中对应的值和HttpProperties类的属性绑定起来，并把HttpProperties加入到Spring的容器中。
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
// Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效。判断当前应用是否是web应用，如果是当前配置类生效
@ConditionalOnClass({CharacterEncodingFilter.class})
// 判断当前项目有没有CharacterEncodingFilter这个类，这个类是SpringMVC中进行乱码解决的过滤器。（以前配置在web.xml中）
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
// 判断配置文件中是否存在spring.http.encoding.enabled配置,如果不存在判断也是成立的。即使我们配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的。
public class HttpEncodingAutoConfiguration {
    
    // properties和SpringBoot的配置文件映射了
    private final Encoding properties;
    
    // 只有一个有参构造器的情况下，参数的值会从容器中获取
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
    
    @Bean // 给容器中添加一个组件，这个组件中的某些值需要从properties中获取
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }

所有在配置文件中能配置的属性都是在xxxProperties类中封装着，配置文件中能配置什么就可以参照某个配置类中的属性。

@ConfigurationProperties(
    prefix = "spring.http"
)
// 从配置文件中获取指定的值和bean的属性就行绑定
public class HttpProperties {

总结：

根据当前的不同条件判断，决定这个配置类是否生效。
一旦这个配置类生效，这个配置类就会给容器中添加各种组件，这些组件的属性是从对应的Properties类中获取的，这些类里面的每个一个属性又是和配置文件绑定的。

初ོ心ꦿ℘.

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot为什么可以开箱即用

SpringBoot为什么可以开箱即用SpringBoot的场景启动器SpringBoot启动main()方法每一个自动配置类进行如何自动配置SpringBoot的场景启动器Spring Boot提供了很多场景启动器，都是以spring-boot-starter-xx作为命名的。spring-boot-starter-logging ：使用 Spring Boot 默认的日志框架 ...
复制链接

扫一扫