Shulou(Shulou.com)06/02 Report--

This article mainly explains "how Spring acquires Bean". The content in the article is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn how Spring acquires Bean.

Prototype Bean loading process

In the previous article, we analyzed the whole loading process of non-lazily loaded singleton Bean. In addition to non-lazily loaded singleton Bean, there is also a kind of Bean in Spring that is Bean of Prototype. Take a look at how it is defined:

1 2 6 7 8 9

In general, the prototype Bean loading process is similar to that of a singleton Bean. Take a look at the difference, this step in AbstractBeanFactory's doGetBean approach:

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}

Line 6 createBean is the same, and the main difference for prototype Bean instantiation is line 6, which creates bean directly, while for a single bean let's compare it:

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}

It will first try getSington, that is, first try to get whether bean exists from singletonObjects, and if so, return the bean object in singletonObjects directly.

Next, we see the difference between prototype bean creation and singleton bean creation in lines 5 and 9, starting with line 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}

This mainly means that bean should set the current beanName to ThreadLocal before it is created, and its purpose is to ensure that multiple threads will not create the same bean at the same time. Then take a look at the code implementation in line 9, that is, what bean does after it is created:

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}

It is easy to understand that the current bean is removed so that other threads can create the bean. The code in line 11 doesn't look, meaning that if bean is the implementation class of FactoryBean, call the getObject () method to get the real object.

ByName source code implementation

Spring provides developers with the function of Autowire (automatic assembly), and the two most commonly used attributes of automatic assembly are byName and byType. Since the purpose of automatic assembly is to solve the problem of excessive object injection, it is easy to find that the Spring source code implementation of byName and byType should locate the populateBean method of the attribute injection code AbstractAutowireCapableBeanFactory in the attribute injection block, and directly intercept the key points:

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}

When you see line 6, line 8 determines whether it is in byName form, it executes the byName automatic assembly code; line 11, line 13 determines whether it is in byType form, and executes the byType automatic assembly code. So first take a look at the byName code implementation on line 7:

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}

The question of space, the code does not follow layer by layer, sort out the logic:

Line 4, finding attributes that are not simple attributes in Bean is a bit of a twist, meaning that attributes are object types, but not all object types will be found, such as CharSequence type, Number type, Date type, URL type, URI type, Locale type and Class type. For more information, please see the isSimpleProperty method of BeanUtils.

Lines 5-7, iterate through all the attributes found. If the bean definition contains the attribute name, instantiate the bean corresponding to the attribute name first.

Line 9, registerDependentBean, register the dependent bean of the current bean, which is used to destroy the dependent bean of a bean before it is destroyed

The rest of the code is some log, there is nothing to say.

ByType source code implementation

The source code implementation of byName is mentioned above, so let's take a look at the byType source code implementation:

1 protected void autowireByType (2 String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {34 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}

As before, line 10 is to find the attribute in Bean that is of object type.

The next step is to iterate through the PropertyName to get the property description for PropertyName, and notice the 16-line judgment and its corresponding comments: don't try to automatically assemble the Object type, which doesn't make any sense, even if it's a non-simple object property from a technical point of view.

Skip lines 18-20 (not sure what it is for). The source code for the byType implementation is mainly in the method resolveDependency on line 21, which is the method in the implementation class DefaultListableBeanFactory of the AbstractAutowireCapableBeanFactory class:

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}

Let's determine whether the property to be automatically assembled is ObjectFactory.class or javaxInjectProviderClass or something else. Let's assemble something else. Take a look at the 12-line code implementation:

1 protected Object doResolveDependency (DependencyDescriptor descriptor, Class type, String beanName, 2 Set autowiredBeanNames, TypeConverter typeConverter) throws BeansException {34 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

The fourth line result is that null does not look, in order to simplify the code Array assembly, Collection assembly, Map assembly code has been omitted, focusing on the general attribute assembly. The first is line 25 to get the candidates for automatic assembly:

1 protected Map

Sort out the logic of the code:

First get the candidate bean name, through the getBeanNamesForType method of DefaultListableBeanFactory, that is, find all the implementation classes or subclasses of the Type specified in the Bean definition

Then lines 7 to 16 determine whether the type to be automatically assembled is the correction type to be automatically assembled. This is mentioned in the article on the PrepareBeanFactory method of some operations before and after the initialization of non-lazily loaded singleton Bean in [Spring Source Code Analysis]. If the type to be automatically assembled is a correction type, such as a ResourceLoader, then a proxy instance will be generated for that type. Specifically, take a look at the implementation of the AutowireUtils.resolveAutowiringValue method in line 10.

Normally, the code from line 17 to line 21 is executed. Check the BeanDefinition corresponding to beanName one by one, and determine whether it is an auto-assembly candidate. By default, it is true. If the autowire-candidate attribute is set to false, it is not.

In this way, get the candidates of all the implementation classes or subclasses of the object to be assembled, and form a specific Bean whose Map,Key is beanName,Value. Then look back at the logic after getting the Bean:

1 Map

Sort out the logic:

If the Map you get is empty and the property must be injected, an exception is thrown

If there are multiple candidates in the obtained Map, determine whether any of them have the attribute configured as "primary=true", take the code that executes lines 13-15, but does not return null for the method on line 8, and throw an exception. I believe that the description of this exception is more familiar with Spring.

If there is only one candidate in the Map, get that directly

Through such a whole process, byType automatic assembly is realized. ByType automatic assembly process is relatively long, and there are many details in the middle, which need to be understood more.

Finally, note that all the PropertyName- > PropertyValue mappings to be injected are simply placed in MutablePropertyValues, and are finally traversed and injected one by one by the setPropertyValues method of the AbstractPropertyAccessor class.

Obtain the source code implementation of Bean instance through FactoryBean

We know that we can rewrite the process of customizing Bean by implementing the FactoryBean interface and overriding the getObject () method. In this section, let's take a look at how the Spring source code can obtain Bean instances through FactoryBean. The code goes directly to the doGetBean method of AbstractBeanFactory to create a singleton 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 is first a Bean and instantiated into an object before the getObject () method can be called, so it still executes lines 3-16, which has been analyzed before. Then execute the method in line 17:

1 protected Object getObjectForBeanInstance (2 Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {34 / / 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 bea 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}

First, lines 5-7 determine whether beanName starts with "&" and is not an implementation class of FactoryBean, and throws an exception if it is not satisfied, because beanName starting with "&" is a feature of the definition of FactoryBean's implementation class bean.

Then judge lines 12-14, if:

Bean is not an implementation class of FactoryBean

BeanName begins with "&"

In both cases, the generated bean object is returned directly, and the rest of the process is not executed.

Finally, the process goes to line 16 to line 30, and finally calls the getObject () method to implement the personalized customization bean, first executing the method in line 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}

The code in line 1, line 11 is ultimately the same as the code in line 12, line 13, calling the following paragraph:

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}

The code in lines 12 and 21, both of which are the same, ends up calling the getObject () method to get the object. Going back to the previous getObjectFromFactoryBean method, although if... Else... The logic ultimately invokes the above methods, but the difference is:

If the isSington method of the FactoryBean implementation class returns true, then every time you call the getObject method, you will first try to get the target object from the FactoryBean object cache. If you have it, you will create it and put it in the FactoryBean object cache. This ensures that every singleton FactoryBean calls the getObject () method and finally gets the target object, that is, it is the same in memory.

If the isSington method of the FactoryBean interface implementation class returns false, a new target object is created each time the getObject method is called

Thank you for your reading, the above is the content of "how Spring acquires Bean". After the study of this article, I believe you have a deeper understanding of the process of Spring obtaining Bean, and the specific use needs to be verified in practice. Here is, the editor will push for you more related knowledge points of the article, welcome to follow!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.