Spring's startup class is
new ClassPathXmlApplicationContext
Start with this construction method and start debug ging
After that, we will enter a very important method of Spring: refresh
public void refresh() throws BeansException, IllegalStateException { synchronized(this.startupShutdownMonitor) { StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); this.prepareRefresh(); ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); this.prepareBeanFactory(beanFactory); try { this.postProcessBeanFactory(beanFactory); StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); this.invokeBeanFactoryPostProcessors(beanFactory); this.registerBeanPostProcessors(beanFactory); beanPostProcess.end(); this.initMessageSource(); this.initApplicationEventMulticaster(); this.onRefresh(); this.registerListeners(); this.finishBeanFactoryInitialization(beanFactory); this.finishRefresh(); } catch (BeansException var10) { if (this.logger.isWarnEnabled()) { this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10); } this.destroyBeans(); this.cancelRefresh(var10); throw var10; } finally { this.resetCommonCaches(); contextRefresh.end(); } } }
13 methods are implemented in refresh. These 13 methods are also the key to understanding Spring
First, the first method is prepareRefresh()
protected void prepareRefresh() { this.startupDate = System.currentTimeMillis(); this.closed.set(false); this.active.set(true); if (this.logger.isDebugEnabled()) { if (this.logger.isTraceEnabled()) { this.logger.trace("Refreshing " + this); } else { this.logger.debug("Refreshing " + this.getDisplayName()); } } this.initPropertySources(); this.getEnvironment().validateRequiredProperties(); if (this.earlyApplicationListeners == null) { this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners); } else { this.applicationListeners.clear(); this.applicationListeners.addAll(this.earlyApplicationListeners); } this.earlyApplicationEvents = new LinkedHashSet(); }
This method first obtains the current time of the system, then changes the flag bits of closed state and active state (from closed state to active state), and then sets some logging functions. Then execute this.initPropertySources(); Click in and you will find that this method is empty. It is obviously left for subclasses to extend, and spring MVC will extend it. Then it executes another method:
this.getEnvironment().validateRequiredProperties();
Environment is an interface that identifies the environment parameters of the system. If you click the getEnvironment method, you will find that its interior is very simple. Only one super method is executed, and super introduces a large number of parameters: the environment parameters are mainly the abstract parent class AbstractEnvironment itself.
Next, you will find that a large number of collection classes have been created to store pre refreshed listeners. However, these collection classes are currently empty and are only left for future expansion. This can be reflected in SpringBoot.
The second method is obtainFreshBeanFactory()
As the name suggests, to get the bean factory. So, what is BeanFactory? It is actually an object factory. It is an interface that overloads a large number of methods to obtain beans, getBean, and a series of methods to obtain bean aliases, obtain bean types, and judge whether it is a singleton. Some class diagrams of BeanFactory are as follows,
ListableBeanFactory defines the method of enumerating Bean objects, and hierarchalbeanfactory defines the method of obtaining parent class beans. So why does Spring define such a complex implementation structure? In fact, the reason is very simple. It is to reduce the coupling of code. When you need to develop a BeanFactoy with multiple functions, you only need to implement different interfaces.
To get back to business, click on the method and you will find that there are two methods:
protected final void refreshBeanFactory() throws BeansException { if (this.hasBeanFactory()) { this.destroyBeans(); this.closeBeanFactory(); } try { DefaultListableBeanFactory beanFactory = this.createBeanFactory(); beanFactory.setSerializationId(this.getId()); this.customizeBeanFactory(beanFactory); this.loadBeanDefinitions(beanFactory); this.beanFactory = beanFactory; } catch (IOException var2) { throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2); } }
First, refreshBeanFactory refreshes the Bean factory. First make an if judgment: if there is a Bean factory, destroy it and close it. A DefaultListableBeanFactory will then be created. This BeanFactory is one of the most commonly used BeanFactroy. After creation, a series of attribute values in BeanFactory will be set. The first setting method is
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) { if (this.allowBeanDefinitionOverriding != null) { beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding); } if (this.allowCircularReferences != null) { beanFactory.setAllowCircularReferences(this.allowCircularReferences); } }
Set whether to allow Bean object overrides and circular references
Next method
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); beanDefinitionReader.setEnvironment(this.getEnvironment()); beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); this.initBeanDefinitionReader(beanDefinitionReader); this.loadBeanDefinitions(beanDefinitionReader); }
This code is very complex. It has many overloaded methods. The purpose of this method is to load the Bean defined in the configuration file into BeanFactory. As for how it is loaded, we'll talk about it later
It can be seen that the obtainFreshBeanFactory() method generally creates a container object DefaultListableBeanFactory and loads the beans of the xml configuration file into the factory.
The third method: prepareBeanFactory(beanFactory)
The purpose is to set some attribute values of the Bean factory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { beanFactory.setBeanClassLoader(this.getClassLoader()); if (!shouldIgnoreSpel) { beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); } beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment())); beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class); beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); if (!NativeDetector.inNativeImage() && beanFactory.containsBean("loadTimeWeaver")) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } if (!beanFactory.containsLocalBean("environment")) { beanFactory.registerSingleton("environment", this.getEnvironment()); } if (!beanFactory.containsLocalBean("systemProperties")) { beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean("systemEnvironment")) { beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment()); } if (!beanFactory.containsLocalBean("applicationStartup")) { beanFactory.registerSingleton("applicationStartup", this.getApplicationStartup()); } }
This method first sets the class loader of the Bean factory, and then sets the parser of the SpEl expression
Then add beanpostprocessor (New applicationcontextawareprocessor (this)); Bean's enhancer is set. Then the following is a large number of methods starting with ignore, ignoring a large number of aware interfaces. So what does aware do? Aware is to get some objects in the container. If you click the classes that implement aware, you will find that most of them contain setXxx methods, because aware is directly translated as perception, which can make the class that implements aware of some of its properties, in other words, set the values of some of its properties. Then here are a number of register methods. Therefore, the main purpose of this method is obvious: initialize the properties of the bean factory
The fourth method: this.postProcessBeanFactory(beanFactory);
The name of this method is consistent with the method defined in the beanfactoryprocessor interface
@FunctionalInterface public interface BeanFactoryPostProcessor { void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException; }
However, if you click in, you will find that the method implementation is empty
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { }
Empty description, which can be used as an extension implementation
The fifth method:
invokeBeanFactoryPostProcessors(beanFactory)
This is its internal implementation details
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors()); if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } }
The specific function of this method is to instantiate and execute all registered BFPP objects, and this method must be executed before the instantiation of singleton objects.
If you continue to click in, you will find that the implementation of this code is very complex, which will be described in detail later.
But its main purpose we already know: strengthen the operation of Bean factory
The sixth method: registerbeanpost processors (beanfactory)
The purpose is to register and implement the BeanPostProcessor, which is a preparatory work before instantiating the Bean and paves the way for subsequent enhancement operations on the Bean. This method will be described in detail later
The seventh method: initMessageSource()
Some operations of internationalization
The eighth method: initapplicationeventmulticast();
Initialize the event broadcaster. When the listener detects a broadcast, it performs a response operation
Ninth method onRefresh()
Empty method, left to subclass implementation. In spring boot, this method is used to start tomcat
The tenth method registerListeners()
Register the listener and prepare for instantiation
The eleventh method: finishBeanFactoryInitialization(beanFactory)
The above five methods are all preparatory work, and this method is a key method.
This method is used to instantiate all the remaining non lazy loaded singleton objects. Click in
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) { beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class)); } if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver((strVal) -> { return this.getEnvironment().resolvePlaceholders(strVal); }); } String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); String[] var3 = weaverAwareNames; int var4 = weaverAwareNames.length; for(int var5 = 0; var5 < var4; ++var5) { String weaverAwareName = var3[var5]; this.getBean(weaverAwareName); } beanFactory.setTempClassLoader((ClassLoader)null); beanFactory.freezeConfiguration(); beanFactory.preInstantiateSingletons(); }
First, the type conversion service of the current context is initialized
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) { beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class)); }
Next, judge whether the current Bean factory contains a built-in value processor. If not, create one
if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver((strVal) -> { return this.getEnvironment().resolvePlaceholders(strVal); }); }
So, what is the built-in value Processor?
Explanation of Spring official documents
For example, the content in ${} needs to be parsed by EmbeddedValueResolver
The next section of code implements the related processing of the concept of "weaving" in AOP
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); String[] var3 = weaverAwareNames; int var4 = weaverAwareNames.length; for(int var5 = 0; var5 < var4; ++var5) { String weaverAwareName = var3[var5]; this.getBean(weaverAwareName); }
The next section of code sets the temporary class loader
beanFactory.setTempClassLoader((ClassLoader)null);
The next section of code freezes those unchanged Bean configurations
beanFactory.freezeConfiguration();
The next code is the focus
beanFactory.preInstantiateSingletons();
Let's go in and have a look
public void preInstantiateSingletons() throws BeansException { if (this.logger.isTraceEnabled()) { this.logger.trace("Pre-instantiating singletons in " + this); } List<String> beanNames = new ArrayList(this.beanDefinitionNames); Iterator var2 = beanNames.iterator(); while(true) { String beanName; Object bean; do { while(true) { RootBeanDefinition bd; do { do { do { if (!var2.hasNext()) { var2 = beanNames.iterator(); while(var2.hasNext()) { beanName = (String)var2.next(); Object singletonInstance = this.getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize").tag("beanName", beanName); SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged(() -> { smartSingleton.afterSingletonsInstantiated(); return null; }, this.getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } smartInitialize.end(); } } return; } beanName = (String)var2.next(); bd = this.getMergedLocalBeanDefinition(beanName); } while(bd.isAbstract()); } while(!bd.isSingleton()); } while(bd.isLazyInit()); if (this.isFactoryBean(beanName)) { bean = this.getBean("&" + beanName); break; } this.getBean(beanName); } } while(!(bean instanceof FactoryBean)); FactoryBean<?> factory = (FactoryBean)bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { SmartFactoryBean var10000 = (SmartFactoryBean)factory; ((SmartFactoryBean)factory).getClass(); isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext()); } else { isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit(); } if (isEagerInit) { this.getBean(beanName); } } }
At the beginning is the log related judgment, which does not need to be studied in depth.
if (this.logger.isTraceEnabled()) { this.logger.trace("Pre-instantiating singletons in " + this); }
Next, get a list of Bean names and get its iterator
List<String> beanNames = new ArrayList(this.beanDefinitionNames); Iterator var2 = beanNames.iterator();
Then traverse the Bean in turn to load the definition information RootBeanDefinition in its parent class
Its fundamental purpose is to improve BeanDefinition
Next, you will judge whether the Factory interface is implemented
if (this.isFactoryBean(beanName)) { bean = this.getBean("&" + beanName); break; }
If there is no implementation, use the name getBean directly
this.getBean(beanName);
This is why we can get the object itself directly through the factory object
Inside getBean is
public Object getBean(String name) throws BeansException { return this.doGetBean(name, (Class)null, (Object[])null, false); }
Jump into doGetBean
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName = this.transformedBeanName(name); Object sharedInstance = this.getSingleton(beanName); Object beanInstance; if (sharedInstance != null && args == null) { if (this.logger.isTraceEnabled()) { if (this.isSingletonCurrentlyInCreation(beanName)) { this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null); } else { if (this.isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } BeanFactory parentBeanFactory = this.getParentBeanFactory(); if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) { String nameToLookup = this.originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly); } if (args != null) { return parentBeanFactory.getBean(nameToLookup, args); } if (requiredType != null) { return parentBeanFactory.getBean(nameToLookup, requiredType); } return parentBeanFactory.getBean(nameToLookup); } if (!typeCheckOnly) { this.markBeanAsCreated(beanName); } StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name); try { if (requiredType != null) { beanCreation.tag("beanType", requiredType::toString); } RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName); this.checkMergedBeanDefinition(mbd, beanName, args); String[] dependsOn = mbd.getDependsOn(); String[] var12; if (dependsOn != null) { var12 = dependsOn; int var13 = dependsOn.length; for(int var14 = 0; var14 < var13; ++var14) { String dep = var12[var14]; if (this.isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } this.registerDependentBean(dep, beanName); try { this.getBean(dep); } catch (NoSuchBeanDefinitionException var31) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31); } } } if (mbd.isSingleton()) { sharedInstance = this.getSingleton(beanName, () -> { try { return this.createBean(beanName, mbd, args); } catch (BeansException var5) { this.destroySingleton(beanName); throw var5; } }); beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { var12 = null; Object prototypeInstance; try { this.beforePrototypeCreation(beanName); prototypeInstance = this.createBean(beanName, mbd, args); } finally { this.afterPrototypeCreation(beanName); } beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException("No scope name defined for bean ��" + beanName + "'"); } Scope scope = (Scope)this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, () -> { this.beforePrototypeCreation(beanName); Object var4; try { var4 = this.createBean(beanName, mbd, args); } finally { this.afterPrototypeCreation(beanName); } return var4; }); beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException var30) { throw new ScopeNotActiveException(beanName, scopeName, var30); } } } catch (BeansException var32) { beanCreation.tag("exception", var32.getClass().toString()); beanCreation.tag("message", String.valueOf(var32.getMessage())); this.cleanupAfterBeanCreationFailure(beanName); throw var32; } finally { beanCreation.end(); } } return this.adaptBeanInstance(name, beanInstance, requiredType); }
This method first converts the Bean Name to eliminate the influence of Factory
Then, an if statement judges the method is singletoncurrentyincreation (beanname), which aims to detect whether the current Bean object exists in the L1 cache. if so, it will be returned directly. if you do not enter the subsequent creation phase
Here's another judgment:
if (this.isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); }
If it is a singleton, it will try to solve the circular dependency problem. If it is a prototype pattern, it will throw an exception directly
Next is an acquisition of the parent class container
BeanFactory parentBeanFactory = this.getParentBeanFactory(); if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) { String nameToLookup = this.originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly); } if (args != null) { return parentBeanFactory.getBean(nameToLookup, args); } if (requiredType != null) { return parentBeanFactory.getBean(nameToLookup, requiredType); } return parentBeanFactory.getBean(nameToLookup); }
Then add a flag bit below to indicate that the object has been created
if (!typeCheckOnly) { this.markBeanAsCreated(beanName); }
This step will determine whether there are dependent bean s. If so, create them first
String[] dependsOn = mbd.getDependsOn(); String[] var12; if (dependsOn != null) { var12 = dependsOn; int var13 = dependsOn.length; for(int var14 = 0; var14 < var13; ++var14) { String dep = var12[var14]; if (this.isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } this.registerDependentBean(dep, beanName); try { this.getBean(dep); } catch (NoSuchBeanDefinitionException var31) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31); } } }
Next, we will determine whether it is a singleton and use the anonymous inner class to pass in a functional interface
if (mbd.isSingleton()) { sharedInstance = this.getSingleton(beanName, () -> { try { return this.createBean(beanName, mbd, args); } catch (BeansException var5) { this.destroySingleton(beanName); throw var5; } }); beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd); }
Will execute the createBean method inside
Click in
There is a core method
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
Click in
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = this.createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } synchronized(mbd.postProcessingLock) { if (!mbd.postProcessed) { try { this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable var17) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17); } mbd.postProcessed = true; } } boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName); if (earlySingletonExposure) { if (this.logger.isTraceEnabled()) { this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } this.addSingletonFactory(beanName, () -> { return this.getEarlyBeanReference(beanName, mbd, bean); }); } Object exposedObject = bean; try { this.populateBean(beanName, mbd, instanceWrapper); exposedObject = this.initializeBean(beanName, exposedObject, mbd); } catch (Throwable var18) { if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) { throw (BeanCreationException)var18; } throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18); } if (earlySingletonExposure) { Object earlySingletonReference = this.getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) { String[] dependentBeans = this.getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length); String[] var12 = dependentBeans; int var13 = dependentBeans.length; for(int var14 = 0; var14 < var13; ++var14) { String dependentBean = var12[var14]; if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } try { this.registerDisposableBeanIfNecessary(beanName, bean, mbd); return exposedObject; } catch (BeanDefinitionValidationException var16) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16); } }
This is the core code for creating beans
First, it executes the following code
this.createBeanInstance(beanName, mbd, args);
It uses reflection to create objects
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]); 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()); } else { Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return this.obtainFromSupplier(instanceSupplier, beanName); } else if (mbd.getFactoryMethodName() != null) { return this.instantiateUsingFactoryMethod(beanName, mbd, args); } else { boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized(mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) { return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd); } else { Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) { ctors = mbd.getPreferredConstructors(); return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd); } else { return this.autowireConstructor(beanName, mbd, ctors, args); } } } } }
The core method is
this.instantiateBean(beanName, mbd);
Click in
Will return
return this.getInstantiationStrategy().instantiate(mbd, beanName, this);
Click instance
Will return
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
Click in
He returned
return ctor.newInstance(argsWithDefaultValues);
We should be familiar with this. Yes, it is to instantiate objects using reflection
OK, let's return to doCreateBean
Its next executive force is one
if (earlySingletonExposure) { if (this.logger.isTraceEnabled()) { this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } this.addSingletonFactory(beanName, () -> { return this.getEarlyBeanReference(beanName, mbd, bean); }); }
Expose in advance, try to solve the circular dependency problem, and put the object into the L3 cache
Proceed below
this.populateBean(beanName, mbd, instanceWrapper);
Populate the properties of the Bean
We just instantiated the Bean, but the attribute values are empty. This method is to fill in its attribute values
The following method
this.initializeBean(beanName, exposedObject, mbd);
Click in to set the Aware interface properties
this.invokeAwareMethods(beanName, bean);
Then the before method of BPP is executed
this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
Then execute the init method method
this.invokeInitMethods(beanName, wrappedBean, mbd);
Finally, the after method of BPP is executed
this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
ok, in this way, the bean is created as a whole. This blog is about the general process of Spring, or many details are omitted. I will explain it in detail in the blog later