SpringIoC依赖注入的过程(三)
上文说到doCreateBean的applyMergedBeanDefinitionPostProcessors方法找到了所有的声明了Autowired标注和Resource标注的字段和方法,以及声明了PostConstruct和PreDestroy标注的方法。到此为止,bean的依赖关系都已经解析到BeanDefinition中,接下来就是利用这些依赖关系进行注入。继续看doCreateBean方法的剩余部分
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, new ObjectFactory() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
这部分代码是什么意思呢?可以看到有一个变量名字叫做allowCircularReferences,可以猜出这里就是处理循环引用的。比如Service1引用了Service2,而Service2也引用了Service1。如果现在正在创建Service1,发现它依赖了Service2,在向Service1注入Service2的过程中肯定要先去创建Service2。这时候发现又要创建Service1,当然不能再创建一个Service1了,而是先将未初始化好的Service1引用先注入到Service2中。然后初始化Service2后再回过来注入到Service1中。关于循环引用的依赖注入过程也许后续会专门的详细解读,今天简单带过,先把主体的流程说通。下面说SpringIoC的重头戏,
populateBean方法,依赖注入就发生在这里。还是分段说吧,免得代码太长
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
上面是要讲的populateBean方法中的第一段代码,它调用所有的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation的方法。
InstantiationAwareBeanPostProcessor的实现类有下面这些
postProcessAfterInstantiation是在bean被实例化以后留出的扩展方法,但实际上并没有用到,上面那些类都是直接返回了true,依赖注入不是发生在这里。我们继续往下看
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;
}
这里是一处依赖注入发生的地方,如果当前的bean是AUTOWIRE_BY_NAME或者AUTOWIRE_BY_TYPE的主动注入模式,则会触发相应的注入方法。先看一下autowireByName
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
if (containsBean(propertyName)) {
Object bean = getBean(propertyName);
pvs.add(propertyName, bean);
registerDependentBean(propertyName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
很好理解,先找到需要注入的依赖的bean的名字,然后递归调用getBean。getBean执行完后就会返回依赖的bean的实例,放入到PropertyValues中。再看看autowireByType是怎么做的
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if (!Object.class.equals(pd.getPropertyType())) {
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
registerDependentBean(autowiredBeanName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
根据类型自动注入的过程稍复杂一些,总体的过程是这样的。通过resolveDependency方法最终调用DefaultListableBeanFactory中的doResolveDependency方法,然后得到需要注入的bean的实例,同样先放到
PropertyValues中。不早了,先到这里,剩下的后面继续。