Spring源码分析之Bean的生命周期（上）

最新推荐文章于 2024-06-30 00:30:00 发布
最新推荐文章于 2024-06-30 00:30:00 发布
阅读量308 收藏
点赞数
分类专栏： spring源码解析 bean的生命周期 spring 文章标签： java spring bean ioc 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44735065/article/details/110871770
版权

目录

Spring最重要的工作就是帮助我们创建对象(IOC inversion of control)并且可以根据配置完成依赖注入(DI Dependency Injection)以此来降低代码的耦合度。

启动Spring就是为创建Bean做准备，从创建到销毁。这一过程就是Bean的生命周期；
这张图就是一个Bean完整的生命周期图

说明：由于整个Bean生命周期的内容太多，所以我将分为上、下两篇博客来写。文中标注【坑x】，表示在生命周期这部分不适合展开来分析，我以后会把我这篇博客里挖坑都给填上。

Spring开始创建Bean的时机

Spring在refresh()方法中调用finishBeanFactoryInitialization(beanFactory) 方法；
完成beanFactory的初始化（实例化非懒加载的单例bean）；
最终会去调用AbstractAutowireCapableBeanFactory类里的createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)去创建Bean

	@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();
			// Tell the subclass to refresh the internal bean factory.
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);
			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);  //BeanDefinitionRegistryPostProcessor ,BeanFactoryPostProcessors
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);
				// Initialize message source for this context.
				initMessageSource();
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();
				// Initialize other special beans in specific context subclasses.
				onRefresh();
				// Check for listener beans and register them.
				registerListeners();

				// Instantiate all remaining (non-lazy-init) singletons.
				// 完成beanFactory的初始化（实例化非懒加载的单例bean）
				finishBeanFactoryInitialization(beanFactory);
				// Last step: publish corresponding event.
				finishRefresh();
			}
			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

一、加载类

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

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		// 1.加载类
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			// 2.实例化前 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 {
			//Spring自带的创建bean的方法
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

合并好的BeanDefinition【坑1】会存储一个Bean的Class信息，去加载类

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

二、实例化前

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);

这个方法最终会调用applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)方法。

	@Nullable
	protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
				if (result != null) {
					return result;
				}
			}
		}
		return null;
	}

Spring会将所有的后置处理器取出来，根据实现了InstantiationAwareBeanPostProcessor的后置处理器，在一个bean实例化前去做一些操作，我自己定义一个后置处理器 TestBeanPostProcessor 。

@Component
public class TestBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		if ("userService".equals(beanName)) {
			System.out.println("userService 即将实例化");
			//return new User();
		}
		return null;
	}

@Component
public class User {}

public class UserService {
    
    private String beanName;
    
    @Autowired
    private User user;
	
    public void setBeanName(String name) {
        this.beanName = name;
    }

    @Override
    public String toString() {
        return "UserService{" +
                "beanName='" + beanName + '\'' +
                ", user=" + user +
                '}';
    }
}    

@ComponentScan(value = "com.spring")
public class AppConfig {

	@Bean
	public UserService userService() {
		return new UserService();
	}
}

public class Test {

	public static void main(String[] args) {

		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
}

结果
在这里插入图片描述
要注意此时userService还没有实例化为对象。

补充
如果这里返回的不是null,而是一个对象那么 createBean方法会执行完毕，不会走后面Spring正常创建bean的流程。直接返回这个对象。比如在这里你希望最终拿到一个userService对象，但是有可能会拿到一个user对象。

	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
			//省略...
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  // 对象
			if (bean != null) {
				return bean;
			}
			//省略...
}

在这里插入图片描述

三、实例化

再往下走，会去执行doCreateBean方法，我们下面的流程都在这个方法当中。

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

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// factoryBeanObjectCache：存的是beanName对应的FactoryBean.getObject()所返回的对象
			// factoryBeanInstanceCache：存的是beanName对应的FactoryBean实例对象
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}

		// 3.实例化
		if (instanceWrapper == null) {
			// 创建bean实例  new USerSerive()
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

		// 原始对象
		final 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 {
					// 运行修改合并好了的BeanDefinition
					// 这里会查找@Autowired的注入点(InjectedElement)，并把这些注入点添加到mbd的属性externallyManagedConfigMembers中
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 如果当前创建的是单例bean，并且允许循环依赖，并且还在创建过程中，那么则提早暴露
		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还没有完成属性注入，是一个非常简单的对象
			// 构造一个对象工厂添加到singletonFactories中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		// 对象已经暴露出去了
		Object exposedObject = bean;
		try {
			// 4.填充属性 @Autowired
			populateBean(beanName, mbd, instanceWrapper);

			// 5.初始化 和 BeanPostProcessor 正常AOP
			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) {
			// 在解决循环依赖时，当AService的属性注入完了之后，从getSingleton中得到AService AOP之后的代理对象
			Object earlySingletonReference = getSingleton(beanName, false);  // earlySingletonObjects
			if (earlySingletonReference != null) {
				// 如果提前暴露的对象和经过了完整的生命周期后的对象相等，则把代理对象赋值给exposedObject
				// 最终会添加到singletonObjects中去
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
			}
				// 如果提前暴露的对象和经过了完整的生命周期后的对象不相等
				// allowRawInjectionDespiteWrapping表示在循环依赖时，只能
				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()) 
						// 也就是说其他bean没有用到AService的最终版本
						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.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

我一会儿再补充FactoryBean相关的知识。首先执行实例化的代码：

		if (instanceWrapper == null) {
			// 创建bean实例  new UserSerive()
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}

这里可以理解为new了一个对象，然后将其包装为BeanWapper对象。这里涉及到推断构造方法【坑2】。
BeanWrapper是对Bean的包装，缓存了bean的内省结果。我们可以获取被包装的对象；获取被包装bean的属性描述器，由于BeanWrapper接口是PropertyAccessor的子接口，因此其也可以设置以及访问被包装对象的属性值。

四、实例化后-填充属性

在这一阶段之前Spring会对BeanDefinition进行处理,并且处理循环依赖问题【坑3】。

	//填充属性
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		// 可以提供InstantiationAwareBeanPostProcessor，控制对象的属性注入
		// 我们可以自己写一个InstantiationAwareBeanPostProcessor，然后重写postProcessAfterInstantiation方法返回false,那么则不会进行属性填充了
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}

		// 是否在BeanDefinition中设置了属性值
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		//  autowire属性
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();  // BeanDefinition AutowireMode
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			// by_name是根据根据属性名字找bean
			// by_type是根据属性所对应的set方法的参数类型找bean
			// 找到bean之后都要调用set方法进行注入

			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;

			// 总结一下
			// 其实就是Spring自动的根据某个类中的set方法来找bean，byName就是根据某个set方法所对应的属性名去找bean
			// byType，就是根据某个set方法的参数类型去找bean
			// 注意，执行完这里的代码之后，这是把属性以及找到的值存在了pvs里面，并没有完成反射赋值
		}

		// 执行完了Spring的自动注入之后，就开始解析@Autowired，这里叫做实例化回调
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);


		// @Autowired注解的 AutowiredAnnotationBeanPostProcessor
		// @Resource注解的 CommonAnnotationBeanPostProcessor
		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

					// 调用BeanPostProcessor分别解析@Autowired、@Resource、@Value，得到属性值
					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) {
			// pvs存的就是属性已经对应的值
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

在这个方法里面Spring使用实现了InstantiationAwareBeanPostProcessor的后置处理器对实例化后的Bean进行处理。

	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					return;
				}
			}
		}
	}

@Component
public class TestBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
	@Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("userService 已完成实例化");
            System.out.println(bean);
        }
        return true;
    }
}

结果:
在这里插入图片描述
之前的后置处理器的入参只有bean的Class对象，现在变为了Object对象，说明实例化完成。还可以看出此时的user属性为空，说明还没有开始依赖注入【坑4】。
而下面这部分代码就完成了属性依赖注入。

		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 调用BeanPostProcessor分别解析@Autowired、@Resource、@Value，得到属性值
				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;
			}
		}

@Component
public class TestBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
	
	@Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("userService 完成属性注入");
            System.out.println(bean.toString());
        }
        return pvs;
    }
}

结果：
在这里插入图片描述

五、初始化相关

接下来开始进行初始化的流程。参见 Spring中Bean的生命周期（下）

补充 FactoryBean

本来想简单说一下，后来想想还是详细介绍一下吧。关于FactoryBean,参见我的这一篇博客:Spring源码分析之FactoryBean.

Baci U
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring bean的生命周期
weixin_34143774的博客
05-15 854
spring bean的生命周期 （1）实例化Bean： 对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。 （2）设置对象属性（依...
Bean的生命周期
weixin_66202611的博客
08-08 756
目录一，bean的初始化（1）Spring的IOC和AOP：（2）Spring Bean的生命周期：二，单例模式与多例模式的区别区别 《代码演示》前言 如图 《代码测试》在正式初始化之前会调用init方法，而我调用的this.init();方法会有专门的人员来写，就是BeanFactoryPostProcessor《提取代码》 《整体代码》 二，单例模式与多例模式的区别 区别 num的值不一样，是由一个类创建了两个对象，但是两个对象是同一个对象，这就是单例 配置文件
bean的生命周期（最全最细讲解）
热门推荐
a910247的博客
06-14 4万+
其定义为：从对象的创建到销毁的过程。而Spring中的一个Bean从开始到结束经历很多过程，但总体可以分为六个阶段Bean定义、实例化、属性赋值、初始化、生存期、销毁。 2.SpringBean生命周期中的增强接口PostProcessor；postProcessBeforeInitialization方法执行前，会执行很多Aware类型的接口，这种类型接口作用是加载资源到Spring容器中。我们在创建一个MyBeanPost的类来实现BeanPostProcessor接口。 ​ ......
【Spring】Spring Bean生命周期详解
最新发布
九师兄
06-30 116
转载：Bean生命周期详解扩展文章：【Spring】Spring Bean 生命周期 本文主要详解bean的生命周期，分为12个环节，每个环节中spring都提供了一些扩展点，我们都将进行详细说明，让大家全面掌握这块的知识。阶段1：Bean元信息配置阶段 阶段2：Bean元信息解析阶段 阶段3：将Bean注册到容器中 阶段4：BeanDefinition合并阶段 阶段5：Bean Class加载阶段 阶段6：Bean实例化阶段（2个小阶段）Bean实例化前阶段Bean实例化阶段阶段7：合并后的BeanDef
【Spring6】| Bean的生命周期（五步、七步、十步法剖析）
m0_61933976的博客
03-13 1万+
【Spring6】| Bean的生命周期（五步、七步、十步法剖析）
Bean 的生命周期总结
qq_62274623的博客
09-09 7180
Java 中的公共类称之为 Bean 或 Java Bean，而 Spring 中的 Bean 指的是将对象的生命周期，交个 Spring IoC 容器来管理的对象。所以 Spring 中的 Bean 对象在使用时，无需通过 new 来创建对象，只需要通过 DI（依赖注入），从 Spring 中取出要使用的对象即可。因为初始化的前置方法和后置方法是为所有 Bean 服务的，而非为某一个 Bean 服务的，所以这两个方法不能写在某个具体的 Bean 中，否则（这两个方法）不会执行。
Spring之Bean生命周期源码解析(一)
a6636656的博客
04-15 511
Spring之Bean生命周期源码解析(一) Bean生命周期流程 Bean包扫描底层流程 MetadataReader 合并BeanDefinition 加载类 什么是Bean的生命周期 Bean的生命周期就是指:在Spring中,一个Bean是如何生成的,如何销毁的 Bean生命周期流程图 Bean的生命周期: 启动ApplicationContext 创建BeanFactory 初始化BeanFactory 在BeanFactory后置处理：在这里会进行包扫描,找.
Spring源码分析系列-Bean的生命周期（总结篇）
黄智霖的博客
05-20 2397
ApplicationContext和BeanFactory BeanFactory是Spring中的顶层接口，只负责管理bean， BeanDefinitionReader和BeanDefinitionRegistry Bean的生命周期 一个被Spring管理的Bean，首先被加载之后首先会被包装成一个BeanDefinition，BeanDefinition代表了一个Spring中Bean的各种基础属性，比如作用域、是否懒加载、所属类class、自动装配类型等等。类被包装成BeanDefinitio
Spring 源码分析（Bean的初始化）
12-21
在整个初始化过程中，Spring通过一系列的回调接口和事件机制，使得开发者可以自定义Bean的生命周期行为，比如添加初始化或销毁方法，实现Bean的自定义初始化逻辑。 总结起来，Spring的Bean初始化是一个复杂而精细的...
深入解析Spring IoC：源码与实践指南
12-13
Spring Bean的生命周期包括创建、初始化、使用和销毁四个阶段。在初始化阶段，Spring会调用`BeanPostProcessor`的后处理方法，例如`postProcessBeforeInitialization()`和`postProcessAfterInitialization()`，允许...
Tom_深入分析Spring源码
02-06
《Spring源码分析》这份资料深入探讨了Spring框架的核心机制，尤其聚焦于Spring5版本。Spring作为Java领域中最重要的轻量级应用框架之一，它的设计理念、实现方式以及工作原理对于任何想成为优秀Java开发者的人都至...
Spring源码分析.rar
12-23
《Spring源码分析》 Spring框架作为Java领域最流行的开源框架之一，它的设计思想和实现方式一直是许多开发者深入研究的对象。这份"Spring源码分析"资料深入探讨了Spring的核心机制，帮助我们理解其背后的原理，从而...
Spring源码分析.docx
07-08
"Spring源码分析" 在 Spring 框架中，Bean 对象的创建过程是一个复杂的过程，涉及到多个步骤和接口。下面将对 Spring 源码中 Bean 对象的创建过程进行分析和解释。 1. 创建工厂，到达 BeanDefinition 步骤 在 ...
去字节面试，直接让人出门左拐：Bean 生命周期都不知道！
Candyz7的博客
09-06 1218
IoC，控制反转，想必大家都知道，所谓的控制反转，就是把 new 对象的权利交给容器，所有的对象都被容器控制，这就叫所谓的控制反转。IoC 很好地体现了面向对象设计法则之一 —— 好莱坞法则：“别找我们，我们找你”，即由 IoC 容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。理解好 IoC 的关键是要明确 “谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”。谁控制谁，控制什么？
7、Bean的生命周期
qq_67720621的博客
11-11 3725
7、Bean的生命周期
bean的生命周期详解
莪是男神的博客
03-13 1026
简单来说，bean 的生命周期其实指的就是 Spring 创建 bean 的一个过程。这个过程并不复杂，主要有以下四个步骤：实例化、属性注入、初始化，以及最后的销毁。但是对于一些复杂 (例如依赖关系比较复杂) 的 bean ，其创建可能会多一些步骤，因为现实情况中 Spring 会在 bean 的生命周期中开放很多的接口，让我们加载 bean 的时候对 bean 做一些自定义操作 (不过通常情况下我们是用不到的)
bean的生命周期
weixin_45723046的博客
05-02 2万+
六、bean的生命周期 https://liayun.blog.csdn.net/article/details/110670961 Bean 的初始化和销毁； 1、@Bean注解中使用init-method属性和destroy-method属性来指定初始化方法和销毁方法。 初始化和销毁方法的时机： 你有没有想过这样一个问题，初始化方法和销毁方法是在什么时候被调用的啊？ bean对象的初始化方法调用的时机：对象创建完成，如果对象中存在一些属性，并且这些属性也都赋好值之后，那么就会调用bean的初始化方
深度探索：Spring IoC源码解析与Bean生命周期
"本文深入解析了Spring IoC的源码机制，主要关注Spring框架中IoC容器的初始化、Bean工厂的实例化、...通过源码分析，开发者可以学习到如何调试和定制Spring容器，以及如何利用Bean的生命周期特性来满足特定的业务需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值