Spring Bean生命周期源码解析

最新推荐文章于 2024-06-22 08:00:00 发布
最新推荐文章于 2024-06-22 08:00:00 发布
阅读量364 收藏 1
点赞数
分类专栏： spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao6406879/article/details/115898849
版权

介绍

目前大部分的 Java 互联网项目，都是用 Spring作为基础框架，管理bean，融合其他框架。Spring Bean生命周期和我们日常开发密不可分，我们虽然可能不太了解原理，但每天都会用，且作为面试的重点、重灾区，让我们一探究竟。
我们众知的Spring Bean生命周期包含实例化、填充属性、初始化，这也是狭义上的Bean生命周期。
由于Spring Bean生命周期源内容较多，本文以较粗的粒度剖析源码，从spring启动到bean创建完成的过程，其他细节内容后期专门讲解。

源码解析

容器启动与包扫描

spring容器启动，注意本文的spring容器为AnnotationConfigApplicationContext，是基于注解的形式，你也可以使用基于xml形式的ClassPathXmlApplicationContext容器，原理相同。

	public AnnotationConfigApplicationContext(String... basePackages) {
		//初始化AnnotatedBeanDefinitionReader-读取注解的Bean读取器
		//初始化ClassPathBeanDefinitionScanner-包扫描器
		this();
		//包扫描操作
		scan(basePackages);
		//刷新spring容器，具体bean创建在其中
		refresh();
	}

scan最终会调用ClassPathBeanDefinitionScanner.doScan执行扫描操作，返回路径下BeanDefinitionHolder的集合。

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		//BeanDefinitionHolder为封装BeanDefinition的对象
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		//循环包扫描的路径
		for (String basePackage : basePackages) {
			//获取候选组件
			//过程：1.根绝路径匹配classPath下所有资源，即class文件
			//     2.循环资源，判断是否匹配，需匹配includeFilters
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//获取作用域元数据并设置至BeanDefinition
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				//获取beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				//若属于AbstractBeanDefinition，设置默认属性
				//lazyInit autowireMode dependencyCheck等
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				//若属于AnnotatedBeanDefinition，设置对应属性
				//包含lazyInit primary dependsOn role description
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//检查beanName有无冲突，不冲突则放入
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

refresh容器刷新

spring容器的初始化和bean创建的过程都在refresh中，我们也可通过beanFactory手动调用refresh方法，达到热加载bean的功能。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			//准备工作：设置启动时间、是否激活标识位
			//初始化属性源（property source）配置
			prepareRefresh();
			//获取BeanFactory；
			//默认实现是DefaultListableBeanFactory，在创建容器的时候创建的
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			//BeanFactory的预准备工作
			//如context的类加载器、BeanPostProcessor、Aware忽略等
			prepareBeanFactory(beanFactory);
			try {
				//BeanFactory准备工作完成后进行的后置处理工作
				//具体实现在不同的子类，如GenericWebApplicationContext添加
				//ServletContextAwareProcessor的BeanPostProcessor
				postProcessBeanFactory(beanFactory);
				//执行BeanFactoryPostProcessor的方法
				//主要执行spring自己的和我们自定义的BeanFactoryPostProcessor
				//此方法也是重点，后期专门文章介绍BeanFactoryPostProcessor
				invokeBeanFactoryPostProcessors(beanFactory);
				//注册BeanPostProcessor（Bean的后置处理器），
				//在创建bean的前后等执行
				registerBeanPostProcessors(beanFactory);
				//初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
				initMessageSource();
				//初始化事件派发器
				initApplicationEventMulticaster();
				 //子类重写这个方法，在容器刷新的时候可以自定义逻辑；
				 //如创建Tomcat，Jetty等WEB服务器
				onRefresh();
				 //注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的
				registerListeners();
				 //初始化所有剩下的非懒加载的单例bean
				finishBeanFactoryInitialization(beanFactory);
				//完成context的刷新。
				//主要是调用LifecycleProcessor的onRefresh()方法
				//并且发布事件（ContextRefreshedEvent）
				finishRefresh();
			}
			catch (BeansException ex) {
				destroyBeans();
				cancelRefresh(ex);
				throw ex;
			}
			finally {
				resetCommonCaches();
			}
		}
	}

finishBeanFactoryInitialization初始化剩下的非懒加载的单例bean

此方法为本文重点，我们定义的非懒加载单例bean都会在此方法中被加载，从beanDefinition转换成spring的bean。
finishBeanFactoryInitialization方法中调用beanFactory.preInstantiateSingletons()创建bean

@Override
	public void preInstantiateSingletons() throws BeansException {
		//将beanFactory中beanDefinitionNames取出构成beanNames 
		//beanDefinitionNames是扫描解析阶段放入
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
		//循环处理beanName 
		for (String beanName : beanNames) {
			//合并BeanDefinition，BeanDefinition存在父子关系，需将父类合并到子类
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//RootBeanDefinition非抽象且单例且非懒加载，才会在此创建
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//若为FactoryBean类型的beanName，会创建两个bean对象
				//&beanName为FactoryBean本身bean对象
				//beanName为FactoryBean实现的getObjectType返回类型，getObject返回对象
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
											((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				//不为FactoryBean则调用getBean获取bean，若获取不到则创建bean
				else {
					getBean(beanName);
				}
			}
		}
		//实现SmartInitializingSingleton的接口后
		//当所有单例 bean 都初始化完成以后
		//Spring的IOC容器会回调该接口的 afterSingletonsInstantiated()方法。
		//bean类中可实现SmartInitializingSingleton接口，自定义bean加载完成后回调
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

getBean 获取bean

getBean方法会调用doGetBean()方法，

	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		//返回bean名称，规范beanName
		final String beanName = transformedBeanName(name);
		Object bean;

		//先从缓存中取数据
		//spring有3级缓存，用于解决循环依赖
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		else {
		//省略部分不重要代码
			try {
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);
				//是否有@dependsOn注解，表示依赖bean，存在则需先创建依赖bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
						}
					}
				}
				// 判断是否单例，是则调用createBean创建bean
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							//创建失败销毁bean
							destroySingleton(beanName);
							throw ex;
						}
					});
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//省略原型bean代码，每次都创建bean
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}
		//省略部分代码 
		return (T) bean;
	}

doCreateBean 创建bean

createBean方法继续调用AbstractAutowireCapableBeanFactory.doCreateBean()方法，这也是最终创建bean的方法，非常重要。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
		BeanWrapper instanceWrapper = null;
		//若为单例，则先移除spring中beanName的bean
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		//实例化对象，此处只是spring选取构造函数反射实例化
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		//此方法用来缓存bean中的注解信息. 
		//此时对象已经创建出来, 但是spring还没有创建成功, 因为各种属性还未添加.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
				}
				mbd.postProcessed = true;
			}
		}
		//此处用来判断是否在创建，用来解决循环依赖
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		Object exposedObject = bean;
		try {
			//填充属性
			populateBean(beanName, mbd, instanceWrapper);
			//初始化
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
		}
		//省略循环依赖代码，后面有专门文章介绍
		return exposedObject;
	}

createBeanInstance 实例化对象

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		//省略部分代码
		//调用determineConstructorsFromBeanPostProcessors选择构造方法来创建对象
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}
		//使用默认的构无参造函数
		return instantiateBean(beanName, mbd);
	}

determineConstructorsFromBeanPostProcessors主要是循环所有BeanPostProcessor，调用SmartInstantiationAwareBeanPostProcessor类型的BeanPostProcessor，执行determineCandidateConstructors方法，若有返回值则调用此构造函数。若都没有返回null，使用默认的构无参造函数。

	protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
			throws BeansException {

		if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
					if (ctors != null) {
						return ctors;
					}
				}
			}
		}
		return null;
	}

如何使用有参构造方法来创建对象呢?
有四个判断条件.

  1. 通过上方,后置处理器,找到了唯一的有参构造
  2. BeanDefinition设置为自动创建的模式 AUTOWIRE_CONSTRUCTOR
  3. BeanDefinition我们设置了ConstructorArgumentValues, 还记得mybatis吗? 我们扫描完BeanDefinition后,给BeanDefinition设置使用什么构造参数和使用哪个beanClass.
  4. 调用singletonObject是,传入的args就不为空, 是有值的, 明确告诉你, 我需要构造方法创建.

populateBean 填充属性

	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		boolean continueWithPropertyPopulation = true;
		//调用beanPostProcess, 用来判断你的bean需不需要完成属性填充 ,
		//如果实现此接口返回false,那么spring不会帮我们填充属性.
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}
		//返回false直接返回
		if (!continueWithPropertyPopulation) {
			return;
		}
		
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		//设置自动注入模式，是感觉name还是type
		//默认是 AUTOWIRE_BY_NO.
		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		//使用后置处理器来处理对象, 例如require , autowire 注解
   		//调用beanPostProcess , InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法.
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

populateBean方法中主要两次使用beanPostProcessor，第一次用来判断是否需要进行属性填充，第二次用InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法来具体填充属性。

initializeBean 初始化bean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

初始化主要执行：
1、initializeBean方法中先调用后置处理器执行@PostConstruct
2、invokeInitMethods中执行InitializingBean接口中afterPropertiesSet方法
3、最后执行我们自定义的init方法
具体操作可见 : Spring系列之生命周期回调链接.

总结

spring创建bean过程相当的复杂，本文挑选主线，列出从容器启动到bean创建完成的主要过程。
主要包含：容器启动、包扫描、生成BeanDefinition、BeanFactoryPostProcessor修改BeanDefinition、选取构造函数、反射实例化对象、填充属性、初始化、aop。

小小小金鱼
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈Spring bean 生命周期验证
08-29
浅谈Spring bean 生命周期验证 Spring bean 生命周期验证是 Spring 框架中一个非常重要的概念，它描述了 bean 从创建到销毁的整个生命周期。了解 Spring bean 生命周期可以帮助开发者更好地理解 Spring 框架，并...
Spring高手之路5——彻底掌握Bean的生命周期
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
06-15 8109
在这篇文章中，我们将深入研究Spring Framework的核心部分——Spring Bean的生命周期。我们将探讨初始化和销毁方法，了解如何使用@PostConstruct和@PreDestroy注解，以及实现InitializingBean和DisposableBean接口。我们还将详细讨论原型Bean的生命周期，并最后总结Spring中控制Bean生命周期的三种方式。无论你是Spring新手，还是想进一步提高你的Spring技能，这篇文章都能给你提供有价值的 insights。
Spring——Bean 的生命周期
浪漫不死的博客
03-21 1万+
目录一、Bean 的生命周期二、代码演示三、主要步骤简述 一、Bean 的生命周期   对于普通的 Java 对象，new 的时候会去创建对象，而当它没有任何引用的时候则被垃圾回收机制回收。相较于前者，由Spring IoC 容器托管的对象，它们的生命周期完全由容器控制。Spring 中每个 Bean 的生命周期如下： 对于 ApplicationContext 容器，当容器启动结束后，实例化所有的 Bean。 设置对象属性，即依赖注入，动态将依赖关系注入到对象中。 紧接着，Spring 会检测该对象
Spring Bean 生命周期详解
最新发布
常备不懈
06-22 1275
在 Spring 框架中，Bean 的生命周期由 Spring 容器全权管理。了解和掌握 Bean 的生命周期对于使用 Spring 开发稳定且高效的应用程序至关重要。本文将详细介绍 Spring Bean 生命周期的五个主要阶段：实例化、属性注入、初始化、使用和销毁，并涵盖各个阶段的关键步骤和扩展点。
Spring Bean的生命周期（非常详细）
iteye_7839的博客
07-05 5156
http://www.cnblogs.com/zrtqsk/p/3735273.html Spring作为当前Java最流行、最强大的轻量级框架，受到了程序员的热烈欢迎。准确的了解Spring Bean的生命周期是非常必要的。我们通常使用ApplicationContext作为Spring容器。这里，我们讲的也是 ApplicationContext中Bean的生命周期。而实际上Bean...
Spring中bean的生命周期
热门推荐
kykangyuky的博客
02-24 3万+
Spring中的bean的生命周期主要包含四个阶段：实例化Bean --＞ Bean属性填充 --＞ 初始化Bean --＞销毁Bean 首先是实例化Bean，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚末初始化的依赖时，容器就会调用doCreateBean()方法进行实例化，实际上就是通过反射的方式创建出一个bean对象 Bean实例创建出来后，接着就是给这个Bean对象进行属性填充，也就是注入这个Bean依赖的其它bean对象 属性填充完成后，进行...
SpringBean的生命周期
04-04 2万+
网络上对于spring生命周期的总结很多，对初学者来说看起来眼花缭乱，实际上Spring Bean的生命周期只有四个阶段。把这四个阶段和每个阶段对应的扩展点糅合在一起虽然没有问题，但是这样非常凌乱，难以记忆。要彻底搞清楚Spring的生命周期，首先要把这四个阶段牢牢记住。实例化和属性赋值对应构造方法和setter方法的注入，初始化和销毁是用户能自定义扩展的两个阶段。在这四步之间穿插的各种扩展点，稍后会讲。 实例化 Instantiation 属性赋值 Populate 初始化 Initializati
Spring源码解析手册
02-21
1.1 Bean的创建与初始化：在Spring中，Bean的生命周期管理是非常关键的。当我们声明一个`@Service`注解的类，如`Louzai1`和`Louzai2`，Spring会自动管理它们。`Louzai1`中有一个对`Louzai2`的依赖，反之亦然，形成...
Spring源码解析.zip
07-31
IoC是Spring的核心特性，它负责管理对象的生命周期和依赖关系。通过XML、注解或Java配置，我们可以定义Bean的创建方式和依赖关系。在源码中，`org.springframework.beans.factory`和`org.springframework.context`包...
Spring源码深度解析第二版
11-15
其中，核心容器是Spring框架的核心部分，负责管理Bean的生命周期，并提供了依赖注入、AOP等功能。 1.2 环境搭建 要想深入了解Spring框架的源码，首先需要搭建Spring框架的开发环境。开发环境主要包括了JDK、...
深度解析 Spring 源码探寻Bean的生命周期.txt
05-07
深度解析 Spring 源码探寻Bean的生命周期
SpringBean 生命周期源码解析
养歌的博客
01-17 1157
前言 Spring 作为当前 Java 最流行、最强大的轻量级框架，受到了程序员的青睐。准确的了解 Spring Bean 的生命周期是非常必要的，Spring Bean 的生命周期是 Spring 面试热点问题，想要答好并不容易！本文将从源码的角度入手，帮助小伙伴彻底掌握 Spring Bean 的生命周期。 而 Spring Bean 的生命周期只有 4 个阶段： 主要逻辑都在 doCreateBean 方法（AbstractAutowireCapableBeanFactory类中，逻辑很清晰，就是顺
Spring中Bean的生命周期
weixin_71786285的博客
12-11 4555
Spring Bean的生命周期是从Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中，这个过程被称为Spring Bean的生命周期。Spring Bean的生命周期大体上分为四个阶段：实例化——>属性注入——>初始化——>销毁。 一、实例化Bean:根据配置文件中Bean 的定义，利用Java Reflection反射技术创建Bean的实例 实例化Bean：根据配置文件中Bean的定义，利用Java反射反射技术创建Bean的实例。
Spring bean生命周期详解
weixin_44145478的博客
10-27 1万+
Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。 Spring bean生命周期 四个阶段 Bean的实例化阶段 Bean的设置属性阶段 Bean的 初始化阶段 Bean的销毁阶段 Spring bean生命周期13个环节 阶段1：Bean元信息配置阶段 阶段2：Bean元信息解析阶段 阶段3：将Bean注册到容器中 阶段4：BeanDefinition合并阶段 阶段5：Bean Class加载阶段 阶段6：Bean实例化阶
Spring Bean生命周期详解
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
Spring Bean生命周期源码篇
qq_43649937的博客
04-26 1776
这里先对AOP进行简单的介绍AOP （AspectOrient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
Spring 面试题
ZWL2333的博客
01-07 366
1.什么是IOC 控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法 IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。 对象由Spring来创建，管理，装配 将对象放到Spring容器中管理 1.在resource目录下创建配置文件，将对象通过id和class放入Spring容器 2. 通过classpathXMLApplicationConte
【spring】创建Bean的方法：createBean源码分析
qq_35436158的博客
02-22 537
深入了解Bean是如何创建的，在创建 过程中需要维护什么信息！
Spring高手之路4——深度解析Spring内置作用域及其在实践中的应用
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
06-10 8354
本文详细解析了Spring的内置作用域，包括Singleton、Prototype、Request、Session、Application和WebSocket作用域，并通过实例讲解了它们在实际开发中的应用。特别是Singleton和Prototype作用域，我们深入讨论了它们的定义、用途以及如何处理相关的线程安全问题。通过阅读本文，读者可以更深入地理解Spring作用域，并在实际开发中更有效地使用它们。
spring bean 生命周期源码解析
04-07
下面是Spring Bean生命周期的源码解析： 1. 实例化阶段：Spring使用反射机制调用Bean的构造方法来创建对象。 2. 属性赋值阶段：Spring使用反射机制或者BeanWrapper将属性值注入到Bean中。 3. 初始化阶段：Spring会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值