SpringBoot自动配置原理

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量304 收藏 3
点赞数 1
分类专栏： 笔记 文章标签： java spring boot spring debug
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaobai0720/article/details/109523642
版权

SpringBoot自动配置原理

本次演示使用版本：JDK1.8、maven3.6.0、idea2018
1、创建一个maven工程，直接点击下一步即可，无需勾选任何选项
2、填写GAV(groupId、artifactId、version)，填写完毕之后点击下一步

3、直接点击完成即可
4、因为我们需要创建一个SpringBoot的工程，所以我们要指定当前的parent为springBoot的子模块（开篇我们使用的是springBoot的2.2.2版本，一会儿为了比较与1版本的区别另外演示）
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
</parent>
5、引入web的启动器（可以不引入，直接演示自动配置原理，但是为了将springBoot的starter知识引入进来，所以在此演示）
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
6、自己手动创建包结构，且【随意】定义一个类来作为启动类，放在任意包下均可，图中类SpringBootAutoConfigApplication.java为我随意起的
7、启动类头上加一个@SpringBootApplication注解，在该类中添加一个main方法。

代码如下：

package cn.cmysz.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootAutoConfigApplication {

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

8、添加一个Controller到一个包下（但是这个包要在刚刚启动类的同级包或者是其子包下，原因何故稍后解释），写上几行代码：

package cn.cmysz.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController//该注解为@Controller 与 @ResponseBody的组合注解
public class HelloController {


    @GetMapping("/hello")
    public String hello(){
        return "Hello";
    }

}

9、点击启动类的 运行按钮发现控制台的输出

发现2.2.2版本的SpringBoot内置Tomcat，且版本为9.0.29，contextPath为’ '，端口号为8080

其中contextPath与端口号均可以在配置文件中配置。

总结：以上就是一个简单的SpringBoot工程的快速入手，接下来说明他的自动配置原理

首先如果你使用的是idea开发工具，那么按住Ctrl+鼠标左键点击刚才在启动类上面添加的@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 {

前四个注解为java自带的元注解。

下方的@SpringBootConfiguration注解表示该类是一个配置类，当然感兴趣的可以点进去这个注解内部，就会发现这个注解的头上除了有java的元注解之外，看见了Spring的@Configuration注解的存在。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

再下方的@EnableAutoConfiguration这个注解是整个自动配置的核心。

点进这个注解之后发现除了一样的有java自带的元注解之外的两个注解

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

核心注解：

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
其一：

点击@AutoConfigurationPackage注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

发现其为我们导入了AutoConfigurationPackages.Registrar.class这个静态内部类。

明显看见该内部类中的两个方法：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

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

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

}

其中最重要的方法：

registerBeanDefinitions(AnnotationMetadata metadata, 
                                    BeanDefinitionRegistry registry)

其内部调用了register方法，将断点打在此处。debug运行主方法。

步进该方法

我们可以通过两种方式看见我们所创建的包

​ 1、在控制台下方的变量中

​ 2、选中ClassUtils.getPackageName(metadata.getClassName()右键计算表达式

总结：SpringBoot在此处将我们所写的SpringBootAutoConfigApplication这个主启动类所在包及其子包下的所有类上被标注@Controller，@Service，@Repository，@Component这四个注解的类加载到IOC容器中。所以我们方才所写的Controller类要放在启动类同级包或者子包下。

注：此功能在SpringBoot1版本与2版本中相差甚微，故只做一次解释

其二：@Import(AutoConfigurationImportSelector.class)

该注解是为我们导入了一个自动配置导入选择器类AutoConfigurationImportSelector

点击AutoConfigurationImportSelector这个类之后发现此时会察觉到SpringBoot的1版本与2版本有所差距，现在我们先来介绍2.2.2版本情况：

点进来会看到有一个静态内部类AutoConfigurationGroup，在此类中有一个方法process

@Override
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
    Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
                 () -> String.format("Only %s implementations are supported, got %s",
                                     AutoConfigurationImportSelector.class.getSimpleName(),
                                     deferredImportSelector.getClass().getName()));
    AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
        .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}

将断点打在此处。点击getAutoConfigurationEntry这个方法

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(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 new AutoConfigurationEntry(configurations, exclusions);
	}

在此处打下断点。点击getCandidateConfigurations方法。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                                                                         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;
}

在此处打下断点，并且点击loadFactoryNames方法。

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

在此处打下断点，并且点击loadSpringFactories方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = cache.get(classLoader);
    if (result != null) {
        return result;
    }

    try {
        Enumeration<URL> urls = (classLoader != null ?
                                 classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                                 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        result = new LinkedMultiValueMap<>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            Properties properties = PropertiesLoaderUtils.loadProperties(resource);
            for (Map.Entry<?, ?> entry : properties.entrySet()) {
                String factoryTypeName = ((String) entry.getKey()).trim();
                for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                    result.add(factoryTypeName, factoryImplementationName.trim());
                }
            }
        }
        cache.put(classLoader, result);
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load factories from location [" +
                                           FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

点击FACTORIES_RESOURCE_LOCATION这个常量，即可看见：

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

此时就是使用的类加载器加载所有在META-INF目录下/spring.factories这个文件中的自动配置类，并且将他们加载进IOC容器中。

举例：

我们在继承parent模块时为我们引入的spring-boot-autoconfigure-2.2.2.RELEASE的META-INF下的spring.factories文件中所有的自动配置类都会将其加载进IOC文件，由此，便完成了SpringBoot的自动配置。

总结：以上是2版本的自动配置过程，接下来说明1版本。

首先将parent换成1版本，此处演示的是SpringBoot的1.5.10.RELEASE版本。

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

在@EnableAutoConfiguration这个注解的上方2版本引入的是：AutoConfigurationImportSelector，1版本引入的是：EnableAutoConfigurationImportSelector

在此类中我们可以看出：

@Deprecated
public class EnableAutoConfigurationImportSelector
		extends AutoConfigurationImportSelector {

	@Override
	protected boolean isEnabled(AnnotationMetadata metadata) {
		if (getClass().equals(EnableAutoConfigurationImportSelector.class)) {
			return getEnvironment().getProperty(
					EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class,
					true);
		}
		return true;
	}

}

起作用的是它的父类AutoConfigurationImportSelector，是不是有点眼熟，就是2版本的AutoConfigurationImportSelector，但是在此类中两个静态内部类全无。

在此类中起作用的是selectImports方法

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    try {
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        List<String> configurations = getCandidateConfigurations(annotationMetadata,
                                                                 attributes);
        configurations = removeDuplicates(configurations);
        configurations = sort(configurations, autoConfigurationMetadata);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return configurations.toArray(new String[configurations.size()]);
    }
    catch (IOException ex) {
        throw new IllegalStateException(ex);
    }
}

将断点打在此处，并且点击进getCandidateConfigurations方法。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
                                                  AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(), 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;
}

将断点打在此处，并且点击loadFactoryNames这个方法。

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    try {
        Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                                 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        List<String> result = new ArrayList<String>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            String factoryClassNames = properties.getProperty(factoryClassName);
            result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
        }
        return result;
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
                                           "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

此处又可看见FACTORIES_RESOURCE_LOCATION这个变量

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

自此以后流程全部一样都是将META-INF包下/spring.factories文件中的所有的自动配置类加载进IOC文件。

留下疑问：

1、我们知道SpringBoot是约定大于配置，那么它给我们默认配置了哪些？

2、我们可不可以修改？

3、那么多的自动配置类，我们要想修改为自己独特配置怎么做？假如我要修改mapper映射文件的地址怎么做？

4、我应该怎么写？就像开篇提到的contextPath和端口号，该怎么修改？

5、我还看见了：No active profile set, falling back to default profiles: default，这是什么？

6、自动配置类都放在了META-INFO/spring.factories文件中，我想自己定义一个属于自己的启动器该怎么做。

7、等等一系列问题。。请听下回。。。。

李沁男朋友
关注
专栏目录
Spring Boot 注册 Servlet 的三种方法
KHOST的博客
05-09 585
一、Spring Boot 注册 Spring Boot 提供了ServletRegistrationBean,FilterRegistrationBean,ServletListenerRegistrationBean三个类分别用来注册 Servlet, Filter, Listener，下面是 Servlet 的示例代码。 importjavax.servlet.http.Ht...
Spring Boot 注册中心的了解与学习
祭羽丶琉璃
09-10 907
今天，正好还是那个各项目不是写完了，老哥跟我们说，项目做完了就要进行一个代码评审，但是我还有很多老哥们一期写的代码不懂，比如说这个注册中心，所以一边上网查一下，一边跟着老哥的代码看一下这个东西的运行原理。 首先，要先提一下，我自己做的demo是根据这给大佬的博文一步一步来的，大佬讲的很详细，让我了解了注册中心的基本运行原理，要是有人也要看这个的运行原理，可以去大佬那里学习一下。下面是链接~~ ...
SpringBoot实现简单的登录注册（超级详细）
我的青春一去不复返
05-22 5万+
第一步：建立简单的项目 第二步：建一个简单的数据表 第三步：配置文件如下： pom.xml文件配置： <?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://mav
[设计模式]springboot优雅实现策略器模式(加入注册器实现)
YiQieFuCong的博客
09-17 983
策略模式组成是通过环境，策略，具体实现三部分组成，本文将环境（context）通过注册器实现，实现自动化注入容器中，维护起来更方便。策略模式（Strategy Pattern）是一种行为型设计模式，用于将不同的算法封装成独立的策略类，并使这些策略类可以相互替换，以实现在运行时动态地选择不同的算法。具体策略（Concrete Strategies）：具体策略类是策略模式的实现类，实现了策略接口或抽象类中定义的具体算法逻辑。当需要切换算法时，客户端可以动态地替换环境对象的策略对象，实现不同的算法逻辑。
springboot系列（一）-HelloWorld入门和原理分析
qianyou6026的博客
04-30 620
一、SpringBoot Helloworld 1、功能说明 发送一个请求，返回一个结果，最基本的web工程 2、搭建springboot工程 2.1、新建一个springboot-study工程 2.2、添加一个springboot-study-HelleWorld模块 2.2、在父pom里面添加依赖 <dependencies> &l...
浅谈springboot自动配置原理
08-25
浅谈SpringBoot自动配置原理 SpringBoot自动配置原理是SpringBoot框架的核心机制之一，它使得开发者可以更方便、更快速地构建应用程序。自动配置原理的核心是通过@EnableAutoConfiguration注解开启自动配置功能，...
01.SpringBoot自动配置原理.pdf
04-22
SpringBoot自动配置原理 SpringBoot自动配置原理是指SpringBoot框架中的一种机制，该机制可以自动配置应用程序所需的各种Bean和依赖项，使得开发者无需手动配置繁多的配置文件和pom坐标。下面将详细介绍SpringBoot...
SpringBoot自动配置原理.docx
11-14
3. **SpringBoot自动配置原理** 自动配置的实现主要基于以下机制： - **条件注解（@Conditional）**：Spring Boot的自动配置类通常会包含@Conditional注解，它允许配置类仅在满足特定条件时生效。例如，如果某个...
springboot自动装配原理
weixin_45947518的博客
11-28 205
文章目录springboot自动装配原理EnableAutoConfiguration注解AutoConfigurationPackage注解Import注解总结 springboot自动装配原理 1：启动类里只有一个注解@SpringBootApplication 2：点进去后有三个需要注意的注解，另外四个注解算是自定义注解的四件套： @SpringBootConfiguration：我们点进去以后可以发现底层是Configuration注解(使用Configuration配置类等同于XML文件)。
Springboot启动源码详解
刘建平Pinard的博客
03-13 1603
我们开发任何一个Spring Boot项目，都会用到如下的启动类 @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }
Spring Boot自动配置原理—简单源码分析
Frank的博客
05-20 446
文章目录引言环境准备Spring Boot 2.x 原理分析@SpringBootApplication:@SpringBootConfiguration@EnableAutoConfiguration@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)Spring Boot 1.5.x 分析总结 引言 众所...
Spring Boot 运行原理,自动配置
平凡之路无尽路的博客
07-12 627
我们可以先看看这段代码发生了什么事情SpringApplication.run(App.class, args);在创建SpringApplication的时候初始化了一些ApplicationContext和ApplicationListener主要通过getSpringFactoriesInstances方法来实现上面的SpringFactoriesLoader.loadFactoryName...
[Spring Boot] 4. Spring Boot实现自动配置的原理
不忘初心，好好沉淀
08-27 1万+
入口注解类@EnableAutoConfiguration@SpringBootApplication注解中包含了自动配置的入口注解：@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration
SpringBoot之@EnableAutoConfiguration注解
热门推荐
charming的专栏
05-07 18万+
首先Spring Boot项目中都会如下启动类： @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } 从...
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 440
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1294
项目功能：商品分类,商品信息,用户。
Hadoop生态圈框架部署（二）- 配置IP地址映射为主机名及免密登录
zcs2312852665的博客
10-29 1250
介绍在虚拟机hadoop1、hadoop2和hadoop3配置IP地址映射为主机名配置虚拟机hadoop1、hadoop2和hadoop3互相免密登录。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1057
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
SpringBoot 自动配置原理
03-28
SpringBoot自动配置原理简述 SpringBoot自动配置是SpringBoot的一大特色，它提供了一种简洁的方式来配置应用程序。在SpringBoot中，我们可以通过添加特定的依赖来自动配置应用程序的各种组件，例如数据源、日志、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值