栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

《Spring》第五篇 Bean的生命周期 - 创建

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

《Spring》第五篇 Bean的生命周期 - 创建

一: Bean的生命周期

第一阶段: 扫描第二阶段: 实例化第三阶段: 属性注入第四阶段: 初始化

二: 举例验证

本文使用Spring源码的版本是5.0
在Spring启动的过程中, 容器中加载的都是非懒加载的单例Bean, 并且容器中都是一个个的BeanDefition,而原型Bean是在需要使用到Bean时新创建一个; 以在配置类中使用注解@ComponentScan定义扫描路径, 使用AnnotationConfigApplicationContext做为容器, 来了解Bean的生命周期;
生命周期从大类分 : 创建 + 销毁
从细化可分为: 扫描 + 实例化 + 属性注入 + 初始化 + 销毁

为何是非懒加载的单例Bean ?
在源码DefaultListableBeanFactory.preInstantiateSingletons()中有明确的判断条件, 见★标识处

public void preInstantiateSingletons() throws BeansException {
		if (logger.isDebugEnabled()) {
			logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		// beanNames : 容器中所有BeanDefition对应的bean主名称
		List beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		// 加载所有非懒加载的单例Bean
		for (String beanName : beanNames) {
			// 1.bean可能存在父子级关系,子BeanDefinition需要继承父BeanDefinition的某些特性, 所以需要做父子BeanDefinition的属性合并
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// ★  2.BeanDefinition不能是抽象的,必须是单例Bean,必须是非懒加载的, 满足此三个条件才允许加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				if (isFactoryBean(beanName)) {
					// 如果是工厂Bean, 那么beanName必须拼接上"&"前缀, 将工厂Bean与普通Bean做区分
					// 加载工厂Bean
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean factory = (FactoryBean) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
									getAccessControlContext());
						} else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean) factory).isEagerInit());
						}
						if (isEagerInit) {
							// 加载类
							getBean(beanName);
						}
					}
				} else {
					// 3. 根据主名称加载Bean
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		// 5. 将所有的非懒加载的单例Bean实例化初始化完成后,如果有单例Bean实现了SmartInitializingSingleton接口
		// 实现afterSingletonsInstantiated()方法, 做回调使用
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				} else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}
 
一: Bean的生命周期  
第一阶段: 扫描  

扫描阶段, 创建初始状态的BeanDefinition

    通过解析配置类AppConfig上注解@ComponentScan定义的扫描路径,将路径下的.class类封装成BeanDefition赋初始值,解析注解,并注册(解析的注解包括 @Lazy,@Primary,@DependsOn,@Description)合并BeanDefition

ClassPathBeanDefinitionScanner.doScan(String… basePackages)

   /**
	 * 根据指定路径扫描,生成BeanDefinition,并注册到容器中
	 * 此方法不会向容器中注册注释配置处理器processor
	 *
	 * @param basePackages @ComponentScan 注解定义的扫描路径,可以是多个
	 * @throws
	 * @return: java.util.Set
	 * @date 2022/1/12 8:40
	 */
protected Set doScan(String... basePackages) {   // @ComponentScan 注解扫描路径可以配置多个
		Assert.notEmpty(basePackages, "At least one base package must be specified");

		Set beanDefinitions = new linkedHashSet<>();
		for (String basePackage : basePackages) {
			Set candidates = findCandidateComponents(basePackage);  // ★ 核心方法: 真正的扫描
			for (BeanDefinition candidate : candidates) {
				Scopemetadata scopemetadata = this.scopemetadataResolver.resolveScopemetadata(candidate);
				candidate.setScope(scopemetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					// 给BeanDefinition的部分属性赋初始值,并判断bena是否有被自动注入到别的bean中
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					// 判断bean是否被@Lazy,@Primary,@DependsOn,@Description 注解定义
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}

				// 检查Spring容器中是否已经存在, key为beanName和value为 candidate 的键值对
				// BeanDefinitionHolder 可以理解将将 BeanDefinition封装成一个 key - value形式的结构
				// key 是beanName , value 是BeanDefinition
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopemetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);  //注册BeanDefinition
				}
			}
		}
		return beanDefinitions;
	}
1. 解析配置类上@ComponentScan注解定义的扫描路径,获取资源路径,并生成BeanDefinition

ClassPathScanningCandidateComponentProvider.scanCandidateComponents(String basePackage)

	private Set scanCandidateComponents(String basePackage) {
		Set candidates = new linkedHashSet<>();
		try {
			//转化指定的资源文件路径, packageSearchPath = classpath*:com/maker/**/*.class
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolvebasePackage(basePackage) + '/' + this.resourcePattern;
			// 通过通配符获取targetclasses指定目录所有的.class文件
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (Resource resource : resources) {  // 遍历扫描到的.class资源文件
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) { // 是否可以读取此资源的内容, 像getInputStream   默认true
					try {
						// getmetadataReaderFactory()  -> 获取一个元信息读取器工厂,如果初始工厂metadataReaderFactory为null,就创建一个CachingmetadataReaderFactory
						// getmetadataReader(resource) -> 通过资源resource从元数据读取器缓存中获取对应的metadataReader
						// 如果没有获取到就让CachingmetadataReaderFactory的父级SimplemetadataReaderFactory去创建一个SimplemetadataReader,最后放入元数据读取器缓存中, 并返回
						// 如果获取到,直接返回
						metadataReader metadataReader = getmetadataReaderFactory().getmetadataReader(resource);

						// 判断是否为一个bean
						// 成为一个bean的要求:
						// (1) 被@Component注解定义, 并且如果同时被@Conditional定义, 匹配的条件是通过的
						// (2) 使用@import注解导入,可以不在扫描路径上,但是必须被@Component定义,并且注解上必须定义别名
						// (3) 使用@Bean注解, 类上可以不使用@Component注解
						// (4) 一般不能是接口、抽象类或者非静态内部类; 如果是抽象类, 但是抽象类中有方法被注解@Lookup定义, 可以做为bean
						if (isCandidateComponent(metadataReader)) {
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								candidates.add(sbd);  // 所有的校验都通过, 确定是一个bean, 添加到BeanDefinition集合中
							} else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						} else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					} catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				} else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		} catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}
2. 赋初始值,解析注解,并注册

赋初始值 : AbstractBeanDefinition.applyDefaults()
解析注解 : AnnotationConfigUtils.processCommonDefinitionAnnotations()

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypemetadata metadata) {

		//判断bean是否被@Lazy定义
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		} else if (abd.getmetadata() != metadata) {
			lazy = attributesFor(abd.getmetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}

		//判断bean是否被@Primary定义
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}

		//判断bean是否被@DependsOn定义
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}

		if (abd instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;

			//判断bean是否被@Role定义
			AnnotationAttributes role = attributesFor(metadata, Role.class);
			if (role != null) {
				absBd.setRole(role.getNumber("value").intValue());
			}

			//判断bean是否被@Description定义
			AnnotationAttributes description = attributesFor(metadata, Description.class);
			if (description != null) {
				absBd.setDescription(description.getString("value"));
			}
		}
	}
3. 合并BeanDefition

由于Bean存在父子级的关系, 所以当父子Bean都被扫描成独立的BeanDefition时,子BeanDefition就需要从父BeanDefition中继承到某些属性值, 然后生成一个新的BeanDefition

AbstractBeanFactory.getMergedBeanDefinition()

   /**
	 * 合并父子BeanDefinition, 生成新的BeanDefinition
	 *
	 * @param beanName     非懒加载的单例Bean的名称
	 * @param bd           与beanName对应的BeanDefinition
	 * @param containingBd
	 * @throws
	 * @return: org.springframework.beans.factory.support.RootBeanDefinition
	 * @date 2022/1/12 15:00
	 */
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;

			// Check with full lock now in order to enforce the same merged instance.
			// containingBd 一般情况都是为null
			// 通过Bean的名称去合并BeanDefinition缓存中获取对应的BeanDefinition
			// 此时获取的BeanDefinition,已经是合并完成的了
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null) {
				// 不存在父级,说明当前的BeanDefinitions已经是一个顶级的BeanDefinitions,不需要做合并处理
				if (bd.getParentName() == null) {
					// Use copy of given root bean definition.
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					} else {
						mbd = new RootBeanDefinition(bd);  // 相当于属性复制,生成一个新的顶级BeanDefinition
					}
				} else {
					// Child bean definition: needs to be merged with parent.
					// 存在父级, 做父子BeanDefinition的合并处理
					// 合并后原本的父子BeanDefinition不会清除,而是会生成一个新的BeanDefinition,并存于合并缓存中
					BeanDefinition pbd;
					try {
						// 如果是工厂Bean,需要去除beanName的前缀 "&"
						String parentBeanName = transformedBeanName(bd.getParentName());
						if (!beanName.equals(parentBeanName)) {
							// 如果beanName与父级名称不一致,即可做合并BeanDefinition步骤
							pbd = getMergedBeanDefinition(parentBeanName);
						} else {
							BeanFactory parent = getParentBeanFactory();
							if (parent instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
							} else {
								throw new NoSuchBeanDefinitionException(parentBeanName,
										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
												"': cannot be resolved without a ConfigurableBeanFactory parent");
							}
						}
					} catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName, "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					// Deep copy with overridden values.
					mbd = new RootBeanDefinition(pbd);
					mbd.overrideFrom(bd);
				}

				// Set default singleton scope, if not configured before.
				// 如果没有定义@Scope注解, 则默认是单例Bean
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(SCOPE_SINGLETON);
				}

				// A bean contained in a non-singleton bean cannot be a singleton itself.
				// Let's correct this on the fly here, since this might be the result of
				// parent-child merging for the outer bean, in which case the original inner bean
				// definition will not have inherited the merged outer bean's singleton status.
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				// Cache the merged bean definition for the time being
				// (it might still get re-merged later on in order to pick up metadata changes)
				// 将合并后的BeanDefinitions放入缓存中
				if (containingBd == null && isCacheBeanmetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}
			return mbd;
		}
	}

扫描步骤完成, 接下来就是真正的创建Bean阶段了, 这也是Bean生命周期的核心阶段, 此步骤走完,Bean也是真正完整的创建好了;
看了其他大佬的文章认为此阶段是Bean生命周期的开始阶段, 我不这么认为。 Spring容器中的Bean并不是对象,而是一个个独立的BeanDefition, Bean的所有信息都包含在内, 既然容器中存放的是BeanDefition,那么扫描阶段生成的初始形态BeanDefition,虽然内部信息还不完整, 但是既以诞生, 就是生命周期的开始

核心源码如下: AbstractAutowireCapableBeanFactory.createBean()

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("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.
		// ★ 1.加载类(马上就要实例化Bean了,确保beanClass被加载了)
		Class resolvedClass = resolveBeanClass(mbd, beanName);
		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.
			// 通过BeanPostProcessors的处理逻辑,返回一个bean的代理对象,而不是bean的实例对象
			// ★ 2.实例化前
			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 {
			// ★ 3.创建Bean(实例化 -> 填充属性 -> 初始化bean)
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isDebugEnabled()) {
				logger.debug("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);
		}
	}

AbstractAutowireCapableBeanFactory.doCreateBean()

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

		// Instantiate the bean.
		// 1.实例化bean
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// 有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 实例化Bean
			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.
		// 2.实例化后
		// Spring扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(),允许后处理器修改合并的bean定义
		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.postProcessed = true;
			}
		}

		// 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.isDebugEnabled()) {
				logger.debug("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 {
			// 3.属性注入
			populateBean(beanName, mbd, instanceWrapper);
			// 4.初始化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);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set 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 " +
										"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
		    // 5.Bean销毁的逻辑
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		} catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}
		return exposedObject;
	}

第二阶段: 实例化

第二阶段的大致步骤如下:

    加载类实例化前实例化实例化后
1. 加载类

BeanDefinition合并之后,就可以去创建Bean对象了,而创建Bean就必须实例化对象,而实例化就必须先加载当前BeanDefinition所对应的class,在AbstractAutowireCapableBeanFactory类的createBean()方法中,一开始就会调用 :

AbstractBeanFactory.resolveBeanClass()

protected Class resolveBeanClass(RootBeanDefinition mbd, String beanName, Class... typesToMatch) throws CannotLoadBeanClassException {
		try {
			if (mbd.hasBeanClass()) {  
			    // 如果beanClass属性的类型是Class,那么就直接返回
				return mbd.getBeanClass();
			}
			if (System.getSecurityManager() != null) {
				return AccessController.doPrivileged((PrivilegedExceptionAction>)
						() -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
			} else {
			    // 如果不是,则会根据类名进行加载(doResolveBeanClass方法所做的事情)
				return doResolveBeanClass(mbd, typesToMatch);
			}
		} catch (PrivilegedActionException pae) {
			ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
		} catch (ClassNotFoundException ex) {
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
		} catch (linkageError err) {
			throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
		}
	}
2. 实例化前

涉及Spring的扩展点InstantiationAwareBeanPostProcessor,继承了BeanPostProcessor, 提供了两个方法postProcessBeforeInstantiation(), postProcessAfterInstantiation()和postProcessPropertyValues(); 可在实例化前后对Bean做自定义的扩展逻辑

AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation()

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.
			// 校验bean是否是合成的
			// 是否有实现BeanPostProcessors接口的实例类, 如果有先执行
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					// 实例化前 - InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
					// 当执行完postProcessBeforeInstantiation()的步骤后, 如果返回值不为空,表示利用Spring的扩展点完成了实例化的操作
					// 但是必须还需要执行postProcessAfterInitialization()步骤,因为AOP的就是在此步骤执行的
					// 创建完成的Bean其实是一个代理Bean对象
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						// 实例化后 - InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}
3. 实例化

在实例化之前, 判断如果是单例Bean,并且有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)

① 是否使用Supplier创建对象
② 如果没有设置Supplier,则检查BeanDefinition中是否设置了factoryMethod (最常见就是使用注解@Bean)
③ 在进行推断构造方法之前,先判断下是否有缓存的构造方法
④ 进行推断构造方法 (Spring提供扩展点,可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法)
⑤ 不匹配以上情况,则直接使用无参构造方法

AbstractAutowireCapableBeanFactory.doCreateBean()

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

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			// 有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 实例化Bean
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

        ........
        
		return exposedObject;
	}

AbstractAutowireCapableBeanFactory.createBeanInstance()

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// Make sure bean class is actually resolved at this point.
		// 确保beanClass被加载了
		Class beanClass = resolveBeanClass(mbd, beanName);

		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		// 1. BeanDefinition中添加了Supplier,则调用Supplier来得到对象
		Supplier instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		// 2.@Bean对应的BeanDefinition
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// Shortcut when re-creating the same bean...
        // 3. 构造方法推断
		// 一个原型BeanDefinition,会多次来创建Bean,那么就可以把该BeanDefinition所要使用的构造方法缓存起来,避免每次都进行构造方法推断
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					// autowireNecessary表示有没有必要进行注入,比如当前BeanDefinition用的是无参构造方法,那么autowireNecessary为false,否则为true,表示需要给构造方法参数注入值
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}

		if (resolved) {
			// 如果确定了当前BeanDefinition的构造方法,那么看是否需要进行对构造方法进行参数的依赖注入(构造方法注入)
			if (autowireNecessary) {
				// 方法内会拿到缓存好的构造方法的入参
				return autowireConstructor(beanName, mbd, null, null);
			} else {
				// 构造方法已经找到了,但是没有参数,那就表示是无参,直接进行实例化 -> 无参的构造函数
				return instantiateBean(beanName, mbd);
			}
		}

        // Candidate constructors for autowiring?
        
		// 如果没有找过构造方法,就需要开始找了(推断构造方法)
		// 提供一个扩展点,可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法
		// 比如AutowiredAnnotationBeanPostProcessor会把加了@Autowired注解的构造方法找出来,具体看代码实现会更复杂一点
		Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);   // ★ 核心源码

		// 如果推断出来了构造方法,则需要给构造方法赋值,也就是给构造方法参数赋值,也就是构造方法注入
		// 如果没有推断出来构造方法,但是autowiremode为AUTOWIRE_CONSTRUCTOR,则也可能需要给构造方法赋值,因为不确定是用无参的还是有参的构造方法
		// 如果通过BeanDefinition指定了构造方法参数值,那肯定就是要进行构造方法注入了
		// 如果调用getBean的时候传入了构造方法参数值,那肯定就是要进行构造方法注入了
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		// 5. 不匹配以上情况,则直接使用默认无参构造函数实例化给定bean
		return instantiateBean(beanName, mbd);  // ★ 核心源码
	}

推断构造方法: Spring的扩展点SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()
AbstractAutowireCapableBeanFactory.determineConstructorsFromBeanPostProcessors()

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;
	}

使用默认无参构造函数实例化给定bean
AbstractAutowireCapableBeanFactory.instantiateBean()

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged((PrivilegedAction) () -> getInstantiationStrategy().instantiate(mbd, beanName, this), getAccessControlContext());
			} else {
				// 默认是CglibSubclassingInstantiationStrategy
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);  // 实例化Bean -> BeanWrapper 
			return bw;
		} catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}
 
4. 实例化后 

Bean对象实例化出来之后,接下来就应该给对象的属性赋值了。在真正给属性赋值之前,Spring做了两件事

    提供一个扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(), 可以对此时的BeanDefinition进行加工如果此时的Bean是一个单例的Bean, 那么在属性注入之前, 先将其添加到相应的单例缓存中,以便后面解决循环引用的问题

AbstractAutowireCapableBeanFactory.doCreateBean()

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        ......
        
		// Allow post-processors to modify the merged bean definition.
		//★ 1.Spring扩展点MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(),可以对此时的BeanDefinition进行加工
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
				     // 扩展点 MergedBeanDefinitionPostProcessor
					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.
		// ★ 2.如果是单例Bean, 那么在属性注入前, 先缓存, 便于后面解决循环引用的问题
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		
         ......
		return exposedObject;
	}
第三阶段: 属性注入

第三阶段的大致步骤如下:

    Spring扩展点: InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(), 后置处理Spring的自动注入执行Spring扩展点InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法

AbstractAutowireCapableBeanFactory.populateBean()

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.

		// 1.实例化之后,属性设置之前
		// 执行Spring扩展点InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()方法
		// 可以实现对Bean的某些属性赋值,当返回false时, 说明属性值已经赋值完毕,直接返回
		// isSynthetic: 判断是否为合并之后的BeanDefition, 不是合并的BeanDefition,无法执行postProcessAfterInstantiation()方法
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}

		//2.Spring的自动注入
		//方式一: 配置文件中, 标签中设置autowire属性, 属性值有byName/byType
		//方式二: @Bean注解中设置autowire属性, Autowire.BY_NAME / Autowire.BY_TYPE
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		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;
		}

		//3. 执行Spring扩展点InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}
第四阶段: 初始化

第四阶段的大致步骤如下:

    初始化前
    执行Aware回调 (BeanNameAware,BeanClassLoaderAware,BeanFactoryAware)
    Spring扩展点BeanPostProcessor.postProcessBeforeInitialization()
    Spring扩展点InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization()初始化
    如果当前Bean对象实现了InitializingBean接口,当前Bean对象是否实现了InitializingBean接口
    没有实现,则执行BeanDefinition中指定的初始化方法初始化后
    Spring扩展点BeanPostProcessor.postProcessAfterInitialization()
    Spring扩展点InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()

AbstractAutowireCapableBeanFactory.initializeBean()

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		//Spring的安全框架, 源码中有很多, 不必理会
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		} else {
			//1.执行Aware回调 (BeanNameAware,BeanClassLoaderAware,BeanFactoryAware)
			invokeAwareMethods(beanName, bean);
		}

		//2. Spring扩展点BeanPostProcessor.postProcessBeforeInitialization()
		//在真正初始化的之前, 如果有自定义的初始化initMethord()方法, 就会在此步骤执行
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			//3.初始化 - 根据initMethods()
			invokeInitMethods(beanName, wrappedBean, mbd);
		} catch (Throwable ex) {
			throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex);
		}

		//4.Spring扩展点BeanPostProcessor.postProcessAfterInitialization()
		//aop 就是在此步骤执行的
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}
 
1. 初始化前 - 执行Aware回调 

AbstractAutowireCapableBeanFactory.invokeAwareMethods()

private void invokeAwareMethods(String beanName, Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}
2.初始化前 - Spring扩展点BeanPostProcessor.postProcessBeforeInitialization()

在真正初始化的之前, 如果有自定义的初始化initMethord()方法, 就会在此步骤执行

AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
3.初始化

AbstractAutowireCapableBeanFactory.invokeInitMethods()

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
		// 判断Bean是否实现了InitializingBean
		// 实现了,执行afterPropertiesSet()方法
		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (logger.isDebugEnabled()) {
				logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
			}
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				} catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			} else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}

		// 如果设置了InitMethod方法,执行此方法实现Bean的初始化
		// 没有设置,实行默认的
		if (mbd != null && bean.getClass() != NullBean.class) {
			String initMethodName = mbd.getInitMethodName();
			if (StringUtils.hasLength(initMethodName) &&
					!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
					!mbd.isExternallyManagedInitMethod(initMethodName)) {
				// 调用bean上自定义的initMethod()方法
				invokeCustomInitMethod(beanName, bean, mbd);
			}
		}
	}
 

AbstractAutowireCapableBeanFactory.invokeCustomInitMethod() : 执行初始化方法

protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd) throws Throwable {
		// 通过initMethodName名称获取初始化方法
		String initMethodName = mbd.getInitMethodName();
		Assert.state(initMethodName != null, "No init method set");
		Method initMethod = (mbd.isNonPublicAccessAllowed() ?
				BeanUtils.findMethod(bean.getClass(), initMethodName) :
				ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));

		if (initMethod == null) {
			if (mbd.isEnforceInitMethod()) { // 校验初始方法是否是默认的
				throw new BeanDefinitionValidationException("Could not find an init method named '" +
						initMethodName + "' on bean with name '" + beanName + "'");
			} else {
				if (logger.isDebugEnabled()) {
					logger.debug("No default init method named '" + initMethodName + "' found on bean with name '" + beanName + "'");
				}
				// Ignore non-existent default lifecycle methods.
				return;
			}
		}

		if (logger.isDebugEnabled()) {
			logger.debug("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
		}

		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction) () -> {
				ReflectionUtils.makeAccessible(initMethod);
				return null;
			});
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction)
						() -> initMethod.invoke(bean), getAccessControlContext());
			} catch (PrivilegedActionException pae) {
				InvocationTargetException ex = (InvocationTargetException) pae.getException();
				throw ex.getTargetException();
			}
		} else {
			try {
				ReflectionUtils.makeAccessible(initMethod);
				initMethod.invoke(bean);
			} catch (InvocationTargetException ex) {
				throw ex.getTargetException();
			}
		}
	}
 
4.初始化后 - Spring扩展点BeanPostProcessor.postProcessAfterInitialization() 

在这个步骤中,对Bean最终进行处理,Spring中的AOP就是基于初始化后实现的,初始化后返回的对象才是最终的Bean对象

AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization()

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
二: 举例验证
## 配置类
@ComponentScan({"com.maker", "com.factory"})
@Configuration
@Description("扫描配置类")
public class AppConfig {
}

## UserService 在 "com.maker" 扫描路径下
@Component
public class UserService implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean {

    public void run() {
        System.out.println("人在奔跑");
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("[初始化前 - (Spring扩展点)BeanClassLoaderAware.setBeanClassLoader()]");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("[初始化前 - (Spring扩展点)BeanFactoryAware.setBeanFactory()]");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("[初始化前 - (Spring扩展点)BeanNameAware.setBeanName()]");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("[初始化 - (Spring扩展点)InitializingBean.afterPropertiesSet()]");
    }
}

## 启动类
public class SpringTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        userService.run();
    }
}

BeanPostProcessor, 在"com.factory"扫描路径下

## InstantiationAwareBeanPostProcessor 实现类 
@Component 
public class MakerInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[实例化前 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()]");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[实例化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()]");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[属性注入 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessPropertyValues()]");
        }
        return null;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization()]");
        }
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()]");
        }
        return null;
    }

## MergedBeanDefinitionPostProcessor 实现类
@Component
public class MakerMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
        if ("userService".equals(beanName)) {
            System.out.println("[实例化 - (Spring扩展点)MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition");
        }
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

## SmartInstantiationAwareBeanPostProcessor 实现类
public class MakerSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    @Override
    public Class predictBeanType(Class beanClass, String beanName) throws BeansException {
        return null;
    }

    @Override
    public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[实例化-推断构造方法 - SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors()]");
        }
        return null;
    }

    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return null;
    }
}

## BeanPostProcessor实现类 - 普通
@Component
public class MakerBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (普通)]");
            return new UserService();
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (普通)]");
        }
        return bean;
    }
}

## BeanPostProcessor实现类 - PriorityOrdered
@Component
public class MakerBeanPostProcessor2 implements BeanPostProcessor, PriorityOrdered {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (PriorityOrdered)]");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (PriorityOrdered)]");
        }
        return bean;
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

## BeanPostProcessor实现类 - Ordered
public class MakerBeanPostProcessor3 implements BeanPostProcessor, Ordered {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (Ordered)]");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)) {
            System.out.println("[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (Ordered)]");
        }
        return bean;
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

执行结果:

[扫描-生成BeanDefinition] - userService
[赋初始值,解析注解,并注册] - userService
[合并BeanDefinition] - userService
[加载类] - userService
[实例化前 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()]
[实例化 - (Spring扩展点)MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition
[实例化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()]
[属性注入 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessPropertyValues()]
[初始化前 - Aware回调 - (Spring扩展点)BeanNameAware.setBeanName()]
[初始化前 - Aware回调 - (Spring扩展点)BeanClassLoaderAware.setBeanClassLoader()]
[初始化前 - Aware回调 - (Spring扩展点)BeanFactoryAware.setBeanFactory()]
[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (PriorityOrdered)]
[初始化前 - (Spring扩展点)BeanPostProcessor.postProcessBeforeInitialization-> (普通)]
[初始化前 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization()]
[初始化 - (Spring扩展点)InitializingBean.afterPropertiesSet()]
[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (PriorityOrdered)]
[初始化后 - (Spring扩展点)BeanPostProcessor.postProcessAfterInitialization-> (普通)]
[初始化后 - (Spring扩展点)InstantiationAwareBeanPostProcessor.postProcessAfterInitialization()]

人在奔跑
转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号