十年网站开发经验 + 多家企业客户 + 靠谱的建站团队
量身定制 + 运营维护+专业推广+无忧售后,网站问题一站解决
这篇文章主要讲解了“Spring获取Bean的过程是怎样的”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Spring获取Bean的过程是怎样的”吧!
成都创新互联成都企业网站建设服务,提供网站制作、做网站网站开发,网站定制,建网站,网站搭建,网站设计,成都响应式网站建设公司,网页设计师打造企业风格网站,提供周到的售前咨询和贴心的售后服务。欢迎咨询做网站需要多少钱:13518219792之前的文章,分析了非懒加载的单例Bean整个加载过程,除了非懒加载的单例Bean之外,Spring中还有一种Bean就是原型(Prototype)的Bean,看一下定义方式:
1 2 6 7 8 9
原型Bean加载流程总得来说和单例Bean差不多,看一下不同之处,在AbstractBeanFactory的doGetBean的方法的这一步:
1 else if (mbd.isPrototype()) { 2 // It's a prototype -> create a new instance. 3 Object prototypeInstance = null; 4 try { 5 beforePrototypeCreation(beanName); 6 prototypeInstance = createBean(beanName, mbd, args); 7 } 8 finally { 9 afterPrototypeCreation(beanName); 10 } 11 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); 12 }
第6行createBean是一样的,原型Bean实例化的主要区别就在于第6行,它是直接创建bean的,而单例bean我们再对比一下:
1 if (mbd.isSingleton()) { 2 sharedInstance = getSingleton(beanName, new ObjectFactory() { 3 public Object getObject() throws BeansException { 4 try { 5 return createBean(beanName, mbd, args); 6 } 7 catch (BeansException ex) { 8 // Explicitly remove instance from singleton cache: It might have been put there 9 // eagerly by the creation process, to allow for circular reference resolution. 10 // Also remove any beans that received a temporary reference to the bean. 11 destroySingleton(beanName); 12 throw ex; 13 } 14 } 15 }); 16 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 17 }
它优先会尝试getSington,即先尝试从singletonObjects中获取一下bean是否存在,如果存在直接返回singletonObjects中的bean对象。
接着,我们看到原型bean创建和单例bean创建的区别还在于第5行和第9行,先看第5行的代码:
1 protected void beforePrototypeCreation(String beanName) { 2 Object curVal = this.prototypesCurrentlyInCreation.get(); 3 if (curVal == null) { 4 this.prototypesCurrentlyInCreation.set(beanName); 5 } 6 else if (curVal instanceof String) { 7 Set beanNameSet = new HashSet(2); 8 beanNameSet.add((String) curVal); 9 beanNameSet.add(beanName); 10 this.prototypesCurrentlyInCreation.set(beanNameSet); 11 } 12 else { 13 Set beanNameSet = (Set) curVal; 14 beanNameSet.add(beanName); 15 } 16 }
这段主要是说bean在创建前要把当前beanName设置到ThreadLocal中去,其目的是保证多线程不会同时创建同一个bean。接着看第9行的代码实现,即bean创建之后做了什么:
1 protected void afterPrototypeCreation(String beanName) { 2 Object curVal = this.prototypesCurrentlyInCreation.get(); 3 if (curVal instanceof String) { 4 this.prototypesCurrentlyInCreation.remove(); 5 } 6 else if (curVal instanceof Set) { 7 Set beanNameSet = (Set) curVal; 8 beanNameSet.remove(beanName); 9 if (beanNameSet.isEmpty()) { 10 this.prototypesCurrentlyInCreation.remove(); 11 } 12 } 13 }
很好理解,就是把当前bean移除一下,这样其它线程就可以创建bean了。第11行的代码不看了,意思是如果bean是FactoryBean的实现类的话,调用getObject()方法获取真正的对象。
Spring有为开发者提供Autowire(自动装配)的功能,自动装配最常用的就是byName和byType这两种属性。由于自动装配是为了解决对象注入导致的过多的问题,因此很容易找到byName与byType的Spring源码实现应该在属性注入这一块,定位到属性注入的代码AbstractAutowireCapableBeanFactory的populateBean方法,直接截取重点:
1 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || 2 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 3 MutablePropertyValues newPvs = new MutablePropertyValues(pvs); 4 5 // Add property values based on autowire by name if applicable. 6 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { 7 autowireByName(beanName, mbd, bw, newPvs); 8 } 9 10 // Add property values based on autowire by type if applicable. 11 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { 12 autowireByType(beanName, mbd, bw, newPvs); 13 } 14 15 pvs = newPvs; 16 }
看到第6行第8行判断是否byName形式,是就执行byName自动装配代码;第11行第13行判断是否byType形式,是就执行byType自动装配代码。那么首先看一下第7行的byName代码实现:
1 protected void autowireByName( 2 String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { 3 4 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); 5 for (String propertyName : propertyNames) { 6 if (containsBean(propertyName)) { 7 Object bean = getBean(propertyName); 8 pvs.add(propertyName, bean); 9 registerDependentBean(propertyName, beanName); 10 if (logger.isDebugEnabled()) { 11 logger.debug("Added autowiring by name from bean name '" + beanName + 12 "' via property '" + propertyName + "' to bean named '" + propertyName + "'"); 13 } 14 } 15 else { 16 if (logger.isTraceEnabled()) { 17 logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + 18 "' by name: no matching bean found"); 19 } 20 } 21 } 22 }
篇幅问题,代码不一层层跟了,逻辑梳理一下:
第4行,找到Bean中不是简单属性的属性,这句话有点绕,意思就是找到属性是对象类型的属性,但也不是所有的对象类型都会被找到,比如CharSequence类型、Number类型、Date类型、URL类型、URI类型、Locale类型、Class类型就会忽略,具体可见BeanUtils的isSimpleProperty方法
第5行~第7行,遍历所有被找到的属性,如果bean定义中包含了属性名,那么先实例化该属性名对应的bean
第9行registerDependentBean,注册一下当前bean的依赖bean,用于在某个bean被销毁前先将其依赖的bean销毁
其余代码都是一些打日志的,没什么好说的。
上面说了byName的源码实现,接下来看一下byType源码实现:
1 protected void autowireByType( 2 String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { 3 4 TypeConverter converter = getCustomTypeConverter(); 5 if (converter == null) { 6 converter = bw; 7 } 8 9 Set autowiredBeanNames = new LinkedHashSet(4); 10 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); 11 for (String propertyName : propertyNames) { 12 try { 13 PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); 14 // Don't try autowiring by type for type Object: never makes sense, 15 // even if it technically is a unsatisfied, non-simple property. 16 if (!Object.class.equals(pd.getPropertyType())) { 17 MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); 18 // Do not allow eager init for type matching in case of a prioritized post-processor. 19 boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass()); 20 DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager); 21 Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); 22 if (autowiredArgument != null) { 23 pvs.add(propertyName, autowiredArgument); 24 } 25 for (String autowiredBeanName : autowiredBeanNames) { 26 registerDependentBean(autowiredBeanName, beanName); 27 if (logger.isDebugEnabled()) { 28 logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" + 29 propertyName + "' to bean named '" + autowiredBeanName + "'"); 30 } 31 } 32 autowiredBeanNames.clear(); 33 } 34 } 35 catch (BeansException ex) { 36 throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex); 37 } 38 } 39 }
前面一样,到第10行都是找到Bean中属性是对象类型的属性。
接着就是遍历一下PropertyName,获取PropertyName对应的属性描述,注意一下16行的判断及其对应的注释:不要尝试自动装配Object类型,这没有任何意义,即使从技术角度看它是一个非简单的对象属性。
第18行~第20行跳过(没有太明白是干什么的),byType实现的源码主要在第21行的方法resolveDependency中,这个方法是AbstractAutowireCapableBeanFactory类的实现类DefaultListableBeanFactory中的方法:
1 public Object resolveDependency(DependencyDescriptor descriptor, String beanName, 2 Set autowiredBeanNames, TypeConverter typeConverter) throws BeansException { 3 4 descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); 5 if (descriptor.getDependencyType().equals(ObjectFactory.class)) { 6 return new DependencyObjectFactory(descriptor, beanName); 7 } 8 else if (descriptor.getDependencyType().equals(javaxInjectProviderClass)) { 9 return new DependencyProviderFactory().createDependencyProvider(descriptor, beanName); 10 } 11 else { 12 return doResolveDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter); 13 } 14 }
这里判断一下要自动装配的属性是ObjectFactory.class还是javaxInjectProviderClass还是其他的,我们装配的是其他的,看一下12行的代码实现:
1 protected Object doResolveDependency(DependencyDescriptor descriptor, Class> type, String beanName, 2 Set autowiredBeanNames, TypeConverter typeConverter) throws BeansException { 3 4 Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor); 5 if (value != null) { 6 if (value instanceof String) { 7 String strVal = resolveEmbeddedValue((String) value); 8 BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null); 9 value = evaluateBeanDefinitionString(strVal, bd); 10 } 11 TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); 12 return converter.convertIfNecessary(value, type); 13 } 14 15 if (type.isArray()) { 16 ... 17 } 18 else if (Collection.class.isAssignableFrom(type) && type.isInterface()) { 19 ... 20 } 21 else if (Map.class.isAssignableFrom(type) && type.isInterface()) { 22 ... 23 } 24 else { 25 Map
第四行结果是null不看了,为了简化代码Array装配、Collection装配、Map装配的代码都略去了,重点看一下普通属性的装配。首先是第25行获取一下自动装配的候选者:
1 protected Map
代码逻辑整理一下:
首先获取候选者bean名称,通过DefaultListableBeanFactory的getBeanNamesForType方法,即找一下所有的Bean定义中指定Type的实现类或者子类
接着第7行~第16行的判断要自动装配的类型是不是要自动装配的纠正类型,这个在 【Spring源码分析】非懒加载的单例Bean初始化前后的一些操作一文讲PrepareBeanFactory方法的时候有讲过,如果要自动装配的类型是纠正类型,比如是一个ResourceLoader,那么就会为该类型生成一个代理实例,具体可以看一下第10行的AutowireUtils.resolveAutowiringValue方法的实现
正常来说都是执行的第17行~第21行的代码,逐个判断查找一下beanName对应的BeanDefinition,判断一下是不是自动装配候选者,默认都是的,如果的autowire-candidate属性设置为false就不是
这样,拿到所有待装配对象的实现类或者子类的候选者,组成一个Map,Key为beanName,Value为具体的Bean。接着回看获取Bean之后的逻辑:
1 Map
整理一下逻辑:
如果拿到的Map是空的且属性必须注入,抛异常
如果拿到的Map中有多个候选对象,判断其中是否有中属性配置为"primary=true"的,有就拿执行第13行~第15行的代码,没有就第8行的方法返回null,抛异常,这个异常的描述相信Spring用的比较多的应该比较熟悉
如果拿到的Map中只有一个候选对象,直接拿到那个
通过这样一整个流程,实现了byType自动装配,byType自动装配流程比较长,中间细节比较多,还需要多看看才能弄明白。
最后注意一点,即所有待注入的PropertyName–>PropertyValue映射拿到之后都只是放在MutablePropertyValues中,最后由AbstractPropertyAccessor类的setPropertyValues方法遍历并进行逐一注入。
我们知道可以通过实现FactoryBean接口,重写getObject()方法实现个性化定制Bean的过程,这部分我们就来看一下Spring源码是如何实现通过FactoryBean获取Bean实例的。代码直接定位到AbstractBeanFactory的doGetBean方法创建单例Bean这部分:
1 // Create bean instance. 2 if (mbd.isSingleton()) { 3 sharedInstance = getSingleton(beanName, new ObjectFactory() { 4 public Object getObject() throws BeansException { 5 try { 6 return createBean(beanName, mbd, args); 7 } 8 catch (BeansException ex) { 9 // Explicitly remove instance from singleton cache: It might have been put there 10 // eagerly by the creation process, to allow for circular reference resolution. 11 // Also remove any beans that received a temporary reference to the bean. 12 destroySingleton(beanName); 13 throw ex; 14 } 15 } 16 }); 17 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 18 }
FactoryBean首先是个Bean且被实例化出来成为一个对象之后才能调用getObject()方法,因此还是会执行第3行~第16行的代码,这段代码之前分析过了就不说了。之后执行第17行的方法:
1 protected Object getObjectForBeanInstance( 2 Object beanInstance, String name, String beanName, RootBeanDefinition mbd) { 3 4 // Don't let calling code try to dereference the factory if the bean isn't a factory. 5 if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) { 6 throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass()); 7 } 8 9 // Now we have the bean instance, which may be a normal bean or a FactoryBean. 10 // If it's a FactoryBean, we use it to create a bean instance, unless the 11 // caller actually wants a reference to the factory. 12 if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { 13 return beanInstance; 14 } 15 16 Object object = null; 17 if (mbd == null) { 18 object = getCachedObjectForFactoryBean(beanName); 19 } 20 if (object == null) { 21 // Return bean instance from factory. 22 FactoryBean factory = (FactoryBean) beanInstance; 23 // Caches object obtained from FactoryBean if it is a singleton. 24 if (mbd == null && containsBeanDefinition(beanName)) { 25 mbd = getMergedLocalBeanDefinition(beanName); 26 } 27 boolean synthetic = (mbd != null && mbd.isSynthetic()); 28 object = getObjectFromFactoryBean(factory, beanName, !synthetic); 29 } 30 return object; 31 }
首先第5行~第7行判断一下是否beanName以"&“开头并且不是FactoryBean的实现类,不满足则抛异常,因为beanName以”&"开头是FactoryBean的实现类bean定义的一个特征。
接着判断第12行~第14行,如果:
bean不是FactoryBean的实现类
beanName以"&"开头
这两种情况,都直接把生成的bean对象返回出去,不会执行余下的流程。
最后流程走到第16行~第30行,最终调用getObject()方法实现个性化定制bean,先执行第28行的方法:
1 protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) { 2 if (factory.isSingleton() && containsSingleton(beanName)) { 3 synchronized (getSingletonMutex()) { 4 Object object = this.factoryBeanObjectCache.get(beanName); 5 if (object == null) { 6 object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess); 7 this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT)); 8 } 9 return (object != NULL_OBJECT ? object : null); 10 } 11 } 12 else { 13 return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess); 14 } 15 }
第1行第11行的代码与第12行第13行的代码最终都是一样的,调用了如下一段:
1 private Object doGetObjectFromFactoryBean( 2 final FactoryBean factory, final String beanName, final boolean shouldPostProcess) 3 throws BeanCreationException { 4 5 Object object; 6 try { 7 if (System.getSecurityManager() != null) { 8 AccessControlContext acc = getAccessControlContext(); 9 try { 10 object = AccessController.doPrivileged(new PrivilegedExceptionAction() { 11 public Object run() throws Exception { 12 return factory.getObject(); 13 } 14 }, acc); 15 } 16 catch (PrivilegedActionException pae) { 17 throw pae.getException(); 18 } 19 } 20 else { 21 object = factory.getObject(); 22 } 23 } 24 catch (FactoryBeanNotInitializedException ex) { 25 throw new BeanCurrentlyInCreationException(beanName, ex.toString()); 26 } 27 catch (Throwable ex) { 28 throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex); 29 } 30 31 // Do not accept a null value for a FactoryBean that's not fully 32 // initialized yet: Many FactoryBeans just return null then. 33 if (object == null && isSingletonCurrentlyInCreation(beanName)) { 34 throw new BeanCurrentlyInCreationException( 35 beanName, "FactoryBean which is currently in creation returned null from getObject"); 36 } 37 38 if (object != null && shouldPostProcess) { 39 try { 40 object = postProcessObjectFromFactoryBean(object, beanName); 41 } 42 catch (Throwable ex) { 43 throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object failed", ex); 44 } 45 } 46 47 return object; 48 }
第12行和第21行的代码,都一样,最终调用getObject()方法获取对象。回过头去看之前的getObjectFromFactoryBean方法,虽然if…else…逻辑最终都是调用了以上的方法,但是区别在于:
如果FactoryBean接口实现类的isSington方法返回的是true,那么每次调用getObject方法的时候会优先尝试从FactoryBean对象缓存中取目标对象,有就直接拿,没有就创建并放入FactoryBean对象缓存,这样保证了每次单例的FactoryBean调用getObject()方法后最终拿到的目标对象一定是单例的,即在内存中都是同一份
如果FactoryBean接口实现类的isSington方法返回的是false,那么每次调用getObject方法的时候都会新创建一个目标对象
感谢各位的阅读,以上就是“Spring获取Bean的过程是怎样的”的内容了,经过本文的学习后,相信大家对Spring获取Bean的过程是怎样的这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是创新互联,小编将为大家推送更多相关知识点的文章,欢迎关注!