闸北区网站建设网页设,杭州兼职网站建设,河南省建设厅证件查询官网,瑞安论坛正文
doCreateBean() 主要用于完成 bean 的创建和初始化工作#xff0c;我们可以将其分为四个过程#xff1a; 最全面的Java面试网站 createBeanInstance() 实例化 beanpopulateBean() 属性填充循环依赖的处理initializeBean() 初始化 bean
第一个过程实例化 bean在前面一篇…正文
doCreateBean() 主要用于完成 bean 的创建和初始化工作我们可以将其分为四个过程 最全面的Java面试网站 createBeanInstance() 实例化 beanpopulateBean() 属性填充循环依赖的处理initializeBean() 初始化 bean
第一个过程实例化 bean在前面一篇博客中已经分析完了这篇博客开始分析 属性填充也就是 populateBean()
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) { PropertyValues pvs mbd.getPropertyValues(); if (bw null) { if (!pvs.isEmpty()) { 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. boolean continueWithPropertyPopulation true; if (!mbd.isSynthetic() hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp (InstantiationAwareBeanPostProcessor) bp; //返回值为是否继续填充bean if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation false; break; } } } } //如果后处理器发出停止填充命令则终止后续的执行 if (!continueWithPropertyPopulation) { return; } 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; } //后处理器已经初始化 boolean hasInstAwareBpps hasInstantiationAwareBeanPostProcessors(); //需要依赖检查 boolean needsDepCheck (mbd.getDependencyCheck() ! RootBeanDefinition.DEPENDENCY_CHECK_NONE); if (hasInstAwareBpps || needsDepCheck) { 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) { //依赖检查对应depends-on属性3.0已经弃用此属性 checkDependencies(beanName, mbd, filteredPds, pvs); } } //将属性应用到bean中 //将所有ProtertyValues中的属性填充至BeanWrapper中。 applyPropertyValues(beanName, mbd, bw, pvs);
} 我们来分析下populateBean的流程
1首先进行属性是否为空的判断
2通过调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)方法来控制程序是否继续进行属性填充
3根据注入类型byName/byType提取依赖的bean并统一存入PropertyValues中
4应用InstantiationAwareBeanPostProcessor的postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName)方法对属性获取完毕填充前的再次处理典型的应用是RequiredAnnotationBeanPostProcesser类中对属性的验证
5将所有的PropertyValues中的属性填充至BeanWrapper中
上面步骤中有几个地方是我们比较感兴趣的它们分别是依赖注入autowireByName/autowireByType以及属性填充接下来进一步分析这几个功能的实现细节 分享一份大彬精心整理的大厂面试手册包含计算机基础、Java基础、多线程、JVM、数据库、Redis、Spring、Mybatis、SpringMVC、SpringBoot、分布式、微服务、设计模式、架构、校招社招分享等高频面试题非常实用有小伙伴靠着这份手册拿过字节offer~ 需要的小伙伴可以自行下载 http://mp.weixin.qq.com/s?__bizMzg2OTY1NzY0MQmid2247485445idx1sn1c6e224b9bb3da457f5ee03894493dbcchksmce98f543f9ef7c55325e3bf336607a370935a6c78dbb68cf86e59f5d68f4c51d175365a189f8#rd 自动注入
Spring 会根据注入类型 byName / byType 的不同调用不同的方法autowireByName() / autowireByType()来注入属性值。
autowireByName()
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {// 获取 Bean 对象中非简单属性String[] propertyNames unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {// 如果容器中包含指定名称的 bean则将该 bean 注入到 bean中if (containsBean(propertyName)) {// 递归初始化相关 beanObject 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 的非简单属性什么叫做非简单属性呢就是类型为对象类型的属性但是这里并不是将所有的对象类型都都会找到比如 8 个原始类型String 类型 Number类型、Date类型、URL类型、URI类型等都会被忽略如下
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {SetString result new TreeSet();PropertyValues pvs mbd.getPropertyValues();PropertyDescriptor[] pds bw.getPropertyDescriptors();for (PropertyDescriptor pd : pds) {if (pd.getWriteMethod() ! null !isExcludedFromDependencyCheck(pd) !pvs.contains(pd.getName()) !BeanUtils.isSimpleProperty(pd.getPropertyType())) {result.add(pd.getName());}}return StringUtils.toStringArray(result);
}这里获取的就是需要依赖注入的属性。
autowireByName()函数的功能就是根据传入的参数中的pvs中找出已经加载的bean并递归实例化然后加入到pvs中
autowireByType
autowireByType与autowireByName对于我们理解与使用来说复杂程度相似但是实现功能的复杂度却不一样我们看下方法代码
protected void autowireByType( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { TypeConverter converter getCustomTypeConverter(); if (converter null) { converter bw; } SetString autowiredBeanNames new LinkedHashSetString(4); //寻找bw中需要依赖注入的属性 String[] propertyNames unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { try { PropertyDescriptor pd bw.getPropertyDescriptor(propertyName); // Dont 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())) { //探测指定属性的set方法 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); //解析指定beanName的属性所匹配的值并把解析到的属性名称存储在autowiredBeanNames中 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); } }
}根据名称第一步与根据属性第一步都是寻找bw中需要依赖注入的属性然后遍历这些属性并寻找类型匹配的bean,其中最复杂就是寻找类型匹配的bean。spring中提供了对集合的类型注入支持如使用如下注解方式
Autowired
private ListTest tests;这种方式spring会把所有与Test匹配的类型找出来并注入到tests属性中正是由于这一因素所以在autowireByType函数新建了局部遍历autowireBeanNames用于存储所有依赖的bean如果只是对非集合类的属性注入来说此属性并无用处。
对于寻找类型匹配的逻辑实现是封装在了resolveDependency函数中其实现如下
public Object resolveDependency(DependencyDescriptor descriptor, String beanName, SetString autowiredBeanNames, TypeConverter typeConverter) throws BeansException {descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); if (descriptor.getDependencyType().equals(ObjectFactory.class)) { //ObjectFactory类注入的特殊处理 return new DependencyObjectFactory(descriptor, beanName); } else if (descriptor.getDependencyType().equals(javaxInjectProviderClass)) { //javaxInjectProviderClass类注入的特殊处理 return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName); } else { //通用处理逻辑 return doResolveDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter); }
} protected Object doResolveDependency(DependencyDescriptor descriptor, Class? type, String beanName, SetString autowiredBeanNames, TypeConverter typeConverter) throws BeansException { /* * 用于支持Spring中新增的注解Value */ Object value getAutowireCandidateResolver().getSuggestedValue(descriptor); if (value ! null) { if (value instanceof String) { String strVal resolveEmbeddedValue((String) value); BeanDefinition bd (beanName ! null containsBean(beanName) ? getMergedBeanDefinition(beanName) : null); value evaluateBeanDefinitionString(strVal, bd); } TypeConverter converter (typeConverter ! null ? typeConverter : getTypeConverter()); return (descriptor.getField() ! null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter())); } //如果解析器没有成功解析则需要考虑各种情况 //属性是数组类型 if (type.isArray()) { Class? componentType type.getComponentType(); //根据属性类型找到beanFactory中所有类型的匹配bean //返回值的构成为key匹配的beanName,valuebeanName对应的实例化后的bean通过getBean(beanName)返回 MapString, Object matchingBeans findAutowireCandidates(beanName, componentType, descriptor); if (matchingBeans.isEmpty()) { //如果autowire的require属性为true而找到的匹配项却为空则只能抛出异常 if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(componentType, array of componentType.getName(), descriptor); } return null; } if (autowiredBeanNames ! null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } TypeConverter converter (typeConverter ! null ? typeConverter : getTypeConverter()); //通过转换器将bean的值转换为对应的type类型 return converter.convertIfNecessary(matchingBeans.values(), type); } //属性是Collection类型 else if (Collection.class.isAssignableFrom(type) type.isInterface()) { Class? elementType descriptor.getCollectionType(); if (elementType null) { if (descriptor.isRequired()) { throw new FatalBeanException(No element type declared for collection [ type.getName() ]); } return null; } MapString, Object matchingBeans findAutowireCandidates(beanName, elementType, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(elementType, collection of elementType.getName(), descriptor); } return null; } if (autowiredBeanNames ! null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } TypeConverter converter (typeConverter ! null ? typeConverter : getTypeConverter()); return converter.convertIfNecessary(matchingBeans.values(), type); } //属性是Map类型 else if (Map.class.isAssignableFrom(type) type.isInterface()) { Class? keyType descriptor.getMapKeyType(); if (keyType null || !String.class.isAssignableFrom(keyType)) { if (descriptor.isRequired()) { throw new FatalBeanException(Key type [ keyType ] of map [ type.getName() ] must be assignable to [java.lang.String]); } return null; } Class? valueType descriptor.getMapValueType(); if (valueType null) { if (descriptor.isRequired()) { throw new FatalBeanException(No value type declared for map [ type.getName() ]); } return null; } MapString, Object matchingBeans findAutowireCandidates(beanName, valueType, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(valueType, map with value type valueType.getName(), descriptor); } return null; } if (autowiredBeanNames ! null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } return matchingBeans; } else { MapString, Object matchingBeans findAutowireCandidates(beanName, type, descriptor); if (matchingBeans.isEmpty()) { if (descriptor.isRequired()) { raiseNoSuchBeanDefinitionException(type, , descriptor); } return null; } if (matchingBeans.size() 1) { String primaryBeanName determinePrimaryCandidate(matchingBeans, descriptor); if (primaryBeanName null) { throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet()); } if (autowiredBeanNames ! null) { autowiredBeanNames.add(primaryBeanName); } return matchingBeans.get(primaryBeanName); } // We have exactly one match. Map.EntryString, Object entry matchingBeans.entrySet().iterator().next(); if (autowiredBeanNames ! null) { autowiredBeanNames.add(entry.getKey()); } //已经确定只有一个匹配项 return entry.getValue(); }
}主要就是通过Type从BeanFactory中找到对应的benaName然后通过getBean获取实例
protected MapString, Object findAutowireCandidates(Nullable String beanName, Class? requiredType, DependencyDescriptor descriptor) {//在BeanFactory找到所有Type类型的beanNameString[] candidateNames BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.isEager());MapString, Object result new LinkedHashMap(candidateNames.length);//遍历所有的beanName,通过getBean获取for (String candidate : candidateNames) {if (!isSelfReference(beanName, candidate) isAutowireCandidate(candidate, descriptor)) {//addCandidateEntry(result, candidate, descriptor, requiredType);}}return result;
}private void addCandidateEntry(MapString, Object candidates, String candidateName,DependencyDescriptor descriptor, Class? requiredType) {Object beanInstance descriptor.resolveCandidate(candidateName, requiredType, this);if (!(beanInstance instanceof NullBean)) {candidates.put(candidateName, beanInstance);}
}public Object resolveCandidate(String beanName, Class? requiredType, BeanFactory beanFactory)throws BeansException {//通过类型找到beanName,然后再找到其实例return beanFactory.getBean(beanName);
}applyPropertyValues
程序运行到这里已经完成了对所有注入属性的获取但是获取的属性是以PropertyValues形式存在的还并没有应用到已经实例化的bean中这一工作是在applyPropertyValues中。继续跟踪到方法体中
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { if (pvs null || pvs.isEmpty()) { return; } MutablePropertyValues mpvs null; ListPropertyValue original; if (System.getSecurityManager() ! null) { if (bw instanceof BeanWrapperImpl) { ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext()); } } if (pvs instanceof MutablePropertyValues) { mpvs (MutablePropertyValues) pvs; //如果mpvs中的值已经被转换为对应的类型那么可以直接设置到beanwapper中 if (mpvs.isConverted()) { // Shortcut: use the pre-converted values as-is. try { bw.setPropertyValues(mpvs); return; } catch (BeansException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, Error setting property values, ex); } } original mpvs.getPropertyValueList(); } else { //如果pvs并不是使用MutablePropertyValues封装的类型那么直接使用原始的属性获取方法 original Arrays.asList(pvs.getPropertyValues()); } TypeConverter converter getCustomTypeConverter(); if (converter null) { converter bw; } //获取对应的解析器 BeanDefinitionValueResolver valueResolver new BeanDefinitionValueResolver(this, beanName, mbd, converter); // Create a deep copy, resolving any references for values. ListPropertyValue deepCopy new ArrayListPropertyValue(original.size()); boolean resolveNecessary false; //遍历属性将属性转换为对应类的对应属性的类型 for (PropertyValue pv : original) { if (pv.isConverted()) { deepCopy.add(pv); } else { String propertyName pv.getName(); Object originalValue pv.getValue(); Object resolvedValue valueResolver.resolveValueIfNecessary(pv, originalValue); Object convertedValue resolvedValue; boolean convertible bw.isWritableProperty(propertyName) !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { convertedValue convertForProperty(resolvedValue, propertyName, bw, converter); } // Possibly store converted value in merged bean definition, // in order to avoid re-conversion for every created bean instance. if (resolvedValue originalValue) { if (convertible) { pv.setConvertedValue(convertedValue); } deepCopy.add(pv); } else if (convertible originalValue instanceof TypedStringValue !((TypedStringValue) originalValue).isDynamic() !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) { pv.setConvertedValue(convertedValue); deepCopy.add(pv); } else { resolveNecessary true; deepCopy.add(new PropertyValue(pv, convertedValue)); } } } if (mpvs ! null !resolveNecessary) { mpvs.setConverted(); } // Set our (possibly massaged) deep copy. try { bw.setPropertyValues(new MutablePropertyValues(deepCopy)); } catch (BeansException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, Error setting property values, ex); }
}我们来看看具体的属性赋值过程
public class MyTestBean {private String name ;public MyTestBean(String name) {this.name name;}public MyTestBean() {}public String getName() {return name;}public void setName(String name) {this.name name;}
}bean idmyTestBean classdabin.spring01.MyTestBeanproperty namename valuedabin/property
/bean如上 bw.setPropertyValues 最终都会走到如下方法
Override
public void setValue(final Nullable Object value) throws Exception {//获取writeMethod也就是我们MyTestBean的setName方法final Method writeMethod (this.pd instanceof GenericTypeAwarePropertyDescriptor ?((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :this.pd.getWriteMethod());if (System.getSecurityManager() ! null) {AccessController.doPrivileged((PrivilegedActionObject) () - {ReflectionUtils.makeAccessible(writeMethod);return null;});try {AccessController.doPrivileged((PrivilegedExceptionActionObject) () -writeMethod.invoke(getWrappedInstance(), value), acc);}catch (PrivilegedActionException ex) {throw ex.getException();}}else {ReflectionUtils.makeAccessible(writeMethod);//通过反射调用方法进行赋值writeMethod.invoke(getWrappedInstance(), value);}
}就是利用反射进行调用对象的set方法赋值
至此doCreateBean() 第二个过程属性填充 已经分析完成了下篇分析第三个过程循环依赖的处理其实循环依赖并不仅仅只是在 doCreateBean() 中处理其实在整个加载 bean 的过程中都有涉及所以下篇内容并不仅仅只局限于 doCreateBean()。
