SpringBoot原理分析

最新推荐文章于 2023-12-12 10:47:35 发布
最新推荐文章于 2023-12-12 10:47:35 发布
阅读量547 收藏 1
点赞数 1
分类专栏： 面试复习 文章标签： SpringBoot原理分析 SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40378034/article/details/104097635
版权

本文采用SpringBoot版本2.2.4.RELEASE

一、父项目

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

spring-boot-starter-parent的父项目：

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.2.4.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
  </parent>

spring-boot-dependencies来真正管理SpringBoot应用里面的所有依赖版本

二、探索SpringApplication启动Spring

@SpringBootApplication//标明是SpringBoot应用，可以开启自动配置的功能
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);//启动SpringBoot应用
    }

}

	public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
		return run(new Class<?>[] { primarySource }, args);
	}

	public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
	//创建SpringApplication对象，并执行运行
    return new SpringApplication(primarySources).run(args);
	}

	public ConfigurableApplicationContext run(String... args) {
    	//创建StopWatch对象，并启动。StopWatch主要用于简单统计run启动过程的时长
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
    	//获得SpringApplicationRunListener的数组，并启动监听
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
      		//创建ApplicationArguments对象
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      		//加载属性配置。执行完成后，所有的environment的属性都会加载进来，包括application.properties和外部的属性配置
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
			Banner printedBanner = printBanner(environment);
      		//创建Spring容器
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
      		//调用所有初始化类的initialize方法
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
      		//初始化Spring容器
			refreshContext(context);
      		//执行Spring容器的初始化的后置逻辑。默认实现为空
			afterRefresh(context, applicationArguments);
      		//停止StopWatch统计时长
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
      		//通知SpringApplicationRunListener的数组，Spring容器启动完成
			listeners.started(context);
      		//调用ApplicationRunner或者CommandLineRunner的运行方法
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
      		//通知SpringApplicationRunListener的数组，Spring容器运行中
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

createApplicationContext()创建Spring容器：

	protected ConfigurableApplicationContext createApplicationContext() {
    	//根据webApplicationType类型，获得ApplicationContext类型
		Class<?> contextClass = this.applicationContextClass;
		if (contextClass == null) {
			try {
				switch (this.webApplicationType) {
				case SERVLET:
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
					break;
				case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
					break;
				default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
			}
		}
    	//创建ApplicationContext对象
		return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

prepareContext()调用所有初始化类的initialize方法：

	private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
			SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    	//设置context的environment属性
		context.setEnvironment(environment);
    	//设置context的一些属性
		postProcessApplicationContext(context);
    	//初始化ApplicationContextInitializer
		applyInitializers(context);
    	//通知SpringApplicationRunListener的数组，Spring容器准备完成
		listeners.contextPrepared(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		//设置beanFactory的属性
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof DefaultListableBeanFactory) {
			((DefaultListableBeanFactory) beanFactory)
					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
		}
		//加载BeanDefinition
		Set<Object> sources = getAllSources();
		Assert.notEmpty(sources, "Sources must not be empty");
		load(context, sources.toArray(new Object[0]));
    	//通知SpringApplicationRunListener的数组，Spring容器加载完成
		listeners.contextLoaded(context);
	}

	protected void load(ApplicationContext context, Object[] sources) {
		if (logger.isDebugEnabled()) {
			logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
		}
    	//执行BeanDefinition加载
		BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
    	//设置loader的属性
		if (this.beanNameGenerator != null) {
			loader.setBeanNameGenerator(this.beanNameGenerator);
		}
		if (this.resourceLoader != null) {
			loader.setResourceLoader(this.resourceLoader);
		}
		if (this.environment != null) {
			loader.setEnvironment(this.environment);
		}
    	//执行BeanDefinition加载
		loader.load();
	}

三、Starter自动化配置原理

@SpringBootApplication注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited//使用@Inherite注解声明出来的自定义注解，在使用此自定义注解时，如果注解在类上面时，子类会自动继承此注解;否则的话，子类不会继承此注解
@SpringBootConfiguration//标记这是一个SpringBoot配置类
@EnableAutoConfiguration//开启自动配置功能
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

@EnableAutoConfiguration注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage//自动配置包，它会获取主程序类所在的包路径，并将包路径（包括子包）下的所有组件注册到IOC容器中
@Import(AutoConfigurationImportSelector.class)//导入自动配置相关的资源
public @interface EnableAutoConfiguration {

AutoConfigurationImportSelector类：

getCandidateConfigurations()获得符合条件的配置类的数组：

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    	//加载指定类型EnableAutoConfiguration对应的，在META-INF/spring.factories里的类名的数组
		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;
	}

在这里插入图片描述

每一个*AutoConfiguration类加入到容器中，用他们来做自动配置

以HttpEncodingAutoConfiguration（Http编码自动配置）为例：

@Configuration(proxyBeanMethods = false)//表明这是一个配置类
@EnableConfigurationProperties(HttpProperties.class)//启用指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到IOC容器中
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)//Spring底层@ConditionalOn注解，根据不同的条件，如果满足指定的条件，整 个配置类里面的配置才会生效； 判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有这个类 CharacterEncodingFilter：SpringMVC中进行乱码解决的过滤器
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)//判断配置文件中是否存在某个配置spring.http.encoding.enabled;如果不存在判断也是成立的
//matchIfMissing=true:即使配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的
public class HttpEncodingAutoConfiguration {

	private final HttpProperties.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(Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
		return filter;
	}

一旦配置类生效，这个配置类就会给容器中添加各种组件，这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的

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

​

四、Conditional机制实现

@Conditional注解根据特定条件来控制bean的创建行为

@Conditional扩展注解作用（判断是否满足当前指定条件）
@ConditionalOnJava系统的java版本是否符合要求
@ConditionalOnBean容器中存在指定Bean
@ConditionalOnMissingBean容器中不存在指定Bean
@ConditionalOnExpression满足SpEL表达式指定
@ConditionalOnClass系统中有指定的类
@ConditionalOnMissingClass系统中没有指定的类
@ConditionalOnSingleCandidate容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty系统中指定的属性是否有指定的值
@ConditionalOnResource类路径下是否存在指定资源文件
@ConditionalOnWebApplication当前是web环境
@ConditionalOnNotWebApplication当前不是web环境
@ConditionalOnJndiJNDI存在指定项

以@ConditionalOnProperty注解为例：

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.METHOD })
@Documented
@Conditional(OnPropertyCondition.class)
public @interface ConditionalOnProperty {

OnPropertyCondition类：

getMatchOutcome()方法获得匹配结果：

	@Override
	public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
    	//获得@ConditionalOnProperty注解的属性
		List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
				metadata.getAllAnnotationAttributes(ConditionalOnProperty.class.getName()));
    	//存储匹配和不匹配的结果消息结果
		List<ConditionMessage> noMatch = new ArrayList<>();
		List<ConditionMessage> match = new ArrayList<>();
    	//遍历annotationAttributes属性数组，逐个判断是否匹配，并添加到结果
		for (AnnotationAttributes annotationAttributes : allAnnotationAttributes) {
			ConditionOutcome outcome = determineOutcome(annotationAttributes, context.getEnvironment());
			(outcome.isMatch() ? match : noMatch).add(outcome.getConditionMessage());
		}
    	//如果有不匹配的，则返回不匹配
		if (!noMatch.isEmpty()) {
			return ConditionOutcome.noMatch(ConditionMessage.of(noMatch));
		}
    	//如果都匹配，则返回匹配
		return ConditionOutcome.match(ConditionMessage.of(match));
	}

	private ConditionOutcome determineOutcome(AnnotationAttributes annotationAttributes, PropertyResolver resolver) {
    	//解析成Spec对象
		Spec spec = new Spec(annotationAttributes);
    	//创建结果数组
		List<String> missingProperties = new ArrayList<>();
		List<String> nonMatchingProperties = new ArrayList<>();
    	//收集是否不匹配的信息，到missingProperties、nonMatchingProperties中
		spec.collectProperties(resolver, missingProperties, nonMatchingProperties);
    	//如果有属性缺失，则返回不匹配
		if (!missingProperties.isEmpty()) {
			return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
					.didNotFind("property", "properties").items(Style.QUOTE, missingProperties));
		}
    	//如果有属性不匹配，则返回不匹配
		if (!nonMatchingProperties.isEmpty()) {
			return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
					.found("different value in property", "different value in properties")
					.items(Style.QUOTE, nonMatchingProperties));
		}
    	//返回匹配
		return ConditionOutcome
				.match(ConditionMessage.forCondition(ConditionalOnProperty.class, spec).because("matched"));
	}

参考：

《Spring源码深度解析》

邋遢的流浪剑客
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot原理解析
05-15
springboot原理，其中包括运行过程，主要注解解释，简单易懂
Spring Boot 自动配置理解 以及实现自定义Starter
Joy_白的专栏
03-05 7669
Java微框架Spring Boot 运行原理深入解读 本文节选自《 JavaEE开发的颠覆者——Spring Boot实战 》一书。本书从Spring 基础、Spring MVC 基础讲起，从而无难度地引入Spring Boot 的学习。涵盖使用Spring Boot 进行Java EE 开发的绝大数应用场景，包含：Web 开发、数据访问、安全控制、批处理、异步消息、系统集成
SpringBoot原理解析（超详细）
qq_66912832的博客
05-26 4805
springboot原理解析 如上图所示： 下面的注解都是用在主配置类中，也就是加了@Configuration的类里面 1.通过@CompentScan + @Controller @Service @Respository @component @ComponentScan的功能其实就是自动扫描并加载符合条件的组件 适用场景（内部bean）：针对我们自己写的组件可以通过该方式来进行加载到容器中。 2.通过@Configuration+@Bean的方式来导入组件 (适...
SpringBoot启动原理解析
抛弃幻想，准备斗争
02-07 295
我们开发任何一个Spring Boot项目，都会用到如下的启动类 1 @SpringBootApplication 2 public class Application { 3 public static void main(String[] args) { 4 SpringApplication.run(Application.class, args); 5 ...
SpringBoot原理分析与实战教程
02-21
springBoot是企业级快速开发的解决方案，特别用于快速构建微服务应用，旨在用简单的方式让开发人员适应各种开发场景，本视频着重介绍SpringBoot的使用和内部原理；内容包含微服务概念、配置文件、日志框架的使用、...
SpringBoot自动配置原理分析
最新发布
06-12
学SpringBoot 最重要的是学它的自动配置原理，不然到了后面项目实战就会发现与其他人的差距在哪里，只知其一不知其二。SpringBoot的自动配置原理是其核心特性之一，其重要性主要体现在简化应用程序的开发和部署过程...
SpringBoot源码分析Demo
11-18
本源码分析Demo旨在深入理解SpringBoot的工作原理，特别是其自动化配置和注解解析机制。 首先，让我们来探讨SpringBoot的核心概念——自动化配置。SpringBoot通过`@EnableAutoConfiguration`注解开启了自动化配置...
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
**Spring整合Mybatis原理分析** 在Java Web开发中，Spring框架以其强大的依赖注入和面向切面编程能力，成为了事实上的核心框架。Mybatis则是一个轻量级的持久层框架，它简化了数据库操作，提供了直观的SQL映射。将...
springboot实战与原理分析视频
02-24
Spring Boot用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域成为领导者。
Springboot原理分析
Evan.Zhou的博客
07-16 107
org.springframework.context.ApplicationContextInitializer new SpringApplication() 工作 1、推导出web应用的类型（非web应用，reactive应用、mvc应用） 2、初始化spring context上下文的初始化器 3、设置监听器 public SpringApplication(ResourceLoader...
Spring Boot原理分析（一）
qq_39339965的博客
12-22 480
扑街前言：spring boot使用起来非常简单，它本身就是提供一种快速开发使用Spring的方式，业务逻辑层和spring的使用完全一致，上手并不困难。但是spring boot本身的原理逻辑非常复杂，也就是用起来简单的东西，往往困难的点别人已经帮你解决了。我会出一个系列慢慢的讲解自己整理原理的一个过程，本次是开篇。（） ...
Spring Boot核心原理
Itmastergo的博客
12-12 2081
Spring Boot的目标是使Spring应用程序的开发变得更加容易和快速。它采用了“习惯优于配置”的理念，通过提供一组默认的配置，让开发者可以零配置地快速搭建项目。Spring Boot并不是一种全新的框架，而是在Spring框架的基础上构建的，它利用Spring框架的众多功能，同时通过简化配置和提供新的功能来提高开发效率。
SpringBoot底层原理及分析
weixin_30685029的博客
07-31 727
一，Spring Boot简介 1.什么是Spring Boot； SpringBoot是由Pivotal团队提供的框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。 该框架使用了特定的方式(继承starter，约定优先于配置)来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域（rapid application...
SpringBoot底层原理
qq_37685457的博客
11-06 146
Hello World探究 1、POM文件 1、父项目 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring‐boot‐starter‐parent</artifactId> <version>1.5.9.RELEASE</...
Spring Boot 框架基础
qq_43439920的博客
03-05 1003
Spring Boot 框架基础 基础案例 pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.6.4</version> <relativePath/> <!-- lookup p
spring-boot的依赖管理
weixin_43960018的博客
03-09 891
spring-boot以简化开发闻名，本文主要讲解spring-boot对依赖的管理。 我们在创建spring-boot项目的时候，打开pom.xml文件，可以看到如下配置 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ve
狂神说SpringBoot02：运行原理初探
热门推荐
狂神说
03-09 1万+
狂神说SpringBoot系列连载课程，通俗易懂，基于SpringBoot2.2.5版本，欢迎各位狂粉转发关注学习。未经作者授权，禁止转载运行原理探究我们之前写的HelloSpringB...
Spring Boot源码解析（一）- @ConditionalOnProperty详解
07-01 1万+
1.前言 最近在学习Spring Boot的运作原理发现“自动配置”的功能都借助于@Conditional注解来完成，@Conditional根据满足某一特定条件创建一个特定的Bean。比如，当某一个类在一个路径下的时候，自动配置一个或多个Bean。即根据特定条件来控制Bean的创建行为。本文只讲解其中一个核心注解@ConditionalOnProperty。 2.@ConditionalOn...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

邋遢的流浪剑客

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值