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

已于 2022-11-19 14:41:35 修改
阅读量372 收藏
点赞数 1
分类专栏： spring原理及源码 文章标签： java 前端 jvm
于 2022-11-09 18:00:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42878176/article/details/127768684
版权

目录

一、整体流程

在这里插入图片描述

二、流程分解

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

创建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扩展点。
吖土豆
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring Bean生命周期源码详解
qq_44027353的博客
04-23 1392
之后child需要根据BeanDefinition来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition，也就是RootBeanDefinition。我们知道BeanPostProcessor接口的作用是在bean初始化前和初始化后执行一些方法，Spring提供了该接口的子接口来进行实例化前后执行的一些方法。可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。
浅谈Spring bean 生命周期验证
08-29
浅谈Spring bean 生命周期验证 Spring bean 生命周期验证是 Spring 框架中一个非常重要的概念，它描述了 bean 从创建到销毁的整个生命周期。了解 Spring bean 生命周期可以帮助开发者更好地理解 Spring 框架，并...
03-Spring之Bean生命周期源码解析上
future-wy
09-09 304
Spring核心IOC（对象创建）、AOP，而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。 Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的 Bean生命周期流程图 Bean的生成过程 1. 生成BeanDefinition Spring启动的时候会进行扫描，会先调用org.springframework.context.annotation.ClassPathS.
Spring源码十四：Spring生命周期
最新发布
Jeremy程序员
07-06 550
上一篇我们在中看到了Spring会在refresh方法中去调用我们的finishBeanFactoryInitialization方法去实例化，所有非懒加载器单例的bean。并实例化后的实例放到单例缓存中。到此我们refresh方法已经接近尾声。Spring的生命周期。
spring bean生命周期源码剖析
stay_the_course的博客
10-04 2507
spring bean生命周期记不住？看完这篇源码剖析就会了，根本不用背诵
Spring 源码解析 Spring生命周期详解
qq_29767649的博客
07-04 317
前言： ① Spring 利用 策略模式 在生命周期中执行各种 后置处理器，每种后置处理器实现不同的功能。 ② Spring 中到处用到了缓存，比如getBean() 时，会去缓存中查找，缓存中没有再去创建Bean。 Spring中最重要的三级缓存 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一级缓存 private fina...
Spring Bean生命周期源码篇
qq_43649937的博客
04-26 1807
这里先对AOP进行简单的介绍AOP （AspectOrient Programming）,直译过来就是 面向切面编程,AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向切面编程，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。AOP可以拦截指定的方法并且对方法增强，而且无需侵入到业务代码中，使业务与非业务处理逻辑分离，比如Spring的事务，通过事务的注解配置，Spring会自动在业务方法中开启、提交业务，并且在业务处理失败时，执行相应的回滚策略。
Spring源码深度解析第二版
11-15
Spring源码深度解析第二版 Spring是一款广泛应用于Java企业级应用程序的开源框架，旨在简化Java应用程序的开发和部署。Spring框架的核心主要包括了IoC容器、AOP、MVC框架等模块。 第1章 Spring整体架构和环境搭建 ...
深度解析 Spring 源码探寻Bean的生命周期.txt
05-07
深度解析 Spring 源码探寻Bean的生命周期
Spring源代码解析
12-30
本文将深入解析Spring的源代码，帮助开发者理解其内部机制，提升对框架的使用技巧和定制能力。 首先，Spring的核心模块包括IoC（Inversion of Control，控制反转）容器、AOP、数据访问/集成、Web模块等。IoC容器是...
Spring源码解析.zip
07-31
《Spring源码解析》 Spring框架作为Java领域最流行的开源框架之一，它的设计思想和实现原理一直是许多开发者深入研究的重点。本压缩包“Spring源码解析”提供了对Spring框架核心组件——IOC（Inversion of Control...
【Spring源码解析】 - 生命周期
qq_34125999的博客
02-27 4270
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 1187
前言 Spring 作为当前 Java 最流行、最强大的轻量级框架，受到了程序员的青睐。准确的了解 Spring Bean 的生命周期是非常必要的，Spring Bean 的生命周期是 Spring 面试热点问题，想要答好并不容易！本文将从源码的角度入手，帮助小伙伴彻底掌握 Spring Bean 的生命周期。 而 Spring Bean 的生命周期只有 4 个阶段： 主要逻辑都在 doCreateBean 方法（AbstractAutowireCapableBeanFactory类中，逻辑很清晰，就是顺
spring源码分析：spring生命周期
samll leaf
12-13 1232
最近在看springboot自动配置，看到了@Conditional,@ConditionalOnMissingBean等等。这些注解，一直研究他们是如何实现springboot的条件注解的。由他们回到了@Configuration,回到了ConfigurationClassPostProcessor。ConfigurationClassPostProcessor实现了BeanFactoryPost
Spring的Bean生命周期源码解读
qq_45887180的博客
06-05 401
spring源码解析
Spring之Bean生命周期源码解析
c243311364的博客
03-21 937
1.启动接口介绍 具体的流程图：Spring扫描底层流程 | ProcessOn免费在线作图,在线流程图,在线思维导图 | AnnotationConfigApplicationContext接口主要做了两件事情：1.scan 2.加载非懒加载的spring对象 68和70行是java中的JFR机制，相当于查看69行代码执行的黑盒子（耗时，性能等） ClassPathBeanDefinitionScanner接口主要是把扫描到的BeanDefinition注册到spring容器中
Spring Bean 生命周期源码
黄沙客栈
08-15 535
Spring Bean 生命周期非常重要，今天我们来进入到源码了解一下整个bean的生命周期 先来一张流程图(懒得画了，截图的) 大概了解了bean的生命周期后，我们来看源码
Spring Bean的生命周期源码分析
Turbo码先生
06-14 269
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 242
spring的容器初始化和bean生命周期源码整理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

吖土豆

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

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

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

打赏作者

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

抵扣说明：

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

余额充值