源码梳理（1）Springboot启动过程中的refreshContext(context) 刷新上下文，实例化Bean

已于 2024-01-30 19:17:07 修改
阅读量934 收藏 9
点赞数 21
分类专栏： 源码梳理 文章标签： spring boot java 后端 spring
于 2024-01-30 14:41:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuperrWatermelon/article/details/135869213
版权

文章目录

SpringBoot容器刷新过程

示例源码的版本是springboot3.0.2

1，主启动类执行run方法
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
    	// 执行run方法
        SpringApplication.run(MainApplication.class);
    }
}
2，执行SpringApplication.class的run方法中的refreshContext(context);方法
	public ConfigurableApplicationContext run(String... args) {
		long startTime = System.nanoTime();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			// 刷新上下文，实例化Bean
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			// 省略...
		return context;
	}
3，执行ConfigurableApplicationContext的refresh()方法
	void refresh() throws BeansException, IllegalStateException;

普通web应用为AnnotationConfigServletWebServerApplicationContext，调用了父类ServletWebServerApplicationContext的refresh() 方法

	public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
		implements AnnotationConfigRegistry {
		// ...
	}

	@Override
	public final void refresh() throws BeansException, IllegalStateException {
		try {
			// 调用父类AbstractApplicationContext的refresh()方法
			super.refresh();
		}
		catch (RuntimeException ex) {
			WebServer webServer = this.webServer;
			if (webServer != null) {
				webServer.stop();
			}
			throw ex;
		}
	}

再调用ServletWebServerApplicationContext的父类AbstractApplicationContext的refresh()方法

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
			// 4.为刷新准备此上下文
			// Prepare this context for refreshing
			prepareRefresh();
			// 5.告诉子类去刷新内部bean工厂
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			// 6.准备bean工厂为了在上下文中使用
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);
			try {
				// 7，允许在上下文子类中对 Bean 工厂进行后置处理
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);
				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				// 8，调用在上下文中注册为Bean的工厂处理器
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);
				// 9，注册Bean后置处理器（Bean后置处理器用于后面Bean创建时的拦截处理）
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				beanPostProcess.end();
				// 初始化消息源
				// Initialize message source for this context.
				initMessageSource();
				// 初始化事件广播器
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// 10，在特定的上下文子类中初始化其他特殊的 bean
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// 检查并注册所有的监听器 bean
				// Check for listener beans and register them.
				registerListeners();
				// 11，实例化剩余所有的非懒加载的单例Bean
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);
				// 12，发布相应的事件
				// Last step: publish corresponding event.
				finishRefresh();
			}
			catch (BeansException ex) {
				// 省略...
			}
			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
				contextRefresh.end();
			}
		}
	}
4，prepareRefresh() 准备这个上下文以进行刷新，设置它的启动日期和活动标志，并对属性源进行任何初始化操作
	protected void prepareRefresh() {
		// 省略...
		// 初始化占位符属性源
		initPropertySources();
		// 验证所有标记为必需的属性是否可解析
		getEnvironment().validateRequiredProperties();
		// 准备applicationListeners（应用程序监听器）
		// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}
		// 准备earlyApplicationEvents （应用程序事件）
		// Allow for the collection of early ApplicationEvents,
		// to be published once the multicaster is available...
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}
5，ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();告诉子类刷新内部 Bean 工厂
	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		// 给bean工厂设置了序列化id并返回
		refreshBeanFactory();
		return getBeanFactory();
	}
6，prepareBeanFactory(beanFactory);准备bean工厂为了在上下文中使用
	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
		// Configure the bean factory with context callbacks.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);
		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// Set a temporary ClassLoader for type matching.
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
		// Register default environment beans.
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
		if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
			beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
		}
	}
7，postProcessBeanFactory(beanFactory);允许在上下文子类中对 Bean 工厂进行处理

执行AnnotationConfigServletWebServerApplicationContext的postProcessBeanFactory方法

	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 下文有说明
		super.postProcessBeanFactory(beanFactory);
		if (this.basePackages != null && this.basePackages.length > 0) {
			this.scanner.scan(this.basePackages);
		}
		if (!this.annotatedClasses.isEmpty()) {
			this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
		}
	}

先调用了父类ServletWebServerApplicationContext的postProcessBeanFactory方法

	@Override
	protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 添加WebApplicationContextServletContextAwareProcessor后置处理器
		// 负责处理实现ServletContextAware和ServletConfigAware接口的Bean
		beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
		// 告诉Bean工厂忽略对ServletContextAware接口的依赖处理
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		// 注册Web应用程序作用域以及其相应的作用域处理器。
		registerWebApplicationScopes();
	}
8，invokeBeanFactoryPostProcessors(beanFactory);调用在上下文中注册为Bean的工厂后置处理器
	protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

执行所有已注册的 BeanFactoryPostProcessor 实例的 postProcessBeanFactory 方法。BeanFactoryPostProcessor实例可以根据需要在Bean实例化之前对容器中的BeanDefinition进行修改、添加或删除。

9，registerBeanPostProcessors(beanFactory);注册Bean后置处理器（Bean后置处理器用于后面Bean创建时的拦截处理）
	protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
	}

将BeanPostProcessors添加到AbstractBeanFactory的beanPostProcessors

10，onRefresh();在特定的上下文子类中初始化其他特殊的 bean

AbstractApplicationContext并没有操作，全部又子类实现

	protected void onRefresh() throws BeansException {
	}

ServletWebServerApplicationContext调用父类GenericWebApplicationContext的onRefresh方法，并创建启动Web服务

	@Override
	protected void onRefresh() {
		super.onRefresh();
		try {
			// 创建Web服务
			createWebServer();
		}
		catch (Throwable ex) {
			throw new ApplicationContextException("Unable to start web server", ex);
		}
	}

GenericWebApplicationContext的onRefresh方法进行初始化主题功能

	@Override
	protected void onRefresh() {
		this.themeSource = UiApplicationContextUtils.initThemeSource(this);
	}
11，finishBeanFactoryInitialization(beanFactory);实例化剩余所有非延迟注册的单例Bean

AbstractApplicationContext的finishBeanFactoryInitialization方法，核心环节beanFactory.preInstantiateSingletons();

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 省略...

		// 实例化剩余所有的非懒加载的单例Bean
		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

DefaultListableBeanFactory实现的preInstantiateSingletons方法，这部分的核心环节是getBean()方法

	@Override
	public void preInstantiateSingletons() throws BeansException {
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof SmartFactoryBean<?> smartFactoryBean && smartFactoryBean.isEagerInit()) {
						getBean(beanName);
					}
				}
				else {
					// 核心环节
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton smartSingleton) {
				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
						.tag("beanName", beanName);
				smartSingleton.afterSingletonsInstantiated();
				smartInitialize.end();
			}
		}
	}

DefaultListableBeanFactory的getBean方法由AbstractBeanFactory的doGetBean方法实现，核心环节getSingleton()

	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		String beanName = transformedBeanName(name);
		Object beanInstance;
		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			// 省略...
		}
		else {
			// 省略...
			try {
				// 省略...
				// Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 核心环节：创建bean
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 省略...
			}
			catch (BeansException ex) {
				beanCreation.tag("exception", ex.getClass().toString());
				beanCreation.tag("message", String.valueOf(ex.getMessage()));
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
			finally {
				beanCreation.end();
			}
		}
		return adaptBeanInstance(name, beanInstance, requiredType);
	}

AbstractBeanFactory的doGetBean方法中的getSingleton()方法，该方法的第二参数是一个函数式接口ObjectFactory<?>，具体的实现是通过了createBean(beanName, mbd, args);方法完成，进入createBean分支，这个环节完成了Bean的实例化，依赖注入，初始化

				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						// 省略...
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

@FunctionalInterface
public interface ObjectFactory<T> {
	T getObject() throws BeansException;
}

createBean分支：AbstractAutowireCapableBeanFactory实现了createBean方法，核心环节doCreateBean方法

	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// 省略...
		try {
			// 核心环节
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		// 省略...
	}

createBean分支：AbstractAutowireCapableBeanFactory的doCreateBean方法，这个方法包含了实例化，依赖注入，初始化

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		// 实例化Bean
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.markAsPostProcessed();
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			// 核心环节：依赖注入 
			populateBean(beanName, mbd, instanceWrapper);
			// 核心环节：初始化
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		// 省略...
		return exposedObject;
	}

createBean分支：populateBean(beanName, mbd, instanceWrapper);依赖注入
createBean分支：exposedObject = initializeBean(beanName, exposedObject, mbd);初始化bean

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		// 如果bean实现了BeanNameAware，BeanClassLoaderAware，BeanFactoryAware则执行这三个接口对应的实现方法
		invokeAwareMethods(beanName, bean);
		Object wrappedBean = bean;
		// 执行bean后置处理器的postProcessBeforeInitialization方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
		try {
			// 调用Bean的初始化方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		// 省略...
		if (mbd == null || !mbd.isSynthetic()) {
			// 执行bean后置处理器的postProcessAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}

到这里，AbstractBeanFactory的doGetBean方法中的getSingleton()方法的第二参数ObjectFactory<?>已经获取到了，接下来进入getSingleton方法的实现

if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							// Explicitly remove instance from singleton cache: It might have been put there
							// eagerly by the creation process, to allow for circular reference resolution.
							// Also remove any beans that received a temporary reference to the bean.
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

DefaultSingletonBeanRegistry实现了getSingleton方法，核心方法有addSingleton(beanName, singletonObject)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			// 省略...
				if (newSingleton) {
					// 核心环节，添加到单实例
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

DefaultSingletonBeanRegistry的addSingleton方法，作用是将给定的单例对象添加到此工厂的单例缓存中。用于对单例进行急切注册（非延迟注册）时调用

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 将对象放入一级缓存
			this.singletonObjects.put(beanName, singletonObject);
			// 移除三级缓存中的该对象
			this.singletonFactories.remove(beanName);
			// 移除二级缓存中的该对象
			this.earlySingletonObjects.remove(beanName);
			// 将 beanName添加registeredSingletons集合中，表示这个单例对象已经在工厂中注册
			this.registeredSingletons.add(beanName);
		}
	}
12，finishRefresh();发布相应的事件
	protected void finishRefresh() {
		// 清理上下文级别的资源缓存
		// Clear context-level resource caches (such as ASM metadata from scanning).
		clearResourceCaches();
		// 初始化生命周期处理器
		// Initialize lifecycle processor for this context.
		initLifecycleProcessor();
		// 通知生命周期处理器完成刷新操作
		// Propagate refresh to lifecycle processor first.
		getLifecycleProcessor().onRefresh();
		// 发布上下文刷新事件
		// Publish the final event.
		publishEvent(new ContextRefreshedEvent(this));
	}
西瓜'
关注
  • 21
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
this.refreshContext(context)；
qq_44587855的博客
11-24 240
this.refreshContext(context); 当前context类型： private void refreshContext(ConfigurableApplicationContext context) { if (this.registerShutdownHook) { shutdownHook.registerApplicationContext(context); } this.refresh...
Springboot 源码分析 —— refreshContext() 解析
一步一步往上爬
05-11 2242
spring refresh() 方法解析。解析配置类流程。解析 autocofiguration 类流程
【SpringBoot】 热部署 ContextRefresher.refresh() 自定义配置一键刷新 ~
最新发布
qq_43571809的博客
01-30 1183
一定要多思考，如果人永远待在舒适圈的话，人永远不会成长。共勉觉得作者写的不错的，值得你们借鉴的话，就请点一个免费的赞吧！这个对我来说真的很重要。
SpringBoot源码（十一）： refreshContext（一）
xby7437的博客
04-13 735
介绍 refreshContext是springBoot启动源码中最复杂的部分了，里面的内容也非常多，将会拆分很多个章节去说。 源码 refreshContext里面就是调用AbstractApplicationContext的refresh的方法。主要的功能就是注册spring容器里面的bean，以及对bean的处理还有广播等功能。 接着看源码吧 public void refresh() throws BeansException, IllegalStateException { sy
Spring Boot源码解析.2.解析refreshContext
Christopher_L1n的博客
07-12 205
Spring Boot启动过程源码解析——refreshContext解析。
SpringBoot启动refreshContext(context)方法
君子以自强不息
12-08 1085
refreshContext 函数 refresh(context); //1、 刷新上下文环境，加载对应的实例信息 if (this.registerShutdownHook) { try { context.registerShutdownHook(); //注册钩子函数，当shutdown时，执行。 } catch (AccessControlException ex) { // Not allowed in some environments. }
java源码包---java 源码 大量 实例
04-18
5个目标文件，演示Address EJB的实现，创建一个EJB测试客户端，得到名字上下文，查询jndi名，通过强制转型得到Home接口，getInitialContext()函数返回一个经过初始化的上下文，用client的getHome()函数调用Home接口...
JAVA上百实例源码以及开源项目源代码
09-17
5个目标文件，演示Address EJB的实现，创建一个EJB测试客户端，得到名字上下文，查询jndi名，通过强制转型得到Home接口，getInitialContext()函数返回一个经过初始化的上下文，用client的getHome()函数调用Home接口...
JAVA上百实例源码以及开源项目
01-03
5个目标文件，演示Address EJB的实现，创建一个EJB测试客户端，得到名字上下文，查询jndi名，通过强制转型得到Home接口，getInitialContext()函数返回一个经过初始化的上下文，用client的getHome()函数调用Home接口...
JAVA上百实例源码以及开源项目源代码 java开源包2
09-24
5个目标文件，演示Address EJB的实现，创建一个EJB测试客户端，得到名字上下文，查询jndi名，通过强制转型得到Home接口，getInitialContext()函数返回一个经过初始化的上下文，用client的getHome()函数调用Home接口...
SpringBoot 源码阅读（8）：refreshContext
qq_42323598的博客
07-30 301
refreshContext private void refreshContext(ConfigurableApplicationContext context) { refresh(context); if (this.registerShutdownHook) { try { context.registerShutdownHook(); } catch (AccessControlException ex) { // Not allowed in some environ
SpringBoot 源码分析刷新应用上下文(3)-refreshContext
一片叶子的博客
06-12 1326
一：入口这一步会解析 @Import 注解，@ComponentScan 注解，通过扫描路径得到被 @Controller、@Service、@Component所标注的这些类并且实例对象存到 IOC 容器中。二、refreshContext 方法实现截图：接着看 refresh(context);截图：接着看 refresh() 方法实现截图：接着看上面截图红框的方法 invokeBeanFactoryPostProcessors(beanFactory);
refreshContext(context)方法源码探究
weixin_30901729的博客
04-02 292
该方法目的是刷新应用上下文,是容器启动最主要的方法,其实现是一个模板方法,内容巨大,所以先看模板方法都做了哪些事,然后再细看每个方法的实现机制. refreshContext(context)方法首先调用了本类中一个refresh(context)方法: 然后在该方法中,context变身AbstractApplicationContext调用了后者的refresh()方法,该方法就是上面...
SpringBoot启动流程分析六 refreshContext()
qq_22162093的博客
07-10 690
前面讲完了prepareContext流程，接下来讲refreshContext方法： 先进入refreshContext方法：最终执行方法是AbstractApplicationContext类 public void refresh() throws BeansException, IllegalStateException { synchronized(this.startupShutdownMonitor) { // 准备刷新 this.pr
springboot run方法执行流程详解（四）——refreshContext
三3三的博客
10-21 375
10 这个方法很重要，本篇会详细介绍这个方法，请耐心阅读。。。 this.refreshContext(context); //刷新应用上下文 我们点进去看下具体执行了哪些操作：
SpringBoot中refreshContext核心方法
shuaigepengge的博客
06-16 1345
SpringBoot中refreshContext核心方法讲解refreshContext：以下是十三个子方法调用 refreshContext：以下是十三个子方法调用 方法一： this.prepareRefresh(); ## 该方法主要作用： 1、设置容器的状态 2、初始化属性设置（应用监听器） 3、检查必备属性是否存在 方法二: this.obtainFreshBeanFactory(); 该方法主要作用： 1、设置beanFactory序列化id 2、
SpringBoot源码 | refreshContext方法解析
csdn565973850的博客
03-28 397
在SpringBoot启动流程中，refreshContext虽然执行步骤较多，加载的类也比较丰富，从准备刷新上下文到为上下文准备bean工厂及配置上下文类加载器，后置处理器到初始化上下文消息源、事件多播以及最后的检查监听器并注册以及实例化剩余的单例bean，最后发布事件，重置Spring核心中的公共内省缓存，整体流程比较清晰，源码给的注释也很丰富，很方便对源码的学习。
SpringBoot源码之容器刷新 refreshContext 方法详解
my的博客
08-23 491
highlight: androidstudio 上一篇我们聊了Springboot的run方法，今天我们聊下关于容器刷新(refresh) 本文很长，请各位同学要忍一下~~~ 好了，废话不多说，直接开干 !!! 1.refresh 主方法 (重要) ``` java public void refresh() throws BeansException, IllegalStateE...
SpringBoot源码解析（1.3.3）-自动装配原理（refreshContext）
sql2008help的博客
03-10 348
SpringBoot源码解析（1.3.3）-自动装配原理（refreshContext） 承接上文：https://blog.csdn.net/sql2008help/article/details/123311657 在 SpringApplication prepareContext 方法中通过调用 load 方法加载带有 @SpringBootApplication 注解的启动类 SpringbootDemoApplication，此时springboot容器只是注册了启动类定义，还并没有解析此注解，
SpringBoot源码深度解析：自动装配与启动原理
"王炸篇的springboot源码解析，涵盖了spring注解的预习、自动装配原理、jar和War包的启动方式，以及作业：自定义启动器与spring注解导入Bean的方法" 在本节中，我们将深入探讨Spring Boot的核心概念和源码，特别是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值