SpringBoot入门(二)自动配置原理

最新推荐文章于 2024-04-20 04:21:21 发布
最新推荐文章于 2024-04-20 04:21:21 发布
阅读量732 收藏 2
点赞数 1
分类专栏： java框架 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxyneymar/article/details/122533107
版权

目录

第四章 自动配置原理入门

4.1 引导加载自动配置类

4.1.1 @SpringBootConfiguration

4.1.2 @ComponentScan

4.1.3 @EnableAutoConfiguration

        4.1.3.1 @AutoConfigurationPackage

        4.1.3.2 @Import(AutoConfigurationImportSelector.class)

4.2 按需开启自动配置项

4.3 实例展示

4.3.1 DispatcherServlet

4.3.2 CharacterEncodingFilter

4.4 总结

4.5 SpringBoot开发步骤

第五章 开发小技巧

5.1 Lombok

5.2 dev-tools

5.3 Spring Initailizr(项目初始化向导)

5.3.1 选择开发场景

5.3.2 目录形式

5.3.3 自动生成主程序类(主配置类)

5.3.4 根据场景选择自动导入依赖

第四章 自动配置原理入门

//@SpringBootApplication
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.xxy.boot")
public class MainApplication {//主程序类
}

4.1 引导加载自动配置类

   @SpringBootApplication注解中的核心：

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

4.1.1 @SpringBootConfiguration

   @SpringBootConfiguration注解的实现用到了注解@Configurantion。代表当前是一个配置类。

@Configuration
public @interface SpringBootConfiguration {
}

4.1.2 @ComponentScan

   指定扫描哪些路径下的Spring注解。

4.1.3 @EnableAutoConfiguration

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

4.1.3.1 @AutoConfigurationPackage

   指定了默认的包规则。

import org.springframework.boot.autoconfigure.AutoConfigurationPackages.Registrar;

@Import({Registrar.class})//给容器中导入一个组件
public @interface AutoConfigurationPackage {
}

//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来，即主程序类MainApplication所在的包下
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }
        //给容器批量注册组件
        //AnnotationMetadata表示注解的源信息，标在哪个类上，在这里就是标来MainApplication这个主程序类上
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            //第二个参数就是指定了哪些包下的spring注解会被注册，这里写的就是主程序类的包下
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }

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

4.1.3.2 @Import(AutoConfigurationImportSelector.class)

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    //这个类当中的一个方法
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }
}
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            //会导入很多默认组件
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            //configurations里面包括了那些默认组件
            //getCandidateConfigurations获取所有的候选配置
            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.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        //SpringFactoriesLoader：spring工厂加载器
        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<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }
//最后得到一个Map<String, List<String>>
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();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryImplementationName = var9[var11];
                            result.add(factoryTypeName, factoryImplementationName.trim());
                        }
                    }
                }

                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

1、利用getAutoConfigurationEntry(annotationMetadata)方法给容器中批量导入一些组件

2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类

3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)方法得到所有的组件

4、从META-INF/spring.factories位置来加载一个文件。

        默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件

        spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories(这个包内就有上面说到的configurations内的127个自动配置类)

        文件里面写死固定了spring-boot一启动就要给容器中加载的所有配置类

4.2 按需开启自动配置项

   虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
   按照条件装配规则(@Conditional)，最终会按需配置。

4.3 实例展示

4.3.1 DispatcherServlet

   比如看这个DispatcherServletAutoConfiguration：

@AutoConfigureOrder(-2147483648)
@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({DispatcherServlet.class})
@AutoConfigureAfter({ServletWebServerFactoryAutoConfiguration.class})
public class DispatcherServletAutoConfiguration {
    
    @Configuration(
        proxyBeanMethods = false
    )
    @Conditional({DispatcherServletAutoConfiguration.DefaultDispatcherServletCondition.class})
    @ConditionalOnClass({ServletRegistration.class})
    @EnableConfigurationProperties({WebMvcProperties.class})
    protected static class DispatcherServletConfiguration {
        protected DispatcherServletConfiguration() {
        }

        @Bean(
            name = {"dispatcherServlet"}
        )
        public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
            DispatcherServlet dispatcherServlet = new DispatcherServlet();
            dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
            dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
            dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
            dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
            dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
            return dispatcherServlet;
        }

        @Bean
        @ConditionalOnBean({MultipartResolver.class})//容器中有这个类型的组件
        @ConditionalOnMissingBean(
            name = {"multipartResolver"}
        )//容器中没有这个名字multipartResolver的组件
        public MultipartResolver multipartResolver(MultipartResolver resolver) {//文件上传解析器
            //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
            //SpringMVC配置时一定要叫multipartResolver。
            //这里条件加上了不叫这个名字，也能找到这个文件上传解析器。防止有些用户配置的文件上传解析器不符合规范
            //此时再重新返回，名字又注册为了multipartResolver，因为方法名就是id
			// Detect if the user has created a MultipartResolver but named it incorrectly
            return resolver;
        }
    }
}

   第一个dispatcherServlet()方法就会在满足条件的情况下在容器中创建出一个DispatcherServlet的实例，并且这个实例的id就是dispatcherServlet。这样我们就不需要像springmvc一样自己在配置文件中手动配置，springboot的底层帮我们配置好了。

   第二个方法的条件针对用户配置的名字可能不符合规范，但是springboot底部能够读到这个对象并返回一个符合规范的id。

4.3.2 CharacterEncodingFilter

   再看看HttpEncodingAutoConfiguration：

@Configuration(
    proxyBeanMethods = false
)
@EnableConfigurationProperties({ServerProperties.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})
@ConditionalOnProperty(
    prefix = "server.servlet.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean//如果用户没有配置这个bean，springboot底层会自动配置
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.web.servlet.server.Encoding.Type.RESPONSE));
        return filter;
    }
}

   自动配置了字符过滤器CharacterEncodingFilter。

   SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先。

4.4 总结

  • SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
  • 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿，xxxProperties和配置文件进行了绑定
  • 生效的配置类就会给容器中装配很多组件
  • 只要容器中有这些组件，相当于这些功能就有了
  • 定制化配置(修改默认实现)
    • 用户直接自己@Bean替换底层的组件

    • 用户去看这个组件是获取的配置文件什么值就去修改

   整体流程：

xxxxxAutoConfiguration ---> 组件 ---> xxxxProperties里面拿值 ----> application.properties

4.5 SpringBoot开发步骤

  • 引入场景依赖：Developing with Spring Boot
  • 查看自动配置了哪些(选做)
    • 自己分析，引入场景对应的自动配置一般都生效了
    • 配置文件application.properties中加入debug=true开启自动配置报告。Negative(不生效)\Positive(生效)
  • 是否需要修改
    • 参照文档修改配置项
    • 自定义加入或者替换组件
      • @Bean、@Component...
    • 自定义器 XXXXXCustomizer

第五章 开发小技巧

5.1 Lombok

   简化JavaBean开发。Lombok会自动帮我们在编译时实现get、set方法，不需要手动写了。

   引入依赖：

<dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
</dependency>

   在IDEA中安装lombok插件。之后直接使用注解即可。

@NoArgsConstructor //无参构造器
@AllArgsConstructor //全参构造器
@ToString //toString方法
@Data //get、set方法不需要手动写了
@EqualsAndHashCode //equals方法和hashCode方法
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
    private String brand;
    private Integer price;
}

   还可以简化日志开发：

@Slf4j //日志
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(@RequestParam("name") String name){
        
        log.info("请求进来了....");
        
        return "Hello, Spring Boot 2!"+"你好："+name;
    }
}

5.2 dev-tools

   实现热更新。Restart。

   引入依赖：

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

   项目或者页面修改以后：Ctrl+F9。

5.3 Spring Initailizr(项目初始化向导)

5.3.1 选择开发场景

5.3.2 目录形式

5.3.3 自动生成主程序类(主配置类)

5.3.4 根据场景选择自动导入依赖

PS：根据尚硅谷课程整理，如有侵权，联系删除

xxyneymar
关注
专栏目录
EnableAutoConfiguration源码解析
翻身已碰头的博客
10-30 1138
Springboot项目中最核心也是入门级的注解就是@SpringBootApplication，这是由@EnableAutoConfiguration、@ComponentScan和@Configuration组成的一个组合注解。 接下来我们将分析其中的EnableAutoConfiguration注解的源码。 springboot的一大特性就是“约定大于配置”，EnableAutoConfig...
SpringBoot 源码阅读（4）：@EnableAutoConfiguration
qq_42323598的博客
07-27 305
@EnableAutoConfiguration 该注解用于自动配置，而自动配置是大部分人使用SpringBoot开发的主要原因。 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @AutoConfigurationPackage @Import(AutoConfigurationImportSelector.class) public @interface EnableAutoConf
springboot @EnableAutoConfiguration自动配置超详解
mayfly_hml的博客
11-26 1987
springboot相关逻辑 1. main启动类 首先就是springboot项目习以为常的main方法调用SpringApplication.run将标注有@SpringBootApplication注解的class对象作为参数传递。SpringBootApplication注解是个组合注解，主要组合了@Configuration，@EnableAutoConfiguration,@Import(AutoConfigurationImportSelector.class)， @ComponentScan
@EnableAutoConfiguration
lqbz的总结
11-14 560
在引导类的@SpringBootApplication下有@EnableAutoConfiguration 继续查看有@Import导入自动配置AutoConfigurationImportSelector 继续查看下面类的selectImports方法，返回字符串数组，在数组中定义了很多需要被加载的类。 重点查看getAutoConfigurationEntry方法中的getCandidateConfigurations方法。此方法返回一个list集合，集合中都是configurations。
springboot源码分析-自动配置原理入门
01-13
自动配置原理入门 1 引导加载自动配置类 @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), ...
Springboot入门到精通完整版.pdf
05-08
Spring Boot 是一个由 Pivotal 团队开发的框架，其设计目的是简化...通过阅读《Springboot入门到精通【完整版】》，你可以系统地学习这个框架，通过实例和实践练习加深理解，逐步成为一名精通Spring Boot的开发者。
一、SpringBoot2基础入门--07-SpringBoot自动配置原理
最新发布
2401_84413531的博客
04-20 738
1、自动配置原理1.1、springboot自动配置底层常用注解。
基于SpringBoot核心原理(自动配置、事件驱动、Condition)
09-07
接下来，我们转向自动配置原理。 自动配置原理： 自动配置是SpringBoot的一大特色，它能根据项目中的依赖自动配置相应的bean。这个过程主要由`@EnableAutoConfiguration`注解触发。SpringBoot通过`@...
SpringBoot2的最佳实践 SpringBoot2基础入门+底层注解+自动配置+高级特性与原理解析
06-23
SpringBoot2的最佳实践课程的技术含量...├─07、基础入门-SpringBoot-自动配置特性.mp4 ├─08、底层注解-@Configuration详解.mp4 ├─09、底层注解-@Import导入组件.mp4 ├─10、底层注解-@Conditional条件装配.mp
EnableAutoConfiguration自动配置使用
zhglhy的专栏
02-18 663
EnableAutoConfiguration 自动配置
自动配置@EnableAutoConfiguration
joy_tom的博客
07-08 4406
在spring中有很多Enable开头的注解，作用就是@Import来收集并注册特定的场景相关的bean，并且加入到IOC容器。 @EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到IOC容器中。 在这里可能会好奇的是为什么@SpringBootApplication必须跟业务包放在同一级路劲上，这里需要了解的一个注解是：@AutoConfigurationPackage 在Registrar.class类中 .
深入分析EnableAutoConfiguration
Leon_Jinhai_Sun的博客
10-31 1242
EnableAutoConfiguration的主要作用其实就是帮助springboot应用把所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器中。 再回到EnableAutoConfiguration这个注解中，我们发现它的import是这样 @Import(AutoConfigurationImportSelector.class) public @interface EnableAutoConfiguration { ...
SpringBoot 自动配置@EnableAutoConfiguration
weixin_44612246的博客
10-25 707
SpringBoot自动配置 @EnableAutoConfiguration
总结：Spring boot之@EnableAutoConfiguration
热门推荐
w2009211777的专栏
01-20 1万+
一、@EnableAutoConfiguration的作用 简单点说就是Spring Boot根据依赖中的jar包，自动选择实例化某些配置，配置类必须有@Configuration注解。 说白了，还是实例化对象，只是实例化的是非main类之外的包。 另外，我们也可以按照自动装配的规范自己定义装配的类。 二、@EnableAutoConfiguration和@Configuration的区别 @Configuration：表示作用的类是个配置类。我们平时也会写配置类，比如我们系统中的Data..
SpringBoot核心运行原理解析之-------@EnableAutoConfiguration
qq_41934990的博客
05-16 4367
下面通过一张图来从整体了解AutoConfigurationImportSelector的核心功能及流程，然后再对照源码看具体的功能实现。当AutoConfigurationImportSelector被@Import注解引入之后，它的selectImports方法会被调用并执行其实现的自动装配逻辑。selectImports方法涵盖了组件自动装配的所有的处理逻辑。if(!if(!
【SpringBoot 自动配置】-EnableAutoConfiguration 注解
qq_33827423的博客
02-21 1371
续接上回与,在前面笔者分析了在 SpringBoot 自动装配中的最重要的两个注解类，@Condition与哎~说到这里，那首先我们跟随笔者一起先回忆一下这两个注解的在 SpringBoot 当中充当什么角色呢？
enableautoconfiguration_深入理解EnableAutoConfiguration原理
weixin_39519619的博客
11-30 431
文章来源：https://my.oschina.net/lt0314/blog/4335365源码分析@EnableAutoConfiguration在SpringBoot中的加载和实例化过程万里长征第一步，我们先理解下什么是EnableAutoConfiguration?什么是EnableAutoConfiguration注解？在哪？org.springframework.boot.a...
SpringBoot核心机制五、EnableAutoConfiguration属性自动装配
roykingw的专栏
04-30 1377
文章目录一、SpringBoot自动装配的两架马车1、@Import注解2、@Conditional注解2.1 Spring中的@Conditional条件注入机制2.2 SpringBoot提供的增强版条件注入机制二、SpringBoot自动装配核心机制解读三、SpringBoot当中的默认配置类1、spring-boot-autoconfigure中关于数据库的几个配置：2、SpringBoot中关于GitProperties的配置 所有调试基于spring-boot-2.4.5版本 ​ 现在终于到
SpringBoot入门：自动配置与开发实践
整个章节提供了丰富的实践指导，帮助读者理解SpringBoot自动配置的工作原理，并教会他们如何有效地利用这一机制来构建自己的SpringBoot应用。阅读完这部分内容后，读者将能够掌握如何配置和管理SpringBoot项目的自动...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值