SpringBoot

最新推荐文章于 2025-07-21 23:35:20 发布

chenkui5098

最新推荐文章于 2025-07-21 23:35:20 发布

阅读量92

点赞数

CC 4.0 BY-SA版权

文章标签： java

原文链接：https://my.oschina.net/u/2286010/blog/3089769

SpringBoot下如何导包

SpringBoot的pom依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

点进去：

<activemq.version>5.15.9</activemq.version>
<antlr2.version>2.7.7</antlr2.version>
<appengine-sdk.version>1.9.73</appengine-sdk.version>
<artemis.version>2.6.4</artemis.version>
<aspectj.version>1.9.2</aspectj.version>
<assertj.version>3.11.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.9.12</byte-buddy.version>
<caffeine.version>2.6.2</caffeine.version>
<cassandra-driver.version>3.6.0</cassandra-driver.version>
... ...

很明显是个版本仲裁中心，即SpringBoot已经帮我们配置好了可能会用到的依赖的版本，以后再添加依赖时（如果是仲裁中心里的），就不用再写版本号。

但我们需要导入某个依赖时，只需要导入一个场景启动器，例如：

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

他会帮我们导入相应场景所欲要的所有jar包：

<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.1.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.1.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.1.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    ... ...
</dependencies>

SpringBoot自动配置过程：

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

点进这个@SpringBootApplication：

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

@SpringBootConfiguration：SpringBoot的配置类注解，相当于Spring的Configuration注解（其实里面也是这么实现的）；

@EnableAutoConfiguration：开启自动配置功能（以前我们需要配置的东西，SpringBoot都给我们自动配置好）。

——点进这个@EnableAutoConfiguration：

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {... ...}

————点进这个@AutoConfigurationPackage：

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

——————点进这个Registrar.class：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());
        }

        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
        }
}

——————这个metadata指的就是@SpringBootApplication这个注解，而getPackageName()拿到的就是@SpringBootApplication标注的类所在的包名：

——————即com.hxm.campuassist。所以@AutoConfigurationPackage这个注解的含义就是将@SpringBootApplication标注的类所在包下的所有组件扫描到Spring容器中。

————点进这个@Import({AutoConfigurationImportSelector.class})：

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());
        }
    }

    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }
}

————通过打断点，发现这个List configurations里加载了很多配置类：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        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;
}
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();
... ...
}

————打开META-INF/spring.factories：

————由此可见，SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置的工作，省去我们手动配置的过程。例如org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration：

————可以看到其往容器中注册了很多组件。

总结：spring-boot维护一个spring-boot-autoconfigure jar包，其下META-INF中的spring.factories列出了所有的AutoConfiguration类，spring-boot启动的时候通过注解将这些自动配置类导入到spring容器中，这些配置类都用@Configuration标注，负责自动配置。

yaml注值 @ConfigurationProperties、@Value

注意，@ConfigurationProperties标注的类如果不在容器里（没有用@Component标注）则不会注值成功。

@PropertySource @ImportResource @Configuration

加载一个外部的properties：

用xml的方式给容器添加一个组件：

用注解的方式给容器添加组件：

SpringBoot自动配置原理（AutoConfiguration类的作用）

application.properties中都可以配什么属性，有两种方法可以确认。

1、官方文档里给出了所有可配置的属性

https://docs.spring.io/spring-boot/docs/2.1.7.RELEASE/reference/html/common-application-properties.html

2、进入相应的AutoConfiguration类确认：

以HttpEncodingAutoConfiguration为例

//声明这是个配置类，可以给容器添加组件
@Configuration 
//启用指定类的@ConfigurationProperties注解（将properties中的值注入到类中）,
//properties中可以配什么，就取决于这个类里有什么属性
@EnableConfigurationProperties({HttpProperties.class})
//判断这是否是个web应用
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
//判断指定类是否在容器里
@ConditionalOnClass({CharacterEncodingFilter.class})
//判断properties中是否配置了这些属性
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    //没配也可以
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    private final Encoding properties;

    //将上面@EnableConfigurationProperties指定的注入了值的HttpProperties拿过来用
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

    //给容器中添加组件
    @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里可以配什么，就看这个类里有什么
@ConfigurationProperties(
    prefix = "spring.http"
)
public class HttpProperties {
    private boolean logRequestDetails;
    private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();

    public HttpProperties() {
    }

    public boolean isLogRequestDetails() {
        return this.logRequestDetails;
    }

    public void setLogRequestDetails(boolean logRequestDetails) {
        this.logRequestDetails = logRequestDetails;
    }

    public HttpProperties.Encoding getEncoding() {
        return this.encoding;
    }

    public static class Encoding {
        public static final Charset DEFAULT_CHARSET;
        private Charset charset;
        private Boolean force;
        private Boolean forceRequest;
        private Boolean forceResponse;
        private Map<Locale, Charset> mapping;

        public Encoding() {
            this.charset = DEFAULT_CHARSET;
        }
... ...
}

总结：