spring容器bean加载过程解析
入口:AbstractBeanFactory的getBean方法:public Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false);}doGetBean方法会返回指定bean的实例protected Object getSingleton...
入口:AbstractBeanFactory的getBean方法:
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
doGetBean方法会返回指定bean的实例
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
singletonObjects和singletonsCurrentlyInCreation分别保存单例bean和正在创建中的单例bean的map,通过其保证要创建的bean不存在也不在创建过程中。
如果bean不存在,则先标识该bean在创建中了markBeanAsCreated
根据bean名称和bean定义,获取RootBeanDefinition
查询depensOn的bean,并获取它们(如果没创建,则走同样的创建bean流程)
下面就开始创建需要的bean:
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>()
首先通过各种措施,保障只有当前线程执行bean创建,然后调用getObject()方法:
而getObject方法,最终调用了AbstractAutowireCapableBeanFactory的createBean方法:
首先,解析bean定义:
resolveBeanClass
获取类加载器
ClassLoader beanClassLoader = getBeanClassLoader();
获取类名字对应的表达式
然后对类加载器和类名字进行校验,校验通过,执行mbd.resolveBeanClass(beanClassLoader)
public Class<?> resolveBeanClass(ClassLoader classLoader) throws ClassNotFoundException {
String className = getBeanClassName();
if (className == null) {
return null;
}
Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
this.beanClass = resolvedClass;
return resolvedClass;
}
ClassUtils.forName,拿着类加载器,完成了类的加载。这是spring自己封装了,最后还是调用了Class.forName()方法;
上述方法出来,做如下操作: mbdToUse.prepareMethodOverrides(); 上面这一步先不管,看下面这一步: Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
这里做的操作,就是依次执行
InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation和postProcessAfterInstantiation方法:
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
可以看到,如果没执行BeforeInstantiation,那么也不会执行AfterInitialization
AnnotationConfigApplicationContext
NoCacheAutoProxyCreator
跳出来,执行真正的创建代码:
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
// Make sure bean class is actually resolved at this point.
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());
}
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) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// Need to determine the constructor...
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
从代码中可以看到,获取构造器依赖于SmartInstantiationAwareBeanPostProcessor,会执行他的determineCandidateConstructors方法。最终执行的AutowiredAnnotationBeanPostProcessor类的方法:
它会遍历类的方法,找Lookup注解,然后再对父类方法执行一致操作;
通过上述一系列操作,找有没有特殊的构造方法。如果没有,则执用无参的构造方法:
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
上面通过默认的构造方法,创建了一个对象。到这里,我们的依赖还没有被自动注入。
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
构造BeanWrpper,然后执行initBeanWrapper方法,然后返回初始化后的BeanWrapper对象给调用方。
可以看到doCreateBean方法中执行了applyMergedBeanDefinitionPostProcessors方法:
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
执行了所有MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法。
依次是:
CommonAnnotationBeanPostProcessor,它会处理@Resource注解,找到需要@Resouce注入的对象;AutowiredAnnotationBeanPostProcessor,它会处理@Autowired,@Value,@Inject。
上述弄完后,执行populateBean方法:
先遍历InstantiationAwareBeanPostProcessor,找到一个匹配的postProcessAfterInstantiation。我这里倒是没执行什么东西。继续往下走。
查看自动注入模式,我这里是根据Name匹配
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
他会调用doGetBean,触发上面加载bean流程,完善依赖bean的加载。
autowireByName,完全是根据属性名字注入的,没有根据@Resource制定的名字去处理。
后面再遍历InstantiationAwareBeanPostProcessor,执行postProcessPropertyValues方法:
CommonAnnotationBeanPostProcessor
InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
try {
metadata.inject(bean, beanName, pvs);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
}
return pvs;
inject方法完成了属性的注入。
然后是AutowiredAnnotationBeanPostProcessor,完成对应注解依赖的注入。
之后执行
applyPropertyValues(beanName, mbd, bw, pvs);
这里看着也没做啥
回到doCreateBean方法,执行
exposedObject = initializeBean(beanName, exposedObject, mbd);
它里面会执行PostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法:
回头缕了一下,发现是mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME搞的鬼,导致我的类属性被覆盖。
ComponentScanBeanDefinitionParser
更多推荐
所有评论(0)