Spring源码之解析SpringBean的生命周期

原创 已于 2022-11-19 14:41:35 修改 · 518 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #前端 #jvm

于 2022-11-09 18:00:54 首次发布
本文详细解析了Spring框架中Bean的创建过程，包括createBean的逻辑、实例化策略、属性赋值与初始化的扩展点，以及AOP在BeanPostProcessor中的应用。重点讲解了MergedBeanDefinitionPostProcessor、SmartInitializingSingleton和BeanPostProcessor的使用场景。

目录

一、整体流程

在这里插入图片描述

二、流程分解

流程分为四个部分，分别是实例化、属性赋值、初始化、销毁

创建Bean的核心代码是AbstractAutowireCapableBeanFactory#createBean

2.1 createBean

在真正创建Bean之前，会先resolveBeforeInstantiation判断是否存在自定义创建bean，如没有，框架再去新创建一个。核心代码都在doCreateBean中，doCreateBean是才是真正创建Bean的地方。

	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		.......代码省略
		
		try {
			/** 在实例化之前判断该bean有没有被自定义创建
			* 根据InstantiationAwareBeanPostProcessors实现类的
			* applyBeanPostProcessorsBeforeInstantiation方法判断
			* 返回值不是null，表示已被自定义创建
			**/
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		try {
		    // 创建bean的核心代码
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
         .......代码省略
	}

resolveBeforeInstantiation:

applyBeanPostProcessorsBeforeInstantiation：获取所有InstantiationAwareBeanPostProcessor的实现类，执行postProcessBeforeInstantiation方法，如果该方法返回的对象不是null，则表示自定义指定bean，不再执行doCreateBean，并且会执行applyBeanPostProcessorsAfterInitialization方法设置bean。

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

2.2 doCreateBean

先总看一下doCreateBean的源码有哪些主要点，然后再逐个分解，主要的点有：（1）实例化bean（createBeanInstance）、（2）MergedBeanDefinitionPostProcessor初始化之前修改BeanDefinition的扩展点（比如扫描@Autowired）、（3）出现循环依赖提前暴露bean、（4）属性赋值（populateBean）、（5）初始化（initializeBean）、（6）判断在初始化的过程后bean是否还是原来的bean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
		    // 如果是单例模式，从缓存中清除
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
		    // 实例化bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
				    // 可以修改BeanDefinition的扩展点，可以初始化之前做一些工作，比如扫描一些属性的注解
                    // CommonAnnotationBeanPostProcessor -> @PostConstruct @PreDestroy @Resource
                    // AutowiredAnnotationBeanPostProcessor -> @Autowired @Value
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// 此处是如果发生了循环依赖的情况，提前暴露没创建完的bean，可以称为半成品的bean或实例化bean
		// getEarlyBeanReference方法中执行SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法
		// getEarlyBeanReference中可以对bean做一些操作，主要应用是Aop织入
		// 对循环依赖感兴趣的话可以去看我的另一篇关于循环依赖的文章。
		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");
			}
			// 提前暴露bean的获取
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}


		Object exposedObject = bean;
		try {
		    // 属性赋值
			populateBean(beanName, mbd, instanceWrapper);
			// 初始化bean
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			// 出现循环依赖的时候earlySingletonReference才不为null
			if (earlySingletonReference != null) {
			    // 这里判断在初始化的过程中，bean是否还是原来的bean，如果不是就会在下面的分支中报错
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// 注册到 disposableBeans 里面.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

2.3 实例化（createBeanInstance）

从这节开始到最后一节之前，讲的都是doCreateBean中的内容。

createBeanInstance： 提供了几种实例化bean的方式和扩展点。

  • instanceSupplier： 作为首选方式，用回调函数创建bean可以避免因使用反射而造成的性能丢失。因为工厂方法或者静态工厂创建bean都要用到反射。

  • 工厂方法：在定义bean的时候，自定义factory-method属性，指定创建bean的工厂方法。

  • 指定构造器创建：实现SmartInstantiationAwareBeanPostProcessor接口的determineCandidateConstructors指定构造器。

  • 无参构造创建： 默认方式，获取beanClass文件的无参构造，反射创建。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		
        // 利用提供的回调函数创建bean
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
        // 利用自定义的factory-method方法创建bean
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		.....代码省略

		// 判断是否有设置BeanPostProcessor指定构造器
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		.....代码省略

		// 没有特别处理，默认使用无参构造创建bean，默认执行instantiateBean
		return instantiateBean(beanName, mbd);
	}

2.4 MergedBeanDefinitionPostProcessor扩展点

实现MergedBeanDefinitionPostProcessor接口，对BeanDefinition做出来，比如实现类AutowiredAnnotationBeanPostProcessor，用于扫描@Autowired和@Value注解。

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}

2.5 属性赋值（populateBean）

这个方法中是对自定义对象属性的赋值，比如自定义的User类等等。

方法步骤：

  1. 执行InstantiationAwareBeanPostProcessors的后置处理器
  2. CommonAnnotationBeanPostProcessor处理@Resource标注的属性
  3. AutowiredAnnotationBeanPostProcessor处理@Autowired、@Value标注的属性
  4. 绑定属性值
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {

        .....代码省略
        
		/** 
		* 执行InstantiationAwareBeanPostProcessors的后置处理器
		* 如果postProcessAfterInstantiation返回false，不再继续执行populateBean，但对后续处理没有影响
		*/
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        // 自动注入模式，默认resolvedAutowireMode == AUTOWIRE_NO
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			/**
			* 这里有两个重要的BeanPostProcessors实现
			*   1. CommonAnnotationBeanPostProcessor： 处理@Resource标注的属性
			*   2. AutowiredAnnotationBeanPostProcessor：处理@Autowired、@Value标注的属性
			*/
			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 (pvs != null) {
		    // 属性绑定
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

2.6 初始化（initializeBean）

执行Aware接口对bean中的工厂对象属性赋值、执行创建Aop的扩展点等等、执行初始化方法

  • invokeAwareMethods： 执行bean实现的BeanNameAware、BeanClassLoaderAware和BeanFactoryAware接口的方法

  • applyBeanPostProcessorsBeforeInitialization： 执行所有BeanPostProcessor的前置处理器， 属于spring的扩展点，其中重要的有ApplicationContextAwareProcessor，用于执行bean实现的EnvironmentAware、ApplicationContextAware等Aware接口的方法

  • invokeInitMethods： 执行初始化方法init-method和afterPropertiesSet

  • applyBeanPostProcessorsAfterInitialization： 执行所有BeanPostProcessor的后置处理器，属于spring的扩展点，其中Aop就是在这里实现的，下一大节会讲述。

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 {
		    // 执行bean实现BeanNameAware、BeanClassLoaderAware、BeanFactoryAware的方法
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
		    // 执行所有BeanPostProcessor的前置处理器
		    // 其中重要的有ApplicationContextAwareProcessor，用于执行bean实现EnvironmentAware、ApplicationContextAware等等Aware接口的方法
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
		    // 执行初始化方法init-method和afterPropertiesSet
			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()) {
		    // 执行所有BeanPostProcessor的后置处理器
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

invokeInitMethods：

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

        // 判断是否实现了InitializingBean接口
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isTraceEnabled()) {
				logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
			     // 执行afterPropertiesSet
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			// 判断是否有init-method
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}

2.7 SmartInitializingSingleton扩展点

主要用于在IoC容器基本启动完成时进行扩展，这时非Lazy的Singleton都已被初始化完。

最后一步，bean创建完毕之后，如果bean实现了SmartInitializingSingleton接口，则执行afterSingletonsInstantiated()。这个是getBean()之后执行的。

// Trigger post-initialization callback for all applicable beans...
		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();
				}
			}
		}

三、在BeanPostProcessor中实现的Aop

在众多BeanPostProcessor的实现类中，有个名字很熟悉的实现类AbstractAutoProxyCreator。

在这里插入图片描述
看下它的后置处理方法，其中有个关于earlyProxyReferences的判断，这个是和循环依赖有关系，顺带提一嘴，在循环依赖中bean如果需要创建代理，不在这创建代理对象，而是在实例化的时候就要把代理对象创建出来，这里是为了防止重复创建代理对象才设置的判断。

	public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
		if (bean != null) {
			Object cacheKey = getCacheKey(bean.getClass(), beanName);
			if (this.earlyProxyReferences.remove(cacheKey) != bean) {
				return wrapIfNecessary(bean, beanName, cacheKey);
			}
		}
		return bean;
	}

wrapIfNecessary：

言归正传，可以看出wrapIfNecessary才是真正创建代理的方法。

在这个方法中我们会发现一个眼熟的方法createProxy，代理对象在这个方法中创建并返回。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

四、总结

生命周期步骤：

  1. 【实例化 - doCreateBean前】执行InstantiationAwareBeanPostProcessors的前置处理器，判断是否有已经指定创建好的对象。
  2. 【实例化 - createBeanInstance】选择实例化的方式，如回调函数、工厂方法、指定构造器等等。
  3. 【实例化 - createBeanInstance】无特别处理使用默认无参构造实例化（instantiateBean）。
  4. 【实例化 - createBeanInstance后】利用MergedBeanDefinitionPostProcessor扩展点修改BeanDefinition的定义信息。
  5. 【属性赋值 - populateBean前】执行InstantiationAwareBeanPostProcessors的后置处理器，一般用于自定义属性赋值。
  6. 【属性赋值 - populateBean】CommonAnnotationBeanPostProcessor： 处理@Resource标注的属性。
  7. 【属性赋值 - populateBean】AutowiredAnnotationBeanPostProcessor：处理@Autowired、@Value标注的属性。
  8. 【初始化 - initializeBean】invokeAwareMethods，执行bean实现BeanNameAware、BeanClassLoaderAware和BeanFactoryAware接口的方法。
  9. 【初始化 - initializeBean】执行所有BeanPostProcessor的前置处理器，其中重要的有ApplicationContextAwareProcessor，用于执行bean实现EnvironmentAware、ApplicationContextAware等等Aware接口的方法。
  10. 【初始化 - initializeBean】执行初始化方法init-method和afterPropertiesSet。
  11. 【初始化 - initializeBean】执行所有BeanPostProcessor的后置处理器。
  12. 【基本创建完毕后】执行SmartInitializingSingleton扩展点。
Spring Bean生命周期源码详解
qq_44027353的博客
04-23 1815
之后child需要根据BeanDefinition来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition，也就是RootBeanDefinition。我们知道BeanPostProcessor接口的作用是在bean初始化前和初始化后执行一些方法，Spring提供了该接口的子接口来进行实例化前后执行的一些方法。可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。
Spring中Bean的生命周期源码分析
BASK2311的博客
02-10 290
从服务的启动到服务的关闭整个流程下来梳理了Bean的整个生命周期，根据这个生命周期自己可以根据这个流程对Spring中容器的实现和Bean的注入流程有了更深的了解，更多细节的部分可以根据一下的源码流程进行debug，毕竟debug看源码是最快的，debug的方式可以知道在每一步入参和出参的结果，以及每一步的正向流程。
03-Spring之Bean生命周期源码解析上
future-wy
09-09 430
Spring核心IOC（对象创建）、AOP，而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。 Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的 Bean生命周期流程图 Bean的生成过程 1. 生成BeanDefinition Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathS.
spring bean生命周期源码剖析
stay_the_course的博客
10-04 2843
spring bean生命周期记不住？看完这篇源码剖析就会了，根本不用背诵
Spring 源码解析 Spring生命周期详解
qq_29767649的博客
07-04 391
前言： ① Spring 利用 策略模式 在生命周期中执行各种 后置处理器，每种后置处理器实现不同的功能。 ② Spring 中到处用到了缓存，比如getBean() 时，会去缓存中查找，缓存中没有再去创建Bean。 Spring中最重要的三级缓存 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存 private fina...
Spring之Bean生命周期源码解析(一)
a6636656的博客
04-15 676
Spring之Bean生命周期源码解析(一) Bean生命周期流程 Bean包扫描底层流程 MetadataReader 合并BeanDefinition 加载类 什么是Bean的生命周期 Bean的生命周期就是指:在Spring中,一个Bean是如何生成的,如何销毁的 Bean生命周期流程图 Bean的生命周期: 启动ApplicationContext 创建BeanFactory 初始化BeanFactory 在BeanFactory后置处理：在这里会进行包扫描,找.
Java开发Spring Bean生命周期全流程解析：基于IoC容器的实例化、初始化与销毁机制及扩展点应用
最新发布
12-10
使用场景及目标：①深入理解Spring Bean生命周期各阶段的执行流程与底层原理；②掌握面试中高频考察的初始化/销毁方法调用顺序、BeanPostProcessor作用等核心知识点；③提升对Spring IoC容器工作机制的认知，用于...
深入理解 Spring Bean 生命周期（附源码分析）
weixin_42118323的博客
05-14 1288
Spring Bean 的生命周期是面试中 Spring 系列的一个高频问题，本篇我们将从源码方面来剖析 Spring Bean 的生命周期。
浅谈Spring bean 生命周期验证
08-29
浅谈Spring bean 生命周期验证 Spring bean 生命周期验证是 Spring 框架中一个非常重要的概念，它描述了 bean 从创建到销毁的整个生命周期。了解 Spring bean 生命周期可以帮助开发者更好地理解 Spring 框架，并...
Spring Bean生命周期源码篇
qq_43649937的博客
04-26 2210
本文深入解析了Spring框架的核心原理，主要涵盖Bean生命周期、依赖注入、AOP实现和循环依赖处理机制。文章详细介绍了Bean的创建过程：从类加载、构造方法推断、依赖注入到初始化阶段，并重点分析了AOP的实现原理和事务管理机制。针对循环依赖问题，文章阐述了三级缓存（singletonObjects、earlySingletonObjects、singletonFactories）的解决方案。此外，还通过手写模拟代码展示了Spring底层工作机制，包括注解扫描、Bean创建、依赖注入和AOP代理等核心流程
【Spring源码解析】 - 生命周期
qq_34125999的博客
02-27 4327
1 Bean初始化、销毁 1.1 @Bean注解 @Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Bean { @AliasFor("name") String[] value(...
SpringBean 生命周期源码解析
养歌的博客
01-17 1427
前言 Spring 作为当前 Java 最流行、最强大的轻量级框架，受到了程序员的青睐。准确的了解 Spring Bean 的生命周期是非常必要的，Spring Bean 的生命周期是 Spring 面试热点问题，想要答好并不容易！本文将从源码的角度入手，帮助小伙伴彻底掌握 Spring Bean 的生命周期。 而 Spring Bean 的生命周期只有 4 个阶段： 主要逻辑都在 doCreateBean 方法（AbstractAutowireCapableBeanFactory类中，逻辑很清晰，就是顺
spring源码分析：spring生命周期
samll leaf
12-13 1333
最近在看springboot自动配置，看到了@Conditional,@ConditionalOnMissingBean等等。这些注解，一直研究他们是如何实现springboot的条件注解的。由他们回到了@Configuration,回到了ConfigurationClassPostProcessor。ConfigurationClassPostProcessor实现了BeanFactoryPost
Spring之Bean生命周期源码解析
c243311364的博客
03-21 1043
1.启动接口介绍 具体的流程图：Spring扫描底层流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 | AnnotationConfigApplicationContext接口主要做了两件事情：1.scan 2.加载非懒加载的spring对象 68和70行是java中的JFR机制，相当于查看69行代码执行的黑盒子（耗时，性能等） ClassPathBeanDefinitionScanner接口主要是把扫描到的BeanDefinition注册到spring容器中
Spring Bean 生命周期源码
黄沙客栈
08-15 615
Spring Bean 生命周期非常重要，今天我们来进入到源码了解一下整个bean的生命周期 先来一张流程图(懒得画了，截图的) 大概了解了bean的生命周期后，我们来看源码
Spring Bean的生命周期源码分析
Turbo码先生
06-14 598
Bean的生命周期 文章目录Bean的生命周期前言一、实例化Bean二、设置对象属性（依赖注入）三、initializeBean3.1 调用Aware接口3.2 调用BeanPostProcessor的前置处理3.3 invokeInitMethods3.3.1 afterPropertiesSet()3.3.2 invokeCustomInitMethod3.4 调用BeanPostProcessor的后置处理4 destory总结 前言 对于普通的Java对象，当new的时候创建对象，当它没有任
Spring的bean生命周期源码整理
m0_37588577的博客
11-01 363
spring的容器初始化和bean生命周期源码整理
Spring Bean生命周期源码解析
zhao6406879的博客
05-07 677
介绍 目前大部分的 Java 互联网项目，都是用 Spring作为基础框架，管理bean，融合其他框架。Spring Bean生命周期和我们日常开发密不可分，我们虽然可能不太了解原理，但每天都会用，且作为面试的重点、重灾区，让我们一探究竟。 我们众知的Spring Bean生命周期包含实例化、填充属性、初始化，这也是狭义上的Bean生命周期。 由于Spring Bean生命周期源内容较多，本文以较粗的粒度剖析源码，从spring启动到bean创建完成的过程，其他细节内容后期专门讲解。 源码解析 容器启动与包
【Spring】Spring之Bean生命周期源码解析
持续学习，坚持原创，分享技术笔记及经验。
07-28 752
Spring之Bean生命周期源码解析
深度探索：Spring IoC源码解析与Bean生命周期
"本文深入解析了Spring IoC的源码机制，主要关注Spring框架中IoC容器的初始化、Bean工厂的实例化、Bean定义的读取以及Bean的生命周期管理。通过对 AnnotationConfigApplicationContext 的实例化过程的分析，揭示了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吖土豆

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

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

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

打赏作者

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

抵扣说明：

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

余额充值