SpringBoot自动配置原理再理解以及自定义starter

自动配置原理：

先总结下结论：

自动配置的原理大致是Springboot在启动时通过spring.factories中的xxxAutoConfiguration找到xxxProperties类进行
默认自动配置(xxxAutoConfiguration类中有很多@Conditional的派生类作用是：当条件不成立时，自动配置会失败)，由于xxxProperties类中有@ConfigurationProperties注解会与application.yml配置文件绑定，因此我们可以在application.yml中覆盖掉某些默认配置！

分析自动配置原理:

通过依次点开@SpringBootApplication->@EnableAutoConfiguration->AutoConfigurationImportSelector.class->getAutoConfigurationEntry方法->getCandidateConfigurations方法->loadFactoryNames方法->loadSpringFactories方法

->找到FACTORIES_RESOURCE_LOCATION变量："META-INF/spring.factories"；

我们找到了spring-boot-autoconfigure-2.5.2下的spring.factories文件，如下图所示：

image-20210720155100427

我们以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理；

//表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件；
@Configuration 

//启动指定类的ConfigurationProperties功能；
  //进入这个HttpProperties查看，将配置文件中对应的值和HttpProperties绑定起来；
  //并把HttpProperties加入到ioc容器中
@EnableConfigurationProperties({HttpProperties.class}) 

//Spring底层@Conditional注解
  //根据不同的条件判断，如果满足指定的条件，整个配置类里面的配置就会生效；
  //这里的意思就是判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnWebApplication(
    type = Type.SERVLET
)

//判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
@ConditionalOnClass({CharacterEncodingFilter.class})

//判断配置文件中是否存在某个配置：spring.http.encoding.enabled；
  //如果不存在，判断也是成立的
  //即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)

public class HttpEncodingAutoConfiguration {
    //他已经和SpringBoot的配置文件映射了
    private final Encoding properties;
    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }
    
    //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @Bean
    @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;
    }
    //。。。。。。。
}

一句话总结 ：根据当前不同的条件判断，决定这个配置类是否生效！

  • 一但这个配置类生效；这个配置类就会给容器中添加各种组件；
  • 这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
  • 所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；
  • 配置文件能配置什么就可以参照某个功能对应的这个属性类
//从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(prefix = "spring.http") 
public class HttpProperties {
    // .....
}

我们去配置文件里面试试前缀，看提示！

image-20210720160138156

这就是自动装配的原理！

总结：

1、SpringBoot启动会加载大量的自动配置类

2、我们看我们需要的功能有没有在SpringBoot默认写好的自动配置类当中；

3、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件存在在其中，我们就不需要再手动配置了）

4、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们只需要在配置文件中指定这些属性的值即可；

xxxxAutoConfigurartion：自动配置类；给容器中添加组件

xxxxProperties:封装配置文件中相关属性；

了解：@Conditional

了解完自动装配的原理后，我们来关注一个细节问题，自动配置类必须在一定的条件下才能生效；

@Conditional派生注解（Spring注解版原生的@Conditional作用）

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；

image-20210720160314651

那么多的自动配置类，必须在一定的条件下才能生效；也就是说，我们加载了这么多的配置类，但不是所有的都生效了。

我们怎么知道哪些自动配置类生效？

我们可以通过在application.yaml/properties中启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；

#开启springboot的调试类
debug=true

Positive matches:（自动配置类启用的：正匹配）

Negative matches:（没有启动，没有匹配成功的自动配置类：负匹配）

Unconditional classes: （没有条件的类）

自定义starter

我们分析完毕了源码以及自动装配的过程，我们可以尝试自定义一个启动器来玩玩！

说明：

启动器模块是一个 空 jar 文件，仅提供辅助性依赖管理，这些依赖可能用于自动装配或者其他类库；

命名归约：

官方命名：

  • 前缀：spring-boot-starter-xxx
  • 比如：spring-boot-starter-web....

自定义命名：

  • xxx-spring-boot-starter
  • 比如：mybatis-spring-boot-starter

编写启动器

1、在IDEA中新建一个空项目 spring-boot-starter-diy
image-20210720162125328

2、新建一个普通Maven模块：kuang-spring-boot-starter

image-20210720162448363

3、新建一个Springboot模块：kuang-spring-boot-starter-autoconfigure

image-20210720162739787

4、在我们的 starter 中 导入 autoconfigure 的依赖！

image-20210720163150209

5、将 autoconfigure 项目下多余的文件都删掉，Pom中只留下一个 starter，这是所有的启动器基本配置！

image-20210720164020201

6、首先在autoconfigure 项目中编写一个自己的服务HelloService ：

package com.kuang;

public class HelloService {

    HelloProperties helloProperties;

    public HelloProperties getHelloProperties() {
        return helloProperties;
    }

    public void setHelloProperties(HelloProperties helloProperties) {
        this.helloProperties = helloProperties;
    }

    public String sayHello(String name){
        return helloProperties.getPrefix() + name + helloProperties.getSuffix();
    }

}

7、再编写一个HelloProperties 配置类

package com.kuang;

import org.springframework.boot.context.properties.ConfigurationProperties;

// 前缀 kuang.hello
@ConfigurationProperties(prefix = "kuang.hello")
public class HelloProperties {

    private String prefix;
    private String suffix;

    public String getPrefix() {
        return prefix;
    }

    public void setPrefix(String prefix) {
        this.prefix = prefix;
    }

    public String getSuffix() {
        return suffix;
    }

    public void setSuffix(String suffix) {
        this.suffix = suffix;
    }
}

8、最后编写我们的自动配置类HelloServiceAutoConfiguration：

package com.kuang;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnWebApplication //web应用生效
@EnableConfigurationProperties(HelloProperties.class)
public class HelloServiceAutoConfiguration {

    @Autowired
    HelloProperties helloProperties;

    @Bean
    public HelloService helloService(){
        HelloService service = new HelloService();
        service.setHelloProperties(helloProperties);
        return service;
    }

}

9、最后在autoconfigure 项目中的resources目录下编写一个自己的 META-INF\spring.factories：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.kuang.HelloServiceAutoConfiguration

image-20210720165918617

10、编写完成后，可以安装到maven仓库中！

image-20210720170410413

总结：

个人总结来说：自定义一个starter需要起一个空的项目，然后再里面新建一个普通maven项目模块和一个springboot项目模块，maven项目的pom中国要引入springboot项目依赖，而在springboot项目里要写xxxAutoConfiguration类、xxxProperties类以及自己要对外提供的服务，最后别忘了在resources目录下的META-INF/spring.factories中写上想对应的xxxAutoConfiguration就行！

新建一个项目测试我们自己写的启动器

1、新建一个SpringBoot 项目

2、导入我们自己写的启动器

<dependency>
    <groupId>com.kuang</groupId>
    <artifactId>kuang-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

3、编写一个 HelloController 进行测试我们自己的写的接口！

package com.kuang.testautocongure;

import com.kuang.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    HelloService helloService;

    @RequestMapping("/hello")
    public String hello(){
        return helloService.sayHello("zxc");
    }

}

4、编写配置文件 application.properties

kuang.hello.prefix="ppp"
kuang.hello.suffix="sss"

5.启动项目进行测试，结果成功!

image-20210720171910989

这就是自定义starter!

本项目代码在码云的spring-boot-starter-diy项目和testAutoCongure项目中，之后会给出码云地址！

posted @ 2021-07-20 17:26  一万年太久只争朝夕  阅读(1063)  评论(0)  编辑  收藏  举报
// 侧边栏目录 // https://blog-static.cnblogs.com/files/douzujun/marvin.nav.my1502.css