Spring Bean的创建过程及相关扩展点
站长
· 阅读数 81
首先，我们最基本的常识是从ApplicationContext入手，从AbstractApplicationContext的refresh()作为入口，找到finishBeanFactoryInitialization()方法，这个方法的作用是实例化非懒加载的Bean实例。那么我们就可以进入AbstractBeanFactory的getBean()方法。
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
下面来看看doGetBean()方法：
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 转换一下，比如有别名、&开头的名字等这些请求，全部都转换成统一的beanName
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 从缓存中去。先从一级缓存中取，不行再从二级缓存取、最后从三级缓存取
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 扩展点---------扩展点-----------扩展点-------------
// 判断name是不是&开头的，如果是&开头的话，并且sharedInstance是FactoryBean类型，就直接返回
// 如果不是&开头，也不是FactoryBean类型，直接返回
// 如果不是&开头，是FactoryBean类型，调用getObject()方法返回Bean对象
// 也就是说，我们可以通过实现FactoryBean来创建Bean对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 下面是从父容器中找对应的Bean实例
// 注意：容器是存在父子关系的。spring mvc就是一个父子关系的容器
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
// 下面准备查找当前Bean对象依赖的其他Bean。比如在创建当前这个Bean之前必须要创建另外一个Bean
try {
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 找到所有在这个Bean创建之前一定要创建出来的依赖，依次调用getBean()创建
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
// ******这是重点******这是重点******这是重点******这是重点******
// 这里理解起来有点绕。注意这个getSingleton(String beanName,ObjectFactory<?> singletonFactory)方法。
// 第二个参数使用lamble表达式，可以先忽略
// getSingleton()里面就做了两件事情：
// 1.通过lamble表达式创建Bean对象
// 2.把创建好的Bean对象放到一级缓存中
// 最后返回创建好的Bean对象
sharedInstance = getSingleton(beanName, () -> {
try {
// 一定要先理清楚getSingleton()方法，再来看createBean()方法
// ******这是重点******这是重点******这是重点******这是重点*****
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 没创建成功就要销毁。不是重点
destroySingleton(beanName);
throw ex;
}
});
// 同样的，检查一下是不是FactoryBean，并且name是否以&开头
// 扩展点---------扩展点-----------扩展点-------------
// 判断name是不是&开头的，如果是&开头的话，并且sharedInstance是FactoryBean类型，就直接返回
// 如果不是&开头，也不是FactoryBean类型，直接返回
// 如果不是&开头，是FactoryBean类型，调用getObject()方法返回Bean对象
// 也就是说，我们可以通过实现FactoryBean来创建Bean对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 其实到这里就可以不用看非单例的情况了，因为基本都差不多。重点关注如何创建Bean对象。
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
// 还是创建Bean对象，这是重点
// ******这是重点******这是重点******这是重点******这是重点*****
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 同上，检查是否是FactoryBean
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
// 这里也一样，其他scope，重点还是在createBean()
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
// 重点都在这里
// ******这是重点******这是重点******这是重点******这是重点*****
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
//下面都不是重点，可忽略
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
下面简单分析一下getSingleton():
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
// 先从一级缓存中取，先试试
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 这不用看，就是做一个数据校验
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// ******这是重点******这是重点******这是重点******这是重点*****
// 这里就是调用lamble表示式里面的逻辑了，千万要理清楚
// lamble表达式里面就是做了createBean()的逻辑
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
// 处理创建Bean对象出异常的情况，不用管
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 最后就是把创建好的Bean对象放到一级缓存中。因为这个Bean对象已经是可以安全发布的了。
addSingleton(beanName, singletonObject);
}
}
// 返回创建好的Bean对象
return singletonObject;
}
}
核心重点createBean()方法：
@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);
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 {
// ********重点1，这是一个扩展点，此时还没有任何Bean实例被创建出来
// ********这里就是把Bean的创建机会开放给开发者
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对象，那么就spring自己来亲自处理
// 重点2，这是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);
}
}
扩展点1：开发者自己创建Bean
@Nullable
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的入口
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 如果真的把Bean实例创建出来了，那么再继续后续的生命周期的逻辑调用
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 一定要是InstantiationAwareBeanPostProcessor的实现类，才会在Bean没有实例化的时候被调用
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 这里面可以对已经创建出来的Bean实例增强
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
1.实现了InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation()方法，就有机会自己创建Bean对象
2.实现了BeanPostProcessor接口的postProcessAfterInitialization()方法就能在Bean对象创建出来后，还有机会对创建出来的Bean对象进行增强或者扩展。注意：可以在这个点做AOP增强。
创建Bean实例
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
// 如果是单例
if (mbd.isSingleton()) {
// 清除缓存
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建Bean实例，这个instanceWrapper是已经被包装的对象了
// 多种创建Bean的方法，了解后可以更灵活地创建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.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 扩展点
// 解析@Autowired，@Value，@Inject注解，把对应的字段和方法解析好设置进BeanDefinition
// 入口在AutowiredAnnotationBeanPostProcessor类中，可查看构造函数
// *****这是重点***********这是重点***********这是重点******
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");
}
// AOP入口，方便增强Bean。此时的Bean还没有设置属性，正好可以在其他Bean依赖它的时候通过getBean方法从第三级缓存中取出来；在这个过程中可以对Bean进行增强。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 设置属性值，通过属性名和字段类型，从IOC容器中getBean取值
populateBean(beanName, mbd, instanceWrapper);
// 调用初始化方法；先处理Aware结尾的接口，比如BeanNameAware，BeanClassLoaderAware，BeanFactoryAware接口；
// 先调用postProcessBeforeInitialization
// 执行初始化方法；InitializingBean接口的afterPropertiesSet方法；还有自定义的初始化方法，比如@PostConstruct注解的方法，init-method配置的方法名
// 再调用postProcessAfterInitialization
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<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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
// 注册销毁方法；比如@PreDestroy注解的方法，或者实现了DisposableBean接口的实现，还有就是配置的destroy-method方法
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// 返回Bean实例
return exposedObject;
}
创建Bean实例createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 通过BeanDefinition和beanName获取Class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 如果这个类的修饰符不是pubic，那么直接抛异常
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());
}
// 检查有没有指定的创造Bean实例的方法
// beanDefinition.setInstanceSupplier(SupplierBean::createUser);
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 检查是否有工厂方法。包括静态工厂、实例工厂、@Bean这种方式也会被转换成工厂方法
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 构造器实例化
// 快速实例化对象，所谓的快速实例化对象，其实就是使用了缓存
boolean resolved = false;
boolean autowireNecessary = false;
// 外部化参数，只能当无外部参数时才使用缓存。不推荐使用外部化参数
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
// 是否使用缓存，其中autowireNecessary表示是否使用有参构造器
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 使用缓存，其中autowireNecessary表示是否使用有参构造器
if (resolved) {
if (autowireNecessary) {
// 这个情况就是使用了已经解析好的BeanDefinition，直接从BeanDefinition中获取构造函数和参数
// 比如Property模式的时候，就会调用这个逻辑创建Bean
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 反射创建对象实例
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// @Autowire注解的构造函数，多个构造函数
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
// @Autowire注解的构造函数，默认的构造函数
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
// 反射创建对象实例
return instantiateBean(beanName, mbd);
}
总结一下就是：
1.先看看有没有指定的工厂方法创建对象；比如Supplier，factory-method
2.其次匹配构造函数；这都是自定匹配的
3.最终就是反射无参构造函数创建对象
// 这个扩展点其实是用来增强BeanDefinition。比如AutowiredAnnotationBeanPostProcessor就是用来解析@Autowired注解的，方便后面给对象属性赋值
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
// MergedBeanDefinitionPostProcessor子类可实现BeanDefinition的扩展
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
设置Bean对象属性值
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.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
// ********扩展点**********扩展点**********扩展点**********扩展点**
// 一看这就是扩展点，一旦postProcessAfterInstantiation返回false，那么直接就跳出不会继续执行设置相关属性值了
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
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) {
// 根据name查找属性值，其实里面也是通过getBean()获取属性值
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// 根据类型查找，其实里面也是通过getBean()获取属性值
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();
}
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
// ******又是扩展点******又是扩展点******又是扩展点******又是扩展点****
// 通过postProcessProperties可以拦截具体的属性并赋值
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// ******又是扩展点******又是扩展点******又是扩展点******又是扩展点****
// 如果没有在postProcessProperties进行扩展，可以在postProcessPropertyValues上扩展
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
// 赋值，不用管
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
初始化Bean实例：
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 调用Aware相关接口；扩展点，可以用开获取Bean名称、类加载器、容器实例
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 前置处理；扩展点，可以用来织入功能实现AOP
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 初始化；用来调用InitializingBean接口、@PostConstruct注解方法、init-method方法
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()) {
// 后置处理；扩展点，可以用来织入功能实现AOP
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
// 处理BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口
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);
}
}
}
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// AOP入口
// *****扩展点*********扩展点*********扩展点*********扩展点*********扩展点****
// 实现BeanPostProcessor接口postProcessBeforeInitialization()方法，可对初始化前的Bean实例进行拦截
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
//*****扩展点*********扩展点*********扩展点*********扩展点*********扩展点****
// 初始化Bean的三种方式：
// 1.实现InitializingBean接口afterPropertiesSet()
// 2.@PostConstruct注解
// 3.xml配置init-method属性
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// 调用InitializingBean接口afterPropertiesSet()初始化
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 {
((InitializingBean) bean).afterPropertiesSet();
}
}
// 调用init-method指定的方法；就是反射执行
// @PostConstruct注解在上面applyMergedBeanDefinitionPostProcessors()扩展BeanDefinition的时候被解析后设置到BeanDefinition中去了，可查看InitDestroyAnnotationBeanPostProcessor
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// AOP入口
// *****扩展点*********扩展点*********扩展点*********扩展点*********扩展点****
// 实现BeanPostProcessor接口postProcessAfterInitialization()方法，可对初始化前的Bean实例进行拦截
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
注册销毁方法
// *****扩展点*********扩展点*********扩展点*********扩展点*********扩展点****
// 销毁方法有三种：
// 1.实现DisposableBean接口的destroy()方法
// 2.@PreDestroy注解
// 3.xml配置destroy-method
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
if (mbd.isSingleton()) {
// Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
// 注册实现了DisposableBean接口
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
else {
// 针对destroy-method配置；其实@PreDestroy注解会在applyMergedBeanDefinitionPostProcessors()扩展BeanDefinition的时候被解析后设置到BeanDefinition中去了，可查看InitDestroyAnnotationBeanPostProcessor
// A bean with a custom scope...
Scope scope = this.scopes.get(mbd.getScope());
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
}
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}
总结一下：getBean()
-
doGetBean()
1.先从缓存中获取
-
getSingleton()：看看缓存中是否有Bean对象；逐步从一级缓存、二级缓存、三级缓存中取；这个要和Bean实例化后addSingleton()结合起来看；这个getSingleton()是可以从三级缓存中创建代理对象的。
-
getObjectForBeanInstance()：如果是以“&”开头的beanName，那么就返回FactoryBean对象；否则，如果这个Bean对象不是FactoryBean的话，就直接返回；如果是FactoryBean，那么就调用FactoryBean的getObject()返回目标对象。
2.从父容器中获取
-
如果上面的getSingleton()获取不到Bean对象，那么就要从父容器中getBean()
3.创建DependsOn对象
-
如果没有父容器或者父容器也拿不到Bean对象，那么就先计算该目标对象的DependsOn，也就是依赖，看看有哪些Bean是需要在这个对象创建之前要创建的。也是通过getBean()触发创建逻辑。
4.创建Bean对象
-
最后就是getSingleton()逻辑中执行创建Bean的逻辑；里面会有一个ObjectFactory，里面最终调用的是createBean方法创建Bean。创建好的Bean最终被添加到一级缓存中。
4.1：前置InstantiationAwareBeanPostProcessor
- resolveBeforeInstantiation()：在Bean实例化之前，给出扩展点让开发者自己有机会创建Bean实例。可用于AOP切入创建代理对象。
4.2：真正的创建Bean实例
-
doCreateBean()：这里面完成了Bean的创建、BeanDefinition的扩展、AOP的切入、属性值的设置、初始化的执行、销毁方法的注册
4.2.1：创建Bean实例
-
createBeanInstance()：分别通过工厂方法、有参构造、无参构造、反射等方法创建Bean实例
-
obtainFromSupplier()：工厂方法
-
instantiateUsingFactoryMethod()：工厂方法，factory-method配置。静态工厂、实例工厂。
-
autowireConstructor()：有参构造、无参构造
-
instantiateBean()：默认反射
4.2.2：BeanDefinition的扩展
- applyMergedBeanDefinitionPostProcessors()：MergedBeanDefinitionPostProcessor实现类可以重新设置BeanDefinition。这里最直接的应用就是针对@Autowired、@Value、@Inject注解
4.2.3：AOP的切入
- addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))：这个就是把刚刚创建出来、还没有对属性赋值的Bean实例放到三级缓存中，给它指定SmartInstantiationAwareBeanPostProcessor子类增强。也就是说，在这个阶段实现SmartInstantiationAwareBeanPostProcessor，就可以针对目标Bean创建Proxy代理。
4.2.4：属性值的设置
- populateBean()：设置属性值。这里面同样也会去IOC容器中找属性对应的Bean实例。在这里的话，也有一个扩展点，就是InstantiationAwareBeanPostProcessor子类可以自定义是否交由spring设置属性值、修改指定的属性值。
4.2.5：初始化的执行
- initializeBean()：这里面就是开始准备初始化的生命周期了。执行Aware接口逻辑、BeforeInitialization、执行初始化方法、AfterInitialization等逻辑的执行。
- invokeAwareMethods()：分别调用BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
- applyBeanPostProcessorsBeforeInitialization()：调用BeanPostProcessor的postProcessBeforeInitialization方法；AOP的织入点
- invokeInitMethods()：调用InitializingBean.afterPropertiesSet()，@PostConstruct注解方法，Init-method配置的目标方法
- applyBeanPostProcessorsAfterInitialization()：调用BeanPostProcessor的postProcessAfetrInitialization方法；AOP的织入点
4.2.6：销毁方法的注册
- registerDisposableBeanIfNecessary()：调用DisposableBean的实现类，@PreDestory注解的方法，destory-method配置的目标方法
-
-
getObjectForBeanInstance()：如果是以“&”开头的beanName，那么就返回FactoryBean对象；否则，如果这个Bean对象不是FactoryBean的话，就直接返回；如果是FactoryBean，那么就调用FactoryBean的getObject()返回目标对象。
-
转载自:https://juejin.cn/post/7111292849835999262