spring-boot源码解析之一启动流程

- 日理万妓 2022-11-07 11:59 343阅读 0赞

### 文章目录 ###

*  安装环境
 *  构建SpringApplication
 *  运行SpringApplication
 *   *  创建Bootstrap上下文对象,并执行bootstrappers
     *  获取SpringApplicationRunListener监听器
     *  启动SpringApplicationRunListener监听器
     *  加载配置
     *  创建容器
     *   *  准备刷新容器前置执行
         *   *  加载启动类,将启动类注入容器.后续spring-boot基于此自动化配置.
         *  刷新容器

# 安装环境 #

刚从git上down下来，然后启动后发现

> Error occurred during initialization of VM Could not reserve enough  
> space for 2097152KB object heap

2G堆内存不够导致的,设置jvm堆内存1G即可.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]  
安装好后,找到**SampleTomcatApplication**这个测试类就行咯.  
访问地址 *http://127.0.0.1:8080/*  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]

# 构建SpringApplication #

![在这里插入图片描述][20210312235415990.png]

先看构造 SpringApplication

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        
    		this.resourceLoader = resourceLoader;
    		Assert.notNull(primarySources, "PrimarySources must not be null");
    		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    		//三种运行环境,默认SERVLET,即基于servlet的web应用程序运行
    		this.webApplicationType = WebApplicationType.deduceFromClasspath();
    		//加载META-INF/spring.factories
    		this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
    		//spring容器刷新之前初始化Spring ConfigurableApplicationContext的回调接口
    		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    		//获取META-INF/spring.factories配置监听器
    		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    		//获取执行main方法的Class
    		this.mainApplicationClass = deduceMainApplicationClass();
    	}

构建运行环境

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

加载 **META-INF/spring.factories** 下Bootstrapper , ApplicationContextInitializer , ApplicationListener 类

*  Bootstrapper
 *  ApplicationContextInitializer :spring容器刷新之前初始化Spring ConfigurableApplicationContext的回调接口
 *  ApplicationListener :

获取META-INF/spring.factories配置监听器，  
主要解析这里的配置  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 2]

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        
    		ClassLoader classLoader = getClassLoader();
    		// Use names and ensure unique to protect against duplicates
    		//加载"META-INF/spring.factories"下
    		Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    		//创建对象
    		List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    		AnnotationAwareOrderComparator.sort(instances);
    		return 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到内存
    				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;
    	}

获取执行main方法的Class

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

# 运行SpringApplication #

public ConfigurableApplicationContext run(String... args) {
        
    		//时间监控,记录启动时间,每个任务时间,最后打印
    		StopWatch stopWatch = new StopWatch();
    		stopWatch.start();
    		//运行META-INF/spring.factories注册的所有Bootstrapper
    		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    		ConfigurableApplicationContext context = null;
    		configureHeadlessProperty();
    		//获取SpringApplicationRunListener监听器,内部封装了所有ApplicationListener
    		SpringApplicationRunListeners listeners = getRunListeners(args);
    		//启动SpringApplicationRunListener监听器
    		listeners.starting(bootstrapContext, this.mainApplicationClass);
    		try {
        
    			//构建环境,执行完后所有environment属性都加载进来,包括配置文件
    			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
    
    			//处理忽略的bean
    			configureIgnoreBeanInfo(environment);
    			//打印banner
    			Banner printedBanner = printBanner(environment);
    			//创建容器
    			context = createApplicationContext();
    			context.setApplicationStartup(this.applicationStartup);
    			//准备刷新容器前置执行
    			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
    			//刷新容器,在这里启动了tomcat
    			refreshContext(context);
    			//刷新容器后置执行
    			afterRefresh(context, applicationArguments);//空实现,子类扩展
    			stopWatch.stop();
    			if (this.logStartupInfo) {
        //打印启动完时间日志
    				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    			}
    			//容器启动完成后,再次执行监听器.
    			listeners.started(context);
    			callRunners(context, applicationArguments);
    		}
    		catch (Throwable ex) {
        
    			handleRunFailure(context, ex, listeners);
    			throw new IllegalStateException(ex);
    		}
    
    		try {
        
    			//run方法执行结束前再次调用监听器
    			listeners.running(context);
    		}
    		catch (Throwable ex) {
        
    			handleRunFailure(context, ex, null);
    			throw new IllegalStateException(ex);
    		}
    		return context;
    	}

## 创建Bootstrap上下文对象,并执行bootstrappers ##

private DefaultBootstrapContext createBootstrapContext() {
        
    		DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
    		//运行META-INF/spring.factories注册的所有Bootstrapper
    		this.bootstrappers.forEach((initializer) -> initializer.initialize(bootstrapContext));
    		return bootstrapContext;
    	}

## 获取SpringApplicationRunListener监听器 ##

private SpringApplicationRunListeners getRunListeners(String[] args) {
        
    		Class<?>[] types = new Class<?>[] {
         SpringApplication.class, String[].class };
    		return new SpringApplicationRunListeners(logger,
    				getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
    				this.applicationStartup);
    	}

可以看到实际上加载的是  EventPublishingRunListener 对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 3]  
当调用  EventPublishingRunListener  构造时,会添加所有的  ApplicationListener

public EventPublishingRunListener(SpringApplication application, String[] args) {
        
    		this.application = application;
    		this.args = args;
    		this.initialMulticaster = new SimpleApplicationEventMulticaster();
    		//获取meta-info下注册的所有ApplicationListener监听器
    		for (ApplicationListener<?> listener : application.getListeners()) {
        
    			this.initialMulticaster.addApplicationListener(listener);
    		}
    	}

## 启动SpringApplicationRunListener监听器 ##

void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
        
    		doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
    				(step) -> {
        
    					if (mainApplicationClass != null) {
        
    						step.tag("mainApplicationClass", mainApplicationClass.getName());
    					}
    				});
    	}

自定义事件,广播到指定ApplicationStartingEvent类型上

@Override
    	public void starting(ConfigurableBootstrapContext bootstrapContext) {
        
    		//自定义事件,广播到指定ApplicationStartingEvent类型上
    		this.initialMulticaster
    				.multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
    	}

广播事件

@Override
    	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        
    		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    		Executor executor = getTaskExecutor();
    		for (ApplicationListener<?> listener :
    				//获取指定type类型的监听事件.
    				getApplicationListeners(event, type)) {
        
    				//获取线程池,spring-boot这里默认null
    			if (executor != null) {
        
    				//执行监听事件
    				executor.execute(() -> invokeListener(listener, event));
    			}
    			else {
        
    				//同步处理
    				invokeListener(listener, event);
    			}
    		}
    	}

获取指定type类型的监听事件.  
AbstractApplicationEventMulticaster\#getApplicationListeners -》  
AbstractApplicationEventMulticaster\#retrieveApplicationListeners

protected boolean supportsEvent(
    			ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {
        
    
    		GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?
    				(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));
    		//查看是否支持事件类型
    		return (smartListener.supportsEventType(eventType) &&
    				//是否支持的源处理类型
    				smartListener.supportsSourceType(sourceType));
    	}

这里默认三种类型,我们就先看  LoggingApplicationListener   
![在这里插入图片描述][20210313111145123.png]

org.springframework.boot.context.logging.LoggingApplicationListener

@Override
    	public boolean supportsEventType(ResolvableType resolvableType) {
        
    		return isAssignableFrom(resolvableType.getRawClass(), EVENT_TYPES);
    	}
    
    	@Override
    	public boolean supportsSourceType(Class<?> sourceType) {
        
    		return isAssignableFrom(sourceType, SOURCE_TYPES);
    	}

![在这里插入图片描述][20210313111710690.png]

public void onApplicationEvent(ApplicationEvent event) {
        
    		//spring-boot启动执行
    		if (event instanceof ApplicationStartingEvent) {
        
    			onApplicationStartingEvent((ApplicationStartingEvent) event);
    		}
    		//springboot环境准备完成执行
    		else if (event instanceof ApplicationEnvironmentPreparedEvent) {
        
    			onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
    		}
    		//spring-boot环境设置完成后
    		else if (event instanceof ApplicationPreparedEvent) {
        
    			onApplicationPreparedEvent((ApplicationPreparedEvent) event);
    		}
    		//容器关闭
    		else if (event instanceof ContextClosedEvent
    				&& ((ContextClosedEvent) event).getApplicationContext().getParent() == null) {
        
    			onContextClosedEvent();
    		}
    		//容器启动失败
    		else if (event instanceof ApplicationFailedEvent) {
        
    			onApplicationFailedEvent();
    		}
    	}

## 加载配置 ##

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
    			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
        
    		// Create and configure the environment
    		//根据运行环境分别创建环境变量配置对象
    		ConfigurableEnvironment environment = getOrCreateEnvironment();
    		//配置命令行
    		configureEnvironment(environment, applicationArguments.getSourceArgs());
    		ConfigurationPropertySources.attach(environment);
    		//执行ApplicationEnvironmentPreparedEvent监听事件
    		listeners.environmentPrepared(bootstrapContext, environment);
    
    		//defaultProperties 移动最后
    		DefaultPropertiesPropertySource.moveToEnd(environment);
    
    		configureAdditionalProfiles(environment);
    		if (environment.getProperty("spring.main.environment-prefix") != null) {
        
    			throw new IllegalStateException("Environment prefix cannot be set via properties.");
    		}
    		bindToSpringApplication(environment);
    		if (!this.isCustomEnvironment) {
        
    			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
    					deduceEnvironmentClass());
    		}
    		ConfigurationPropertySources.attach(environment);//将自己sources添加第一个
    		return environment;
    	}

根据运行环境分别创建环境变量配置对象

private ConfigurableEnvironment getOrCreateEnvironment() {
        
    		if (this.environment != null) {
        
    			return this.environment;
    		}
    		switch (this.webApplicationType) {
        
    		case SERVLET:
    			return new StandardServletEnvironment();
    		case REACTIVE:
    			return new StandardReactiveWebEnvironment();
    		default:
    			return new StandardEnvironment();
    		}
    	}

这里执行的是  StandardServletEnvironment ,根据继承结构会调用父类,然后创建4个  propertySources 对象

@Override
    	protected void customizePropertySources(MutablePropertySources propertySources) {
        
    		propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
    		propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
    		if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
        
    			propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
    		}
    		super.customizePropertySources(propertySources);
    	}

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 4]  
配置命令行

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
        
    		if (this.addConversionService) {
        
    			ConversionService conversionService = ApplicationConversionService.getSharedInstance();//返回一个懒加载对象
    			environment.setConversionService((ConfigurableConversionService) conversionService);
    		}
    		configurePropertySources(environment, args);
    		configureProfiles(environment, args);
    	}

这里可以看到,若设置了命令行,会默认添加到头位置,也就是优先级最高.

protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
        
    		MutablePropertySources sources = environment.getPropertySources();
    		if (!CollectionUtils.isEmpty(this.defaultProperties)) {
        
    			DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
    		}
    		//解析命令行
    		if (this.addCommandLineProperties && args.length > 0) {
        
    			String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
    			if (sources.contains(name)) {
        
    				PropertySource<?> source = sources.get(name);
    				CompositePropertySource composite = new CompositePropertySource(name);
    				composite.addPropertySource(
    						new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
    				composite.addPropertySource(source);
    				sources.replace(name, composite);
    			}
    			else {
        
    				//放到第一个位置
    				sources.addFirst(new SimpleCommandLinePropertySource(args));
    			}
    		}
    	}

加载spring.profiles.active 配置环境

protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
        
    	}

可以看到这里空实现,看注释文档提示看这个监听器 ConfigFileApplicationListener,  
![在这里插入图片描述][20210313122644735.png]  
打开之后,提示看 ConfigDataEnvironmentPostProcessor，暂且放一边不管.  
![在这里插入图片描述][20210313122704169.png]  
接着执行ConfigurationPropertySources.attach会把configurationProperties 放最前面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 5]  
紧接着执行ApplicationEnvironmentPreparedEvent事件类型监听器,这里主要看

EnvironmentPostProcessorApplicationListener\#onApplicationEnvironmentPreparedEvent

private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        
    		ConfigurableEnvironment environment = event.getEnvironment();
    		SpringApplication application = event.getSpringApplication();
    		for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(event.getBootstrapContext())) {
        
    			postProcessor.postProcessEnvironment(environment, application);
    		}
    	}

分别从META-INF/spring.factories注入6个对象,执行逻辑后会分别创建2个PropertySources对象,  
![在这里插入图片描述][20210313131214286.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 6]  
紧接着会将defaultProperties移动到最后面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 7]  
最后将自己移动到最前面.自此初始化环境变量完成.

## 创建容器 ##

protected ConfigurableApplicationContext createApplicationContext() {
        
    		return this.applicationContextFactory.create(this.webApplicationType);
    	}

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
        
    		try {
        
    			switch (webApplicationType) {
        
    			case SERVLET:
    				return new AnnotationConfigServletWebServerApplicationContext();
    			case REACTIVE:
    				return new AnnotationConfigReactiveWebServerApplicationContext();
    			default:
    				return new AnnotationConfigApplicationContext();
    			}
    		}
    		catch (Exception ex) {
        
    			throw new IllegalStateException("Unable create a default ApplicationContext instance, "
    					+ "you may need a custom ApplicationContextFactory", ex);
    		}
    	};

因为webApplicationType为SERVLET所以这里创建的是AnnotationConfigServletWebServerApplicationContext对象  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 8]

### 准备刷新容器前置执行 ###

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
    			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
    			ApplicationArguments applicationArguments, Banner printedBanner) {
        
    		//设置环境变量
    		context.setEnvironment(environment);
    		//容器后置处理
    		postProcessApplicationContext(context);
    		//遍历执行每个ApplicationContextInitializer方法,Meta-info注入或调用addInitializers添加
    		applyInitializers(context);
    
    		//通知ApplicationContextInitializedEvent容器初始化事件监听器
    		listeners.contextPrepared(context);
    
    		bootstrapContext.close(context);//BootstrapContextClosedEvent 发送监听器
    		if (this.logStartupInfo) {
          //打印log
    			logStartupInfo(context.getParent() == null);
    			logStartupProfileInfo(context);
    		}
    		// Add boot specific singleton beans
    		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    		//注册启动参数bean，这里将容器指定的参数封装成bean，注入容器
    		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    		//banner注入beanFactory
    		if (printedBanner != null) {
        
    			beanFactory.registerSingleton("springBootBanner", printedBanner);
    		}
    		//设置允许重复id或name的bean定义覆盖,默认false
    		if (beanFactory instanceof DefaultListableBeanFactory) {
        
    			((DefaultListableBeanFactory) beanFactory)
    					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    		}
    		//是否懒加载beanDefinition,默认false
    		if (this.lazyInitialization) {
        
    			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    		}
    		// Load the sources
    		//获取启动类指定的参数,也就是SpringApplication.run(SampleTomcatApplication.class, args);
    		//SampleTomcatApplication.class ,可指定多个.
    		Set<Object> sources = getAllSources();
    		Assert.notEmpty(sources, "Sources must not be empty");
    		//加载启动类,将启动类注入容器.
    		load(context, sources.toArray(new Object[0]));
    
    		//ApplicationPreparedEvent : 发布容器已加载事件,以及将监听器添加到context中
    		listeners.contextLoaded(context);
    	}

容器后置处理,这里主要懒加载了自定义转换器

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
        
    		if (this.beanNameGenerator != null) {
        
    			context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
    					this.beanNameGenerator);
    		}
    		if (this.resourceLoader != null) {
        
    			if (context instanceof GenericApplicationContext) {
        
    				((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
    			}
    			if (context instanceof DefaultResourceLoader) {
        
    				((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());
    			}
    		}
    		//懒加载自定义转换器.
    		if (this.addConversionService) {
        
    			context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance());
    		}
    	}

遍历执行每个ApplicationContextInitializer方法,Meta-info注入或调用addInitializers添加

protected void applyInitializers(ConfigurableApplicationContext context) {
        
    		for (ApplicationContextInitializer initializer : getInitializers()) {
        
    			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
    					ApplicationContextInitializer.class);
    			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
    			initializer.initialize(context);
    		}
    	}

#### 加载启动类,将启动类注入容器.后续spring-boot基于此自动化配置. ####

protected void load(ApplicationContext context, Object[] sources) {
        
    		if (logger.isDebugEnabled()) {
        
    			logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
    		}
    		BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
    		if (this.beanNameGenerator != null) {
        
    			loader.setBeanNameGenerator(this.beanNameGenerator);
    		}
    		if (this.resourceLoader != null) {
        
    			loader.setResourceLoader(this.resourceLoader);
    		}
    		if (this.environment != null) {
        
    			loader.setEnvironment(this.environment);
    		}
    		loader.load();
    	}

void load() {
        
    		for (Object source : this.sources) {
        
    			load(source);
    		}
    	}
    private void load(Object source) {
        
    		Assert.notNull(source, "Source must not be null");
    		//class类型,则采用注解类型
    		if (source instanceof Class<?>) {
        
    			load((Class<?>) source);
    			return;
    		}
    		//resource类型,则xml解析
    		if (source instanceof Resource) {
        
    			load((Resource) source);
    			return;
    		}
    		//package,启动扫描包,如@ComponentScan
    		if (source instanceof Package) {
        
    			load((Package) source);
    			return;
    		}
    		//字符串,则直接加载
    		if (source instanceof CharSequence) {
        
    			load((CharSequence) source);
    			return;
    		}
    		throw new IllegalArgumentException("Invalid source type " + source.getClass());
    	}

加载的核心代码在这里.这里会分别采用groovy和java方式加载.

private void load(Class<?> source) {
        
    		if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
        
    			// Any GroovyLoaders added in beans{} DSL can contribute beans here
    			GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
    			((GroovyBeanDefinitionReader) this.groovyReader).beans(loader.getBeans());
    		}
    		if (isEligible(source)) {
        
    			this.annotatedReader.register(source);//注解方式,将启动类bean信息存入beanDefinitionMap
    		}
    	}

其加载的核心代码就要看spring了，这里只简单的阐述下。最终会走到如下代码，主要逻辑就是注入AnnotatedGenericBeanDefinition，内部其实封装了启动main函数的类。自此启动类注入spring容器中。

<T> void doRegisterBean(Class<T> beanClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
    			@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
        
    
    		//创建一个注解bean定义对象,这里beanClass是main函数对应的class类
    		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        
    			return;
    		}
    
    		abd.setInstanceSupplier(instanceSupplier);
    		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
    		abd.setScope(scopeMetadata.getScopeName());
    		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    
    		//设置Lazy,DependsOn等注解配置
    		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    		if (qualifiers != null) {
        
    			for (Class<? extends Annotation> qualifier : qualifiers) {
        
    				if (Primary.class == qualifier) {
        
    					abd.setPrimary(true);
    				}
    				else if (Lazy.class == qualifier) {
        
    					abd.setLazyInit(true);
    				}
    				else {
        
    					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
    				}
    			}
    		}
    		for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
        
    			customizer.customize(abd);
    		}
    
    		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
    		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    		//注册bean到spring容器
    		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    	}

### 刷新容器 ###

private void refreshContext(ConfigurableApplicationContext context) {
        
    		if (this.registerShutdownHook) {
        
    			try {
        
    				//注册钩子注销context函数
    				context.registerShutdownHook();
    			}
    			catch (AccessControlException ex) {
        
    				// Not allowed in some environments.
    			}
    		}
    		//刷新容器
    		refresh(context);
    	}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70]: /images/20221023/ac85ac2edc504b5f80dbd091c772bef4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 1]: /images/20221023/14779f27e5974c288fc0e23cf4a15b8e.png
[20210312235415990.png]: /images/20221023/1fc6d1a31c4f4b869ca327014c162c87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 2]: /images/20221023/13fdc896235649d8b37ac078674ff4b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 3]: /images/20221023/1f32e1c4388745b6a398547f0db358ad.png
[20210313111145123.png]: /images/20221023/b80b025cb52b4b6ba568a93ec973fe40.png
[20210313111710690.png]: /images/20221023/0c802d89a6904c61b6cebe79b868f1fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 4]: /images/20221023/47fc777fb9d44fa09cc9ba46a14f3cbb.png
[20210313122644735.png]: /images/20221023/1a5d879d96e44e9ba5177ddb5ecb5826.png
[20210313122704169.png]: /images/20221023/f94cfcc0f4ac45d58e85fa2eec70d552.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 5]: /images/20221023/139b7e9758814967876da61b6057bafa.png
[20210313131214286.png]: /images/20221023/f4ac5221e3ba4f698ad9ba728e27f9cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 6]: /images/20221023/662f4f43e17a49568e20ad0b4f00f6de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 7]: /images/20221023/e33e075a431a44ecae5106b6016951e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L051YW5fRmVuZw_size_16_color_FFFFFF_t_70 8]: /images/20221023/ac6cdbd81c69473a87df06f220317865.png