web环境下Spring的启动过程和源码分析

蔚落 2022-05-17 01:55 111阅读 0赞

# web环境下Spring的启动过程 #

可以先了解一下《[Java Web项目启动加载顺序][Java Web]》

web.xml 节点加载顺序context-param -> listener -> filter -> servlet

1.web.xml中配置Spring的监听器ContextLoaderListener

<listener> 
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 
    </listener>

2.web容器(如tomcat)初始化ServletContext的过程中会调用触发一个ServletContextEvent，这个事件会触发监听器ContextLoaderListener的contextInitialized方法，开始Spring上下文的初始化过程

/**
     * Initialize the root web application context.
     */
    @Override
    public void contextInitialized(ServletContextEvent event) {
       initWebApplicationContext(event.getServletContext());
    }

3.生成一个空的WebApplicationContext对象

![70][]

因为WebApplicationContext是一个接口，那到底是生成哪个实现类的实例呢

a.可以在在web.xml中配置

<context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.XmlWebApplicationContext</param-value>
    </context-param>

b.如果要是没在web.xml中配置，则默认生成的就是XmlWebApplicationContext的实例

![70 1][]

设置当前webApplicationContext的parent上下文，一般为null，除非在web.xml中配置。

configureAndRefreshWebApplicationContext(cwac, servletContext)为当前webApplicationContext设置id，值可以在web.xml中配置，也可以默认生成;还将当前servletContext作为属性值设置进当前webApplicationContext；这个方法最后会refresh上下文。

5.调用AbstractApplicationContext的refresh()方法刷新上下文是一个关键性的地方，会发生很多关键的事情，将进行重点讲解，详解请看下文。

6.webApplicationContext配置并刷新完后，将其作为属性塞进servletContext，再做些其它操作后就完成了Spring的Root WebAplication的初始化，这个时候你就可以享受Spring Ioc和AOP带来的便捷了。

7.如果使用了SpringMVC，需要在web.xml配置一个DispatcherServlet作为请求分发控制。

<servlet>
        <servlet-name>maijia</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <description>加载/WEB-INF/spring/目录下的所有XML作为Spring MVC的配置文件</description>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:/spring/spring-web.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

因为DispatcherServlet实现了ApplicationContextAware接口，因此之前初始化好的上下文Root WebApplication会被注入到DispatcherServlet作为即将创建的MVC自己的上下文webApplication的parent，这个类由web容器运行，和普通的Servlety有相同的生命周期。init的时候读取配置的参数contextConfigLocation，MVC上下文的servletContext也会被设置，和之前webApplication中设置的servletContext是同一个哦！wac.setNamespace(getNamespace())设置命名空间，数据来自Spring的xml配置，用来解析xml内容的。wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()))还会注册一个监听器。最终也会调用AbstractApplicationContext.refresh()方法，和Spring Root WebApplication做的是相同的事情，初始化当前上下文。

值得注意的是，IoC容器和上下文的初始化一般不包含bean依赖注入的实现。一般而言，依赖注入发生在应用第一次想容器getBean索取bean时。但有一个例外值得注意，在使用IoC容器时有一个预实例化的配置，这个预实例化是可以配置的，具体可以在bean定义信息的lazyinit属性来设定；有了这个预实例化的特性，用户可以对容器初始化过程中作一个微小的控制；从而改变这个被设置lazyinit属性的bean的依赖注入的发生，使得这个bean的依赖注入在IoC容器初始化时就预先完成了。

实际开发过程中，一般都不手动给bean设置scope和lazyinit属性，默认scope=singleton，lazyinit=false，所以大多数我们要用到的bean在在IoC容器初始化时就预先完成了。

--------------------

现在开始重点讲解AbstractApplicationContext的refresh()方法

@Override
    public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
          // Prepare this context for refreshing.
          prepareRefresh();
    
          // Tell the subclass to refresh the internal bean factory.
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
          // Prepare the bean factory for use in this context.
          prepareBeanFactory(beanFactory);
    
          try {
             // Allows post-processing of the bean factory in context subclasses.
             postProcessBeanFactory(beanFactory);
    
             // Invoke factory processors registered as beans in the context.
             invokeBeanFactoryPostProcessors(beanFactory);
    
             // Register bean processors that intercept bean creation.
             registerBeanPostProcessors(beanFactory);
    
             // Initialize message source for this context.
             initMessageSource();
    
             // Initialize event multicaster for this context.
             initApplicationEventMulticaster();
    
             // Initialize other special beans in specific context subclasses.
             onRefresh();
    
             // Check for listener beans and register them.
             registerListeners();
    
             // Instantiate all remaining (non-lazy-init) singletons.
             finishBeanFactoryInitialization(beanFactory);
    
             // Last step: publish corresponding event.
             finishRefresh();
          }
    
          catch (BeansException ex) {
             // Destroy already created singletons to avoid dangling resources.
             destroyBeans();
    
             // Reset 'active' flag.
             cancelRefresh(ex);
    
             // Propagate exception to caller.
             throw ex;
          }
       }
    }

1.**prepareRefresh();**

① 这个方法设置context的启动日期。

② 设置context当前的状态，是活动状态还是关闭状态。

③ 初始化context environment（上下文环境）中的占位符属性来源。

④ 验证所有必需的属性。

2.**ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();**

让这个类（AbstractApplicationContext）的子类刷新内部bean工厂。实际上就是重新创建一个bean工厂。

在子类中启动refreshBeanFactory()的方法

@Override
    	protected final void refreshBeanFactory() throws BeansException {
    		if (hasBeanFactory()) {
    			destroyBeans();
    			closeBeanFactory();
    		}
    		try {
                //创建IoC容器，这里使用的是DefaultListableBeanFactory
    			DefaultListableBeanFactory beanFactory = createBeanFactory();
    			beanFactory.setSerializationId(getId());
    			customizeBeanFactory(beanFactory);
                //启动对BeanDefinition的载入，非常重要的一步，将bean的定义信息加载进beanFactory
    			loadBeanDefinitions(beanFactory);
    			synchronized (this.beanFactoryMonitor) {
    				this.beanFactory = beanFactory;
    			}
    		}
    		catch (IOException ex) {
    			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    		}
    	}

loadBeanDefinitions(beanFactory) 将bean的定义信息以BeanDefinition的结构加载进beanFactory。

3.**prepareBeanFactory(beanFactory) ；**上一步已经把工厂建好了，但是还不能投入使用，因为工厂里什么都没有，还需要配置一些东西。配置这个工厂的标准环境，比如context的类加载器和后处理器。

4.**postProcessBeanFactory(beanFactory);** 上面对bean工厂进行了许多配置，现在需要对bean工厂进行一些处理。

① 添加一个ServletContextAwareProcessor到bean工厂中。

② 在bean工厂自动装配的时候忽略一些接口。如：ServletContextAware、ServletConfigAware

③ 注册WEB应用特定的域（scope）到bean工厂中，以便WebApplicationContext可以使用它们。比如"request", "session", "globalSession", "application"，

④注册WEB应用特定的Environment bean到bean工厂中，以便WebApplicationContext可以使用它们。如："contextParameters", "contextAttributes"

5.**invokeBeanFactoryPostProcessors(beanFactory);**这一步也是对bean工厂进行一些处理。这一步主要是**调用所有的bean工厂处理器（BeanFactoryPostProcessor）对bean工厂进行一些处理**。这个方法必须在所有的singleton初始化之前调用。

6.**registerBeanPostProcessors(beanFactory);**注册用来拦截bean创建的BeanPostProcessor bean.这个方法需要在所有的application bean初始化之前调用。把这个注册的任务委托给了**PostProcessorRegistrationDelegate**来完成。

7.**initMessageSource();**初始化MessageSource接口的一个实现类。这个接口提供了消息处理功能。主要用于国际化/i18n。

8.**initApplicationEventMulticaster();**为这个context初始化一个事件广播器（**ApplicationEventMulticaster**）

9.**onRefresh()**;在AbstractApplicationContext的子类中初始化其他特殊的bean。其实就是初始化ThemeSource接口的实例。这个方法需要在所有单例bean初始化之前调用。

10.**registerListeners()**; 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean，这些监听器是注册到ApplicationEventMulticaster中的。这不会影响到其它监听器bean。在注册完以后，还会将其前期的事件发布给相匹配的监听器。

11. **finishBeanFactoryInitialization(beanFactory)**;完成bean工厂的初始化工作。这一步非常复杂，也非常重要，涉及到了bean的创建。第2步中只是完成了BeanDefinition的定义、解析、处理、注册。但是还没有初始化bean实例。这一步**将初始化所有非懒加载的单例bean**（即所有lazyinit=false且socpe=singleton的bean），继续在下文进行详解。

12.**finishRefresh()**;完成context的刷新。主要是调用LifecycleProcessor的onRefresh()方法，并且发布事件（ContextRefreshedEvent）。

--------------------

详解finishBeanFactoryInitialization(beanFactory)

/**
    	 * Finish the initialization of this context's bean factory,
    	 * initializing all remaining singleton beans.
    	 */
    	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    		// Initialize conversion service for this context.
    		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
    			beanFactory.setConversionService(
    					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    		}
    
    		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) {
    			getBean(weaverAwareName);
    		}
    
    		// Stop using the temporary ClassLoader for type matching.
    		beanFactory.setTempClassLoader(null);
    
    		// Allow for caching all bean definition metadata, not expecting further changes.
    		beanFactory.freezeConfiguration();
    
    		// Instantiate all remaining (non-lazy-init) singletons.
    		beanFactory.preInstantiateSingletons();
    	}

这个方法我们只需要关注最后一行即可，也就是beanFactory.preInstantiateSingletons();

DefaultListableBeanFactory

public void preInstantiateSingletons() throws BeansException {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Pre-instantiating singletons in " + this);
            }
    
            //获取解析过的所有beanNames
            List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    
            // Trigger initialization of all non-lazy singleton beans...
            for (String beanName : beanNames) {
                //获取对应的RootBeanDefinition，其内部就含有BeanDefinition
                RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
                //非抽象、单例模式、非lazy-init，满足以上条件的进入到实例化
                if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                    //对FactoryBean的类型实例化
                    if (isFactoryBean(beanName)) {
                        final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                                @Override
                                public Boolean run() {
                                    return ((SmartFactoryBean<?>) factory).isEagerInit();
                                }
                            }, getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                    else {
                        //getBean方法主要进行了对相应的beanName的实例化
                        getBean(beanName);
                    }
                }
            }
            // Trigger post-initialization callback for all applicable beans...
            for (String beanName : beanNames) {
                //获取上述的对应的实例化对象，对SmartInitializingSingleton的实现类进行afterSingletonInstantiated()方法调用
                Object singletonInstance = getSingleton(beanName);
                if (singletonInstance instanceof SmartInitializingSingleton) {
                    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                    if (System.getSecurityManager() != null) {
                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                            @Override
                            public Object run() {
                                smartSingleton.afterSingletonsInstantiated();
                                return null;
                            }
                        }, getAccessControlContext());
                    }
                    else {
                                            //会调用InitializingBean的afterPropertiesSet()方法
                        smartSingleton.afterSingletonsInstantiated();
                    }
                }
            }

由此观之，此过程主要实现所有残留的beanNames能被实例化，这里的实例化指的是对beanFactory中beanName对应的RootBeanDefinition中的beanClass进行准确的实例化，包括属性以及方法复用等等，主要是通过`DefaultListableBeanFactory#getBean`方法。

--------------------

getBean方法详解

1-1.Spring在初始化bean的时候会调用beanFactory的getBean方法

1-2.getBean调用doGetBean方法，先从bean单例缓存中取，如果取得到则直接返回(如果bean是FactoryBean，则调用其getObject方法返回)

2. 如果不存在则先从beanFactory中找到bean的BeanDefinition，如果当前的beanFactory找不到对应的beanDefinition，则到父beanFactory找，如果父beanFactory也找不到，则顺着父链往上找。

3.取当前bean的所有依赖bean，这样会触发getBean的递归调用，知道取到一个没有任何依赖的bean为止。

String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
       for (String dependsOnBean : dependsOn) {
          if (isDependent(beanName, dependsOnBean)) {
             throw new BeanCreationException("Circular depends-on relationship between '" +
                   beanName + "' and '" + dependsOnBean + "'");
          }
          registerDependentBean(dependsOnBean, beanName);
          getBean(dependsOnBean);
       }
    }

4.获取或生成bean的实例

if (mbd.isSingleton()) {
        sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
                try {
                    return createBean(beanName, mbd, args);
                }
                catch (BeansException ex) {
                    // Explicitly remove instance from singleton cache: It might have been put there
                    // eagerly by the creation process, to allow for circular reference resolution.
                    // Also remove any beans that received a temporary reference to the bean.
                    destroySingleton(beanName);
                    throw ex;
                }
            }
        });
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
    
    else if (mbd.isPrototype()) {
        // It's a prototype -> create a new instance.
        Object prototypeInstance = null;
        try {
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
        }
        finally {
            afterPrototypeCreation(beanName);
        }
        bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    }
    
    else {
        String scopeName = mbd.getScope();
        final Scope scope = this.scopes.get(scopeName);
        if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
        }
        try {
            Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                @Override
                public Object getObject() throws BeansException {
                    beforePrototypeCreation(beanName);
                    try {
                        return createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                }
            });
            bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
        }
        catch (IllegalStateException ex) {
            throw new BeanCreationException(beanName,
                    "Scope '" + scopeName + "' is not active for the current thread; " +
                            "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                    ex);
        }
    }

4-1. 如果作用域是singleton，则会先从单例缓存中找，找得到就直接返回，找不到就调用createBean方法创建一个实例

4-2.如果作用域是prototype，则直接createBean方法创建一个新的实例。

4-3.如果作用域是request、session、global session,则去beanFactory的scopes里去检索相应的bean，有则取值，无则生成并塞入相应的scope中。

bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

3种情况，都会判断这个bean是不是FactoryBean，如果不是直接返回原来的，如果是则调用其getObject方法返回一个实例。

--------------------

上文在创建新的bean实例时会调用AbstractAutowireCapableBeanFactory的createBean方法

@Override
    	protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    			throws BeanCreationException {
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Creating instance of bean '" + beanName + "'");
    		}
    		// Make sure bean class is actually resolved at this point.
            //判断需要创建的bean是否可以实例化，这个类是否可以通过类加载器来载入
    		resolveBeanClass(mbd, beanName);
    
    		// Prepare method overrides.
    		try {
    			mbd.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
    					beanName, "Validation of method overrides failed", ex);
    		}
    
    		try {
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
                //如果bean配置了PostProcessor，那么返回的是一个proxy
    			Object bean = resolveBeforeInstantiation(beanName, mbd);
    			if (bean != null) {
    				return bean;
    			}
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"BeanPostProcessor before instantiation of bean failed", ex);
    		}
            //创建bean实例
    		Object beanInstance = doCreateBean(beanName, mbd, args);
    		if (logger.isDebugEnabled()) {
    			logger.debug("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	}

1.createBean 会先调用resolveBeforeInstantiation方法尝试创建代理，这个方法详细介绍请看下文

2.如果3-1没有返回代理，createBean最后调用doCreateBean创建bean实例，这个方法详解请看下文

3-1.doCreateBean方法会先调用AbstractAutowireCapableBeanFactory的createBeanInstance方法生成一个简单的bean对象

3-2.doCreateBean方法再调用populateBean(beanName, mbd, instanceWrapper);给简单bean对象填充property values（字段属性值）

4.populateBean执行到最后会调用applyPropertyValues给bean填充属性

5. doCreateBean在调用完populateBean方法后，调用 initializeBean方法

populateBean(beanName, mbd, instanceWrapper);
    if (exposedObject != null) {
       exposedObject = initializeBean(beanName, exposedObject, mbd);
    }

AbstractAutowireCapableBeanFactory.initializeBean

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    		if (System.getSecurityManager() != null) {
    			AccessController.doPrivileged(new PrivilegedAction<Object>() {
    				@Override
    				public Object run() {
    					invokeAwareMethods(beanName, bean);
    					return null;
    				}
    			}, getAccessControlContext());
    		}
    		else {
                //如果bean实现了Aware接口,则set需要aware的东西
    			invokeAwareMethods(beanName, bean);
    		}
    
    		Object wrappedBean = bean;
    		if (mbd == null || !mbd.isSynthetic()) {
                //执行bean初始化前置processor
    			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    		}
    
    		try {
                //这里就开始执行initMethod 和 afterPropertiesSet方法
    			invokeInitMethods(beanName, wrappedBean, mbd);
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(
    					(mbd != null ? mbd.getResourceDescription() : null),
    					beanName, "Invocation of init method failed", ex);
    		}
    
    		if (mbd == null || !mbd.isSynthetic()) {
                //执行bean初始化后置processor
    			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    		}
    		return wrappedBean;
    	}

如果bean实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware，则调用bean相应的set方法设值

private void invokeAwareMethods(final String beanName, final Object bean) {
    		if (bean instanceof Aware) {
    			if (bean instanceof BeanNameAware) {
    				((BeanNameAware) bean).setBeanName(beanName);
    			}
    			if (bean instanceof BeanClassLoaderAware) {
    				((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
    			}
    			if (bean instanceof BeanFactoryAware) {
    				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
    			}
    		}
    	}

initializeBean中比较重要的一步applyBeanPostProcessorsBeforeInitialization和applyBeanPostProcessorsAfterInitialization

最后bean的实例就初始化完成了

--------------------

resolveBeforeInstantiation方法只是为提前生成代理提供可能而已，需要beanFacotry注册了实现InstantiationAwareBeanPostProcessor接口的processor。

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
       Object bean = null;
       if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
          // Make sure bean class is actually resolved at this point.
          if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
             bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);//执行Class初始化前的操作
             if (bean != null) {
                bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);//执行bean初始化后的操作（如schedule定时、bean作为applicationContext的监听器、若满足aop则生成代理类 等等）
          }
          mbd.beforeInstantiationResolved = (bean != null);
       }
       return bean;
    }

applyBeanPostProcessorsAfterInitialization方法，这里就是即将发生AOP的地方，关键性的入口，如果这个bean需要aop，这个方法执行后会返回一个代理类。

--------------------

AbstractAutowireCapableBeanFactory的createBeanInstance方法

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		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());
    		}
    
    		if (mbd.getFactoryMethodName() != null)  {
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) {
    			synchronized (mbd.constructorArgumentLock) {
    				if (mbd.resolvedConstructorOrFactoryMethod != null) {
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) {
                //bean定义信息autowire=constructor时
    			if (autowireNecessary) {
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else {
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Need to determine the constructor...
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null ||
    				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		return instantiateBean(beanName, mbd);
    	}

重点关注最后一行instantiateBean(beanName, mbd);

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    		try {
    			Object beanInstance;
    			final BeanFactory parent = this;
    			if (System.getSecurityManager() != null) {
    				beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
    					@Override
    					public Object run() {
    						return getInstantiationStrategy().instantiate(mbd, beanName, parent);
    					}
    				}, getAccessControlContext());
    			}
    			else {
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}

关注beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

来看看SimpleInstantiationStrategy

public class SimpleInstantiationStrategy implements InstantiationStrategy {
     
        // FactoryMethod的ThreadLocal对象，线程所有的变量
        private static final ThreadLocal<Method> currentlyInvokedFactoryMethod = new ThreadLocal<Method>();
     
        // 返回当前线程所有的FactoryMethod变量值
        public static Method getCurrentlyInvokedFactoryMethod() {
            return currentlyInvokedFactoryMethod.get();
        }
     
        // 第一种实例化方法，实现部分，部分抽象
        @Override
        public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
            // bd对象定义里，是否包含MethodOverride列表；spring有两个标签参数会产生MethodOverrides ，分别是 lookup-method,replaced-method 
            // 没有MethodOverride对象，可以直接实例化
            if (bd.getMethodOverrides().isEmpty()) {
                // 实例化对象的构造方法
                Constructor<?> constructorToUse;
                // 锁定对象，使获得实例化构造方法线程安全
                synchronized (bd.constructorArgumentLock) {
                    // 查看bd对象里是否含有
                    constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
                    // 没有就生成
                    if (constructorToUse == null) {
                        final Class<?> clazz = bd.getBeanClass();
                        if (clazz.isInterface()) {
                            throw new BeanInstantiationException(clazz, "Specified class is an interface");
                        }
                        try {
                            if (System.getSecurityManager() != null) {
                                constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                                    @Override
                                    public Constructor<?> run() throws Exception {
                                        return clazz.getDeclaredConstructor((Class[]) null);
                                    }
                                });
                            }
                            else {
                                constructorToUse =    clazz.getDeclaredConstructor((Class[]) null);
                            }
                            // 生成成功后，赋值给bd对象，后面使用
                            bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                        }
                        catch (Exception ex) {
                            throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                        }
                    }
                }
                // 反射生成对象
                return BeanUtils.instantiateClass(constructorToUse);
            }
            else {
                // 有MethodOverride对象，使用cglib实现实例化
                return instantiateWithMethodInjection(bd, beanName, owner);
            }
        }
     
        // 第一种实例化方法的抽象部分
        protected Object instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner) {
            throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
        }
     
        // 第二种实例化方法，实现部分，抽象部分
        @Override
        public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
                final Constructor<?> ctor, Object... args) {
            // 查看bd对象是否有MethodOverride对象
            // 没有MethodOverride，则直接实例化对象
            if (bd.getMethodOverrides().isEmpty()) {
                if (System.getSecurityManager() != null) {
                    // use own privileged to change accessibility (when security is on)
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            ReflectionUtils.makeAccessible(ctor);
                            return null;
                        }
                    });
                }
                // 反射实例化对象
                return BeanUtils.instantiateClass(ctor, args);
            }
            else {
                // 有MethodOverride，使用cglib实现实例化
                return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
            }
        }
     
        // 第二种实例化方法的抽象部分
        protected Object instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner,
                Constructor<?> ctor, Object... args) {
            throw new UnsupportedOperationException("Method Injection not supported in SimpleInstantiationStrategy");
        }
     
        // 第三种实例化方法，全部实现
        @Override
        public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner,
                Object factoryBean, final Method factoryMethod, Object... args) {
     
            try {
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            ReflectionUtils.makeAccessible(factoryMethod);
                            return null;
                        }
                    });
                }
                else {
                    ReflectionUtils.makeAccessible(factoryMethod);
                }
     
                // currentlyInvokedFactoryMethod，这块暂时还没看到在哪个地方用到了
                // 先取出原有的 Method
                Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
                try {
                    // 设置当前的Method
                    currentlyInvokedFactoryMethod.set(factoryMethod);
                    // 使用factoryMethod实例化对象
                    return factoryMethod.invoke(factoryBean, args);
                }
                finally {
                    // 实例化完成，恢复现场
                    if (priorInvokedFactoryMethod != null) {
                        currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
                    }
                    else {
                        currentlyInvokedFactoryMethod.remove();
                    }
                }
            }
            catch (IllegalArgumentException ex) {
                throw new BeanInstantiationException(factoryMethod.getReturnType(),
                        "Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
                        "args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
            }
            catch (IllegalAccessException ex) {
                throw new BeanInstantiationException(factoryMethod.getReturnType(),
                        "Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
            }
            catch (InvocationTargetException ex) {
                String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
                if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
                        ((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) {
                    msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
                            "declaring the factory method as static for independence from its containing instance. " + msg;
                }
                throw new BeanInstantiationException(factoryMethod.getReturnType(), msg, ex.getTargetException());
            }
        }
     
    }

大多数情况，bean实例化都是用反射实现的，少数情况会用cglib实现

[Java Web]: https://blog.csdn.net/pange1991/article/details/48598569
[70]: /images/20220517/dc63f6a9718844c9aadfeadc83c1c2e1.png
[70 1]: /images/20220517/fa85dd6d4a1f453ba7dac5ffefbb73f1.png