Spring的启动过程01

最新推荐文章于 2024-07-25 22:44:17 发布
最新推荐文章于 2024-07-25 22:44:17 发布
阅读量138 收藏
点赞数
分类专栏： SpringBoot 文章标签： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wewinwe/article/details/109263394
版权
  • 开始
@SpringBootApplication
public class MallTany01Application {

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

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

=>

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
   return new SpringApplication(primarySources).run(args);
}
  • SpringApplication()
public SpringApplication(Class<?>... primarySources) {
   this(null, primarySources);
}

=>

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
  //resourceLoader资源加载器，默认为null
   this.resourceLoader = resourceLoader;
   Assert.notNull(primarySources, "PrimarySources must not be null");
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
 //推断是否为web应用
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
  //实例化类型为ApplicationContextInitializer的类
   setInitializers((Collection) 		     getSpringFactoriesInstances(ApplicationContextInitializer.class));
  //实例化类型为ApplicationListener的类
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  //推断主函数类
   this.mainApplicationClass = deduceMainApplicationClass();
}
  • this.webApplicationType = WebApplicationType.deduceFromClasspath();
	static WebApplicationType deduceFromClasspath() {
		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
			return WebApplicationType.REACTIVE;
		}
		for (String className : SERVLET_INDICATOR_CLASSES) {
			if (!ClassUtils.isPresent(className, null)) {
				return WebApplicationType.NONE;
			}
		}
		return WebApplicationType.SERVLET;
	}
  • REACTIVE:内嵌式相应web服务器
  • NONE：不需要服务器
  • SERVLET:使用内嵌的web服务器
private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";

其中isPresent的作用是利用forName（）根据提供的类名和类加载器，去尝试加载该类，如果加载成功返回true否则抛出异常并返回false

public static boolean isPresent(String className, @Nullable ClassLoader classLoader) {
   try {
      forName(className, classLoader);
      return true;
   }
   catch (IllegalAccessError err) {
      throw new IllegalStateException("Readability mismatch in inheritance hierarchy of class [" +
            className + "]: " + err.getMessage(), err);
   }
   catch (Throwable ex) {
      // Typically ClassNotFoundException or NoClassDefFoundError...
      return false;
   }
}

此处返回的是WebApplicationType.SERVLET

  • setInitializers((Collection)getSpringFactoriesInstances(ApplicationContextInitializer.class));

=>

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
   return getSpringFactoriesInstances(type, new Class<?>[] {});
}

=>

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
  //得到类加载器
   ClassLoader classLoader = getClassLoader();
   // Use names and ensure unique to protect against duplicates
   Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
   AnnotationAwareOrderComparator.sort(instances);
   return instances;
}

=>

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

=>

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
  //先查看缓存在是否存在类记载器，加载过类。其中就是一个map。它的key为之前的classLoader，value为一个map。这个map存储量不同的类
   MultiValueMap<String, String> result = cache.get(classLoader);
   if (result != null) {
      return result;
   }

   try {
     //获取FACTORIES_RESOURCE_LOCATION="META-INF/spring.factories"的url
      Enumeration<URL> urls = (classLoader != null ?
            classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
            ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
      result = new LinkedMultiValueMap<>();
     //遍历url
      while (urls.hasMoreElements()) {
        //例子：url=jar:file:/D:/InstallationPath/m2/repository/org/springframework/boot/spring-boot/2.3.4.RELEASE/spring-boot-2.3.4.RELEASE.jar!/META-INF/spring.factories
         URL url = urls.nextElement();
         UrlResource resource = new UrlResource(url);
        //加载该url下的spring.factories，并将其封装到map中
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
         for (Map.Entry<?, ?> entry : properties.entrySet()) {
            String factoryTypeName = ((String) entry.getKey()).trim();
           //将每个factoryTypeName作为key，value为其包含的配置类，添加到result中。
            for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
               result.add(factoryTypeName, factoryImplementationName.trim());
            }
         }
      }
     //将其放入map中
      cache.put(classLoader, result);
      return result;
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
            FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
}

上述函数中properties的值。它是是个map。

在这里插入图片描述

下面给出了url=jar:file:/D:/InstallationPath/m2/repository/org/springframework/boot/spring-boot/2.3.4.RELEASE/spring-boot-2.3.4.RELEASE.jar!/META-INF/spring.factories文件内容

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=\
org.springframework.boot.diagnostics.FailureAnalyzers

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,\
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor,\
org.springframework.boot.reactor.DebugAgentEnvironmentPostProcessor

# Failure Analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.context.properties.NotConstructorBoundInjectionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanCurrentlyInCreationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanDefinitionOverrideFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanNotOfRequiredTypeFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindValidationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.UnboundConfigurationPropertyFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ConnectorStartFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoSuchMethodFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoUniqueBeanDefinitionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.PortInUseFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ValidationExceptionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyNameFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.InvalidConfigurationPropertyValueFailureAnalyzer

# FailureAnalysisReporters
org.springframework.boot.diagnostics.FailureAnalysisReporter=\
org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter

最种的result结果如下，他包含了所有META-INF/spring.factories的配置类名

在这里插入图片描述

  • return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());

    getOrDefault：从result中得到key为factoryTypeName="org.springframework.context.ApplicationContextInitializer"的值。

    default V getOrDefault(Object key, V defaultValue) {
    V v;
    return (((v = get(key)) != null) || containsKey(key))
        ? v
        : defaultValue;
}

    最终的返回结果：

在这里插入图片描述

  • private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
   ClassLoader classLoader = getClassLoader();
   // Use names and ensure unique to protect against duplicates
   Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
   AnnotationAwareOrderComparator.sort(instances);
   return instances;
}

=>

List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);

实例化name中的类，并将其添加到instances列表中。

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
      ClassLoader classLoader, Object[] args, Set<String> names) {
   List<T> instances = new ArrayList<>(names.size());
   for (String name : names) {
      try {
         Class<?> instanceClass = ClassUtils.forName(name, classLoader);
         Assert.isAssignable(type, instanceClass);
         Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
         T instance = (T) BeanUtils.instantiateClass(constructor, args);
         instances.add(instance);
      }
      catch (Throwable ex) {
         throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
      }
   }
   return instances;
}

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
   this.resourceLoader = resourceLoader;
   Assert.notNull(primarySources, "PrimarySources must not be null");
   this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
   this.webApplicationType = WebApplicationType.deduceFromClasspath();
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   this.mainApplicationClass = deduceMainApplicationClass();
}

所以：setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

的作用是实例化META-INF/spring.factories中所有factoryTypeName="org.springframework.context.ApplicationContextInitializer"的配置类。

  • 同理setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));的作用为实例化ApplicationListener的配置类

  • this.mainApplicationClass = deduceMainApplicationClass();包含main的类

private Class<?> deduceMainApplicationClass() {
   try {
      StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
      for (StackTraceElement stackTraceElement : stackTrace) {
         if ("main".equals(stackTraceElement.getMethodName())) {
            return Class.forName(stackTraceElement.getClassName());
         }
      }
   }
   catch (ClassNotFoundException ex) {
      // Swallow and continue
   }
   return null;
}

总结：

new SpringApplication(primarySources)的作用如下

  • 推断web应用类型
  • 实例化ApplicationContextInitializer
  • 实例化ApplicationListener
  • 推断主应用类
wewinwe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot test启动过程
liulong1010的专栏
01-18 1926
加载Spring的上下文启动流程 https://www.processon.com/embed/61cd2436e401fd7a538b36a7 解析： @SpringBootTest标记了junit5的注解@ExtendWith(SpringExtension.class) SpringExtension实现了junit5的test的生命周期的钩子函数，如BeforeAllCallback，TestInstancePostProcessor，BeforeEachCallback 在juni
Spring MVC 启动过程源码分析详解
08-27
Spring MVC 启动过程源码分析详解 Spring MVC 启动过程的源码分析详解是 Spring MVC 框架中一个非常重要的部分，对于了解 Spring MVC 的工作原理和内部机制非常重要。在这篇文章中，我们将从源码层面上对 Spring ...
Spring启动过程详解
JAVA技术爱好者
11-09 1万+
Spring启动过程详解前言spring容器启动过程AnnotationConfigApplicationContext有参数构造方法无参数构造AnnotatedBeanDefinitionReader构造配置类解析register（解析我们的配置类Appconfig）refresh启动准备prepareRefreshprepareBeanFactory(beanFactory)registerBeanPostProcessors(beanFactory)initMessageSourceinitAppli
Spring IOC的启动过程
Palpitate_fx的博客
06-19 2605
Spring IOC的启动过程
Spring 启动顺序
Wells974
06-12 1697
加载配置文件: 读取或等配置文件。创建 Spring 容器: 初始化。Bean 定义加载: 通过扫描和配置文件加载 Bean 定义。Bean 实例化: 根据 Bean 定义创建 Bean 实例。依赖注入: 将所需的依赖注入到 Bean 中。Bean 初始化: 调用初始化方法。完成启动: 应用完全启动并准备好处理请求。Spring 容器会根据配置文件和注解扫描路径加载 Bean 定义。在这个阶段，Spring 解析配置文件中的 Bean 定义和注解（如@Component@Service等）。
启动Spring项目详细过程
君寞傲
10-12 6166
1、Spring 项目放到web项目容器中（Tomcat、Jetty、JBoss） 本文以通用的Tomcat为例 2、项目容器启动时需要加载读取web.xml配置文件 如下图： 3、容器首先会去读取web.xml配置文件中的两个节点：<listener> </listener>和<context-param> </context-param...
Spring 启动流程
dreambyday
11-17 5881
按Bean状态描述：按方法描述：准备阶段：刷新阶段refresh()：
spring启动流程
asfasfasgjkl的博客
08-08 4371
在网上找的各种资料，总结spring启动的大致流程
spring项目的启动过程
风明水漾的博客
07-02 3890
下边利用tomcat启动spring项目来看看启动过程中发生了什么： 项目启动过程比较长，本想着粘到编辑器中做解析，无奈字数超限，于是转为图片，结果超出长度，不得已做了二次截图才上传成功，项目启动的主要行为大概都截到了，可以参考一下。 总结一下tomcat启动加载顺序： 1.启动tomcat容器catalina，catalina 就是Tomcat服务器使用的 Apache实现的servlet容器的名字 2.容器监听日志打印出当前运行系统
Spring启动及Bean实例化过程来看经典扩展接口
热门推荐
张彦峰的博客
04-16 1万+
从Spring启动及Bean实例化过程来看经典扩展接口如下，并给出我们可能的应用分析：BeanPostProcessor+BeanFactoryPostProcessor+ApplicationContextAware++InitializingBean和DisposableBean+BeanDefinitionRegistryPostProcessor+ApplicationListener
Spring容器的启动过程
ZCC的专栏
08-21 5137
一、Spring的启动过程 (1)首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境； (2)其次，在web.xml中会提供有contextLoaderListener。在web容器启动时，会触发容器初始化事件，此时contextLoaderListener会监听到...
Spring Boot启动过程完全解析(一)
08-30
Spring Boot启动过程完全解析 Spring Boot启动过程是指从应用程序启动到Spring Boot应用程序完全启动的整个过程。这个过程可以分为多个阶段，每个阶段都有一些重要的步骤和机制。下面将详细地介绍Spring Boot启动...
启动Spring项目详细过程(小结)
08-25
在Spring容器的启动过程中，会执行以下步骤：首先，会检查是否已经存在根应用程序上下文，如果不存在，则创建一个新的应用程序上下文。然后，会创建一个新的spring容器，并将其添加到ServletContext中。最后，会将...
Spring Boot启动过程全面解析（三）
08-30
Spring Boot启动过程全面解析（三） Spring Boot框架作为当前最流行的Java开发框架之一，其启动过程是一个复杂的过程，涉及到多个组件和接口的协作。下面我们将深入探讨Spring Boot启动过程的第三部分，了解...
详解spring注解配置启动过程
09-01
Spring框架的注解配置启动过程是现代Spring应用中常见的初始化方式，它摆脱了传统的XML配置文件，使得配置更加简洁和直观。在这个过程中，Spring通过一系列的自动装配和上下文加载来初始化并管理bean。以下是对...
Spring Boot组成的分布式系统中实现日志跟踪
心猿意码
07-25 359
除了使用Sleuth和Zipkin之外，我们还可以自定义日志输出格式，以便更容易地识别请求的追踪信息。Xml深色版本1通过使用Spring Cloud Sleuth和Zipkin，我们可以轻松地为Spring Boot应用实现日志跟踪。这种方式不仅简化了日志跟踪的实现，还提供了强大的可视化工具，帮助我们更好地理解和调试分布式系统。此外，通过自定义日志输出格式和使用MDC，我们可以进一步定制日志以适应特定的需求。
Spring boot 2.0 升级到 3.3.1 的相关问题 （五）
飞一站的博客
07-24 434
解决Spring boot 2.0 升级到3.3.1 版本的druid 配置和Redis配置不生效的问题。
Spring Boot 集成 Kafka
最新发布
Casual_Lei的博客
07-25 669
Spring Boot 与 Kafka 的集成使得消息队列的使用变得更加简单和高效。通过上述步骤，你可以轻松地配置 Kafka、实现生产者和消费者，并利用 Spring Boot 提供的强大功能来处理消息流。了解 Kafka 的高级特性（如事务和异步处理）能够帮助你更好地满足业务需求，确保系统的高可用性和数据一致性。
Spring Boot 配置文件
m0_60963435的博客
07-23 1047
T04BF👋专栏:🫵 今天你敲代码了吗。
spring启动过程
04-13
Spring启动过程可以分为以下几个步骤[^1]： 1. 创建Spring容器：通过创建一个ApplicationContext对象来启动Spring容器。可以使用不同的ApplicationContext实现类，如AnnotationConfigApplicationContext、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值