Spring IOC源码分析三：Spring refresh下-实例化bean

最新推荐文章于 2022-04-14 15:16:15 发布
最新推荐文章于 2022-04-14 15:16:15 发布
阅读量880 收藏 1
点赞数 4
分类专栏： Spring 文章标签： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_29899265/article/details/89023404
版权

文章目录

7.initMessageSource

在Spring容器中初始化一些国际化相关的属性。

8.initApplicationEventMulticaster

在Spring容器中初始化事件广播器，事件广播器用于事件的发布。

9.onRefresh

一个模板方法，不同的Spring容器做不同的事情。

比如web程序的容器AnnotationConfigEmbeddedWebApplicationContext中会调用createEmbeddedServletContainer方法去创建内置的Servlet容器，如启动tomcat。

10.registerListeners

把Spring容器内的时间监听器和BeanFactory中的时间监听器都添加的事件广播器中。

11.finishBeanFactoryInitialization

实例化BeanFactory中已经被注册但是未实例化的所有非懒加载实例
主流程

在这里插入图片描述
主流程大致为，从缓存中找到是否已经实例化了该 singleton bean，如果已经实例化好了，那么就直接返回；如果在缓存中没有找到，则将当前的 bean 封装为 RootBeanDefinition，然后通过调用 DefaultSingletonBeanRegistry#getSingleton 得到初始化好的 singleton bean，然后将其注册至缓存，然后再判断是普通 bean 还是 factory bean 作必要的处理后，最后返回。

AbstractBeanFactory#doGetBean

 Object sharedInstance = getSingleton(beanName);

先从缓存中查找是否以及实例化了该bean，如果已存在，直接返回。

if (!typeCheckOnly) {
    markBeanAsCreated(beanName);
}

将当前bean标记为已创建。

if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			//回调AbstractAutowireCapableBeanFactory 的 createBean
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			destroySingleton(beanName);
			throw ex;
		}
	});
	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

这里调用DefaultSingletonBeanRegistry#getSingleton：

beforeSingletonCreation(beanName);
singletonObject = singletonFactory.getObject();
afterSingletonCreation(beanName);
if (newSingleton) {
    addSingleton(beanName, singletonObject);
}

beforeSingletonCreation和afterSingletonCreation 检查了当前bean是不是在被排除的bean集合中以及是不是正在创建。

protected void beforeSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
		throw new BeanCurrentlyInCreationException(beanName);
	}
}

protected void afterSingletonCreation(String beanName) {
	if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
		throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
	}
}

而addSingleton是将实例化好的bean加入缓存
接下来重点关注singletonObject = singletonFactory.getObject()，这里回调了getObject方法，即AbstractAutowireCapableBeanFactory#createBean。通过此回调方法正式拉开了实例化 bean 的序幕。
AbstractAutowireCapableBeanFactory#createBean

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
	return bean;
}
Object beanInstance = doCreateBean(beanName, mbdToUse, args);

在进行真正的实例化之前，会先调用一部分已注册的beanPostProcessor的before,after方法。
AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation

Class<?> targetType = determineTargetType(beanName, mbd);
	if (targetType != null) {
		bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
		if (bean != null) {
			bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
		}
}

AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInstantiation

for (BeanPostProcessor bp : getBeanPostProcessors()) {
	if (bp instanceof InstantiationAwareBeanPostProcessor) {
		InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
		Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
		if (result != null) {
			return result;
		}
	}
}

可以看出，这里只处理实现了InstantiationAwareBeanPostProcessor的processor，如AbstractAutoProxyCreator,用来处理AOP。

从主流程可以看出主要做了三件事：一、create Bean Instance；二、populate bean；三、initialize bean。

实例化-createBeanInstance

createBeanInstance根据 bean 的不同配置方式，实现了三种实例化bean的方式，分别是 factory instantiate bean、autwire instantiate bean 以及 default instantiate bean。

AbstractAutowireCapableBeanFactory#createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    	...
        if (mbd.getFactoryMethodName() != null) {
            //使用factory method实例化bean
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
    	
    	...
        //如果已经解析过则使用解析好的构造函数方法不需要再次解析
		if (resolved) {
			if (autowireNecessary) {
				//constructor自动注入
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				//默认构造方法实例化
				return instantiateBean(beanName, mbd);
			}
		}
       
    	//未解析过，解析构造方法，返回数组。这里的数组包含显示声明的无参构造
    	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            //使用构造方法实例化
			return autowireConstructor(beanName, mbd, ctors, args);
		}
    	...
        // 没有特殊的处理,只需使用no-arg构造函数即编译器提供的无参构造
        return instantiateBean(beanName, mbd);
}
  1. 如果有factoryMethod，则使用factoryMethod实例化
  2. 如果没有factoryMethod但有显示声明的构造方法，则使用该构造方法实例化。
  3. 如果以上都没有，使用编译器生成的无参构造方法实例化。

分别看一下每个实例化过程

1.工厂方法实例化

使用factoryMethod比较简单，找到factory method，反射调用即可。

ConstructorResolver#instantiate

//AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod
protected BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
	return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

//#ConstructorResolver#instantiateUsingFactoryMethod
public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

	bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
}

//#instantiate
private Object instantiate(String beanName, RootBeanDefinition mbd,@Nullable Object factoryBean, Method factoryMethod, Object[] args) {
	...
	return this.beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
}

可以看出调用链很长，最后调用了一个Instantiation的策略来实例化。默认的实现是SimpleInstantiationStrategy。

SimpleInstantiationStrategy#instantiate

...
Object result = factoryMethod.invoke(factoryBean, args);
if (result == null) {
	result =
	 new NullBean();
}
...
return result;

通过反射调用factoryMethod实例化bean

2.声明的构造方法实例化

接上文的AbstractAutowireCapableBeanFactory#createBeanInstance方法。

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

这里会解析并返回显示声明的构造方法数组。解析过程会调用BeanPostProcessor#determineCandidateConstructors，这部分主要是由AutowiredAnnotationBeanPostProcessor来处理

AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors

由于代码太长，节选部分代码

//获取所有构造方法
Constructor<?>[] rawCandidates= beanClass.getDeclaredConstructors();

for (Constructor<?> candidate : rawCandidates) {
    //获取指定类中指定注解
    AnnotationAttributes ann = findAutowiredAnnotation(candidate);
    if (ann != null) {
        //如果在此构造方法之前已有requiredConstructor，则报错
        if (requiredConstructor != null) {
            throw new BeanCreationException(beanName,
                                            "Invalid autowire-marked constructor: " + candidate +
                                            ". Found constructor with 'required' Autowired annotation already: " +
                                            requiredConstructor);
        }
        //获取注解中required属性值
        boolean required = determineRequiredStatus(ann);
        if (required) {
            //如果候选构造方法集合不为空
            if (!candidates.isEmpty()) {
                throw new BeanCreationException;
            }
            //当前的构造方法就是required属性所配置的构造方法
            requiredConstructor = candidate;
        }
        //将当前的构造方法添加到候选构造方法集合中
        candidates.add(candidate);
    }
    //如果类中没有指定注解，并且构造方法参数列表为空
    else if (candidate.getParameterCount() == 0) {
        //当前的构造方法是默认构造方法
        defaultConstructor = candidate;
    }
    
    //如果候选构造方法集合不为空
    if (!candidates.isEmpty()) {
        // Add default constructor to list of optional constructors, as fallback.
        if (requiredConstructor == null) {
            //如果所有的构造方法都没有配置required属性，且有默认构造方法
            if (defaultConstructor != null) {
                //将默认构造方法添加到候选构造方法列表
                candidates.add(defaultConstructor);
            }
            //...
           
        }
        //将候选构造方法集合转换为数组
        candidateConstructors = candidates.toArray(new Constructor<?>[0]);
    }
    //如果候选构造方法只有1个且有参数
    else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
        //则当前构造方法就是候选类的构造方法
        candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
    }
    //...
   else {
       //其他情况下返回一个空的数组，比如有多个构造方法的情况下
       candidateConstructors = new Constructor<?>[0];
   }
    //将类的候选构造方法集合存放到容器的缓存中
    this.candidateConstructorsCache.put(beanClass, candidateConstructors);
    //返回指定类的候选构造方法数组，如果没有返回null
    return (candidateConstructors.length > 0 ? candidateConstructors : null);
}
  1. 首先获取所有显示声明的构造方法，循环遍历
  2. 获取每个构造方法的指定注解。
private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
    if (ao.getAnnotations().length > 0) {  // autowiring annotations have to be local
        //遍历所有autowire相关的注解:@Autowire、@Value以及JSR-330等
        for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
            //获取给定对象上的指定类型的注解
            AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
            if (attributes != null) {
                return attributes;
            }
        }
    }
    return null;
}
  1. 如果存在指定注解，并且构造方法上有@Required注解并为true，则当前构造方法为Required构造方法，加入候选构造方法的集合中。
  2. 如果类中没有autowire的相关注解，并且构造方法参数列表为空，则当前构造方法为默认构造方法，同时加入候选构造方法的集合中。
  3. 如果在所有构造方法中有且只有一个构造方法，并且有参数，则返回这个构造方法，这一条就是当类中声明了一个field，并且在构造方法里存在，即使没有@Autowired注解也会自动注入的原因。比如：
public class A{
    private final B b;
    
     public A(B b){
        this.b=b;
    }
}
  1. 返回找到的构造方法。如果构造方法有多个且未标识特殊注解，则返回null，使用空参构造实例化，实例化时会先获取默认构造方法，此时会创建失败，错误信息为No default constructor found。

如果解析出的构造方法不为空，则使用返回的构造方法实例化。

protected BeanWrapper autowireConstructor(
    String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {

    return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

ConstructorResolver#autowireConstructor

public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
                                       @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
    //节选部分
    //这里省略了从缓存中获取，以及将构造方法list按参数个数排序
    for (Constructor<?> candidate : candidates) {
        if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
            //如果已找到选用的构造函数或者需要的参数个数小于当前构造函数的参数个数则终止，因为已经按照参数个数降序排列
            break;
        }
        ConstructorArgumentValues resolvedValues = new ConstructorArgumentValues();
		if (resolvedValues != null) {
          
            //...
            //在给定已解析的构造函数参数值的情况下，创建一个参数数组以调用构造函数或工厂方法。调用getBean获取参数
            argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, 		   		paramTypes,paramNames,getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
        }
        if (typeDiffWeight < minTypeDiffWeight) {
            constructorToUse = candidate;
            argsHolderToUse = argsHolder;
            argsToUse = argsHolder.arguments;
            minTypeDiffWeight = typeDiffWeight;
            ambiguousConstructors = null;
        }
        
        bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
    }
    
}

需要注意的一点是createArgumentArray(),这个方法会调用resolveAutowiredArgument(),之后会调用beanFactory.resolveDependency()去解析依赖关系，然后调用getBean来获取实例。详见 @Autowired详解的解析依赖关系

这里的实例化也由SimpleInstantiationStrategy完成的。

SimpleInstantiationStrategy#instantiate

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,final Constructor<?> ctor, Object... args) {
	return BeanUtils.instantiateClass(ctor, args);
}
//instantiateClass
ctor.newInstance(args);
//newInstance
T inst = (T) ca.newInstance(initargs);

也是通过使用其构造函数 constructor 使用Java 反射实例化了 bean。

3.默认的构造方法实例化

AbstractAutowireCapableBeanFactory#instantiateBean

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

SimpleInstantiationStrategy#instantiate

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    // Don't override the class with CGLIB if no overrides.
    if (!bd.hasMethodOverrides()) {
        Constructor<?> constructorToUse= clazz.getDeclaredConstructor();
        }
        return BeanUtils.instantiateClass(constructorToUse);
    }
    else {
        // Must generate CGLIB subclass.
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
}

//instantiateClass
ctor.newInstance(args);
//newInstance
T inst = (T) ca.newInstance(initargs);

通过使用编译器生成的默认无参 constructor通过Java 反射实例化了 bean

初始化1-populate bean

这部分的初始化主要是处理依赖关系，如@Autowired、@Value、@Inject注解的属性和方法

AbstractAutowireCapableBeanFactory#populateBean

pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
pvs = pvsToUse;

进行依赖注入的过程，先处理autowire的注入，可以根据Bean的名字或类型来完成Bean的autowire

if (pvs != null) {
	//对属性进行注入 如@Autowired属性
	applyPropertyValues(beanName, mbd, bw, pvs);
}

然后对属性进行注入。详见 @Autowired详解

初始化2-initialize bean

这部分主要是初始化bean的自身属性，如注入Aware对象，执行afterPropertiesSet方法等。

AbstractAutowireCapableBeanFactory#initializeBean

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	invokeAwareMethods(beanName, bean); ①
	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		//执行bean-post-processor 的beforeInitialization方法
		wrappedBean = applyBeanPostProcessorsBeforeInitialization (wrappedBean, beanName);②
	}

	try {
		//处理实现了InitializingBean接口的beans的回调方法
		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()) {
		//执行bean-post-processor 的afterInitialization方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);④
	}

	return wrappedBean;
}

整个流程可以理解为三大块

  1. 注入 Aware 对象，见①；
  2. 调用 bean-post-processors 接口方法，见②和④；
  3. 调用 InitializingBean 方法，见③。
注入 Aware 对象

AbstractAutowireCapableBeanFactory#invokeAwareMethods

private void invokeAwareMethods(final String beanName, final 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);
			}
		}
		//将当前的beanFactory注入，这也就是为什么如果实现了BeanFactoryAware接口，会自动获取到但钱的BeanFactory实例
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

可以看到，注入了三种情况

  • 如果当前 bean 实现了 BeanNameAware 接口，只是调用了 setBeanName，比如logging
  • 如果当前 bean 实现了 BeanClassLoaderAware 接口，将 Spring 容器的 BeanClassLoader 注入到当前 bean
  • 如果当前 bean 实现了 BeanFactoryAware 接口，将 Spring 容器中与 bean 初始化相关的 BeanFactory 实例注册给当前的 bean。
调用 bean-post-processors 接口方法
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;
}

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

可以看出如果某个 beanProcessor 处理返回一个 null 则直接返回，并且终止其余的 bean-post-processors。要注意的是，该回调方法是针对对容器中所有的普通 bean 进行的回调。并且该方法是在回调 InitializeBean 接口方法之前调用，并且是在 populate bean之后进行的调用，通常是对原有 bean 做一层封装，然后返回该封装对象。这点BeanPostProcessor接口注释也已经说明。

public interface BeanPostProcessor {

    /**
     * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
     * or a custom init-method). The bean will already be populated with property values.
     * The returned bean instance may be a wrapper around the original.
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one;
     * if {@code null}, no subsequent BeanPostProcessors will be invoked
     * @throws org.springframework.beans.BeansException in case of errors
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
     */
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    /**
     * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean
     * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
     * or a custom init-method). The bean will already be populated with property values.
     * The returned bean instance may be a wrapper around the original.
     * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean
     * instance and the objects created by the FactoryBean (as of Spring 2.0). The
     * post-processor can decide whether to apply to either the FactoryBean or created
     * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
     * <p>This callback will also be invoked after a short-circuiting triggered by a
     * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
     * in contrast to all other BeanPostProcessor callbacks.
     * @param bean the new bean instance
     * @param beanName the name of the bean
     * @return the bean instance to use, either the original or a wrapped one;
     * if {@code null}, no subsequent BeanPostProcessors will be invoked
     * @throws org.springframework.beans.BeansException in case of errors
     * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
     * @see org.springframework.beans.factory.FactoryBean
     */
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}
调用 InitializingBean 方法
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
        throws Throwable {

    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isDebugEnabled()) {
            logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
        .....
        ((InitializingBean) bean).afterPropertiesSet();
        .....
    }

    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

可以看到，主要回调的是InitializingBean接口的afterPropertiesSet方法，所以，我们可以让某个 bean 实现 InitializingBean 接口，并通过该接口实现一些当 bean 实例化好以后的回调方法，注意afterPropertiesSet并不返回任何值，所以，这里不是像 bean-post-processor 那样对 bean 起到修饰的作用，而是起到纯粹的调用作用

12.finishRefresh

refresh做完之后需要做的其他事情。

  1. 清除上下文级资源缓存（例如来自扫描的ASM元数据）。
  2. 初始化生命周期处理器，并设置到Spring容器中(LifecycleProcessor)
  3. 调用生命周期处理器的onRefresh方法，这个方法会找出Spring容器中实现了SmartLifecycle接口的类并进行start方法的调用
  4. 发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
  5. 发布EmbeddedServletContainerInitializedEvent事件告知对应的ApplicationListener进行响应的操作
  6. 调用LiveBeansView的registerApplicationContext方法：如果设置了JMX相关的属性，则就调用该方法

扩展

到这里Spring 容器的bean初始化就全部完成了，最后补充一个扩展，那就是ApplicationContext是在什么时候注入的，从上述文章不难看出，invokeAwareMethods并没有对ApplicationContext注入，经过测试发现，如果实现了ApplicationContextAware，则将会在调用 bean-post-processors 接口方法这一步的postProcessBeforeInitialization中的invokeAwareInterfaces方法进行注入
ApplicationContextAwareProcessor

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;
		
		....

		invokeAwareInterfaces(bean);

		....

		return bean;
}

private void invokeAwareInterfaces(Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof EnvironmentAware) {
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}
}


public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
}

以上。

Jagger-Wang
关注
专栏目录
深入解析Spring IoC源码：核心机制与实践应用
12-13
2. **实例化Bean工厂**：`AnnotationConfigApplicationContext`的构造函数中，会初始化一个`DefaultListableBeanFactory`，这是Spring中处理Bean的核心组件。`DefaultListableBeanFactory`负责管理Bean的定义、创建...
2、spring源码解析之单例bean的实例化
qq_39504520的博客
05-12 804
文章目录前言1.refresh之实例化单实例bean2.解决循环依赖3.依赖注入之setter注入 前言 上文讲到了整体流程、以及配置类的BeanDefinition注册到ioc容器中。 ​ 其实bean的实例化是一件非常复杂的事情，因为不同的bean实例化的方式都是有一些差别的。而且bean在实例化过后会经历很多后置的处理(BeanPostProcess)，所以本文我会核心讲如何实例化我们的单例bean。 ​ 本文暂时不会涉及到很多有关于后置处理器的核心点（后续可能会讲到），本文暂时着重bean是如何实.
【spring-bean的解析和refresh方法】
qq_33700648的博客
04-14 1103
spring-bean的解析 refresh
做一个合格的程序猿之浅析Spring IoC源码（十一）Spring refresh()方法解析后记1
BazingaLyncc
03-14 2514
上次分析refresh这块spring IoC的时候，时间比较仓促，只是debug了部分源码，大家分析起来不是很好~ 今天我们还是先总结一下吧~ spring在实例化bean的时候，根据bean实现的接口不同，bean的实例化也是有先后顺序的 由于此块代码太多，贴图给大家的学习的效果不好，现在以spring 3.2.5源代码为例，大家再一份“温故”一下，然后“知新”
Spring IOC核心源码解析--refresh方法源码解析
06-03 353
本文基于spring 5.2.23.RELEASE版本分析，jar包spring-context:5.1.13.RELEASE.jar Spring 的核心方法refresh()方法位于AbstractApplicationContext.java类中. refresh()方法说明 加载和刷新配置的表示形式，这些配置是配置在xml文件、属性文件或者是跟数据库模式相关联的配置信息。 这是一个启动方法，如果启动失败，它将销毁已经创建的单例对象，避免资源浪费。 换句话说，在调用该方法后，应该实例化所有的单例或者不
Spring源码解析之IOC（二）refresh方法
weixin_41645232的博客
02-05 322
1、prepareRefresh(); 上下文refresh之前准备操作 1）设置当前系统时间 2）设置上下文关闭 / 活跃 标志 3）获取Envirenment（没有就创建StandartEnvirenment），验证所有按要求标记的属性是否可解析 4）创建用于存储refresh之前ApplicationListener和ApplicationEvent的容器 2、obtainFreshBeanFactory() 获取beanFactory AbstractApplicationConte
深入解析Spring IoC：源码与实践指南
最新发布
12-13
在实例化`AnnotatedBeanDefinitionReader`后，通常会使用`ClassPathBeanDefinitionScanner`扫描指定包下标记了特定注解（如`@Component`）的类，将其注册为BeanDefinition。 在注册配置类为BeanDefinition后，调用`...
SpringIOC refresh()初始化代码实例
08-24
SpringIOC refresh()初始化代码实例的主要作用是实例化所有不需要延迟初始化的单例bean，这些bean是在应用程序启动时需要初始化的。在 Spring 框架中，bean 的实例化是通过 BeanFactory 来完成的，而 refresh() 方法...
这一次搞懂Spring的Bean实例化原理操作
09-07
在Spring中，Bean的实例化是整个IoC（Inversion of Control）容器的核心过程，它涉及到BeanDefinition对象的使用，以及一系列后处理器的调用，包括BeanDefinitionRegistryPostProcessor、BeanFactoryPostProcessor、...
Spring IOC 源码解析
扛麻袋的少年的博客
03-09 2925
Spring5源码分析(二)：        既然本文我们来分析 Spring IOC 源码，那么我们就先来讨论以下几个问题：①什么是 IOC？  ② IOC 能帮我们做哪些事情？ 1.什么是 IOC         控制反转（Inversion o...
JVM类 和 spring Bean 的实例化 和 初始化区别以及顺序
秋楓的博客
09-22 6512
JVM spring
SpringBoot bean解析之refresh方法（四）
lhf2112的博客
02-25 408
上一篇文章讲述AbstractApplicationContext类的invokeBeanFactoryPostProcessors方法，主要完成通过BeanDefinitionRegistryPostProcessor向容器内添加bean定义，以及调用BeanFactoryPostProcessor向容器内的bean添加属性。接下来，我们来看registerBeanPostProcessors(...
Spring解析，加载及实例化Bean的顺序
qq_27863515的博客
01-31 2751
在使用Spring时，Bean之间会有些依赖， 比如一个BeanA实例化时需要用到BeanB,那么B应该在A之前实例化好。很多时候Spring智能地为我们做好了这些工作，但某些情况下可能不是，比如Springboot的@AutoConfigureAfter注解，手动的指定Bean的实例化顺序，了解Spring内Bean的解析，加载和实例化顺序机制有助于我们更好的使用Spring/Springboot，避免手动的去干预Bean的加载过程，搭建更优雅的框架。 Spring容器在实例化时会加载容器内所有非延迟加载
SpringBoot成长记10：Bean实例化的流程和设计
繁茂的博客
09-28 327
之前我们已经分析SpringBoot在run方法时，它会执行的refresh()容器的操作。 在SpringBoot中，refresh()有十几个方法，每个方法的大重要程度是不一样的，我们通过抓大放小的方式，分析处理上图3个核心逻辑。 并且已经研究完了invokeBeanFactoryPostProcessors和onRefresh的逻辑，分析它们的原理和设计思想。 之前主要分析的： 原理有对SpringBoot的自动装配配置如何做到的、第三方技术如何进行扩展的、tomcat如何启动的 设计思想有Spr.
Spring源码解析之零 ------ 容器初始化过程(refresh()方法)概要
怪盗基德
07-03 5414
本篇主要讲解，容器初始化时候的refresh()方法里的，几个重要方法的基本作用。 首先来看一下refresh()方法。spring容器的启动，创建bean，bean的初始化等一系列过程都在这个refresh方法里面，进行调用。 public void refresh() throws BeansException, IllegalStateException { synchro
spring 源码解读Spring IOC原理
Code-lover's Learning Notes
11-30 3315
Spring IOC设计原理解析:本文乃学习整理参考而来 一、 什么是Ioc/DI？ 二、 Spring IOC体系结构 (1) BeanFactory (2) BeanDefinition 三、 IoC容器的初始化 1、 XmlBeanFactory(屌丝IOC)的整个流程 2、 FileSystemXmlApplicatio
做一个合格的程序猿之浅析Spring IoC源码（十一）Spring refresh()方法解析之一
BazingaLyncc
03-12 6324
经过上面几节的简单介绍我们了解了spring的一些组件，现在我们来分析一下AbstractApplicationContext中的refresh()这个核心方法吧~ 用我们上一节的代码，debug进入refresh方法：public void refresh() throws BeansException, IllegalStateException { synchronized (
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值