Spring什么时候实例化Bean的？

今天忽然想到一个问题，Spring是什么时候实例化Bean的？

1、是spring容器启动的时候？

2、还是第一次用到bean的时候实例化？

于是决定看一下源码

N年以前，spring还没有现在这么强大的时候，我们是如何使用spring的呢？使用XML文件配置，如下：

public class SchoolServiceImpl {

    public String getTimeStr(){
      return   LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:MM:ss"));
    }

    public String getInStr(String str){
        return str;
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="schoolService" class="com.learn.spring.spring01.service.SchoolServiceImpl">

    </bean>
</beans>

将SchoolServiceImpl注册进spring，让spring管理。这步是怎么完成的呢？入下：

public static void main(String[] args) {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("schoolService.xml");

		SchoolServiceImpl service = context.getBean("schoolService", SchoolServiceImpl.class);

		System.out.println(service.getTimeStr());
	}

开始debug

主要步骤：

1、创建beanFactory的实例DefaultListableBeanFactory，这个对象管理所有bean，为什么说它管理着所有bean对象呢，下面会说到

refresh()->obtainFreshBeanFactory->refreshBeanFactory->DefaultListableBeanFactory beanFactory = this.createBeanFactory();

2、根据路径读取XML文件、并解析xml文件，注册bean

loadBeanDefinitions(beanFactory)->新建XmlBeanDefinitionReader对象，负责xml的读取->loadBeanDefinitions(beanDefinitionReader)->loadBeanDefinitions(configLocations),根据上面代码中指定的XML文件位置，去相应读取，如果是多个xml文件，则是循环解析->XmlBeanDefinitionReader中进一步处理，将读到的Resource对象进一步解析->doLoadBeanDefinitions方法完成两件事，将xml解析为Document对象，注册bean->DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions.parseBeanDefinitions的方法解析xml每个bean标签、import标签等，其中的parseDefaultElement如下：
 

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, "import")) {
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
            this.doRegisterBeanDefinitions(ele);
        }

    }

->processBeanDefinition方法将每个bean标签解析为BeanDefinitionHolder对象，这个对象里面已经包含了bean的抽象定义BeanDefinition对象，这个对象比较关键，它包含的这个bean是单例还是多例、是不是懒加载等信息。因为以后的bean的实例化都是在这里拿到BeanDefinition对象，去实例化的。registerBeanDefinition注册->DefaultListableBeanFactory下的registerBeanDefinition方法会判断当前是否已经存在了该bean的BeanDefinition对象，判断的依据就是beanDefinitionMap能不能找到，如果没有，则把这个beanName和BeanDefinition放到这个map中、和beanDefinitionNames这个list中

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    @Nullable
    private static Class<?> javaxInjectProviderClass;
    private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories;
    @Nullable
    private String serializationId;
    private boolean allowBeanDefinitionOverriding = true;
    private boolean allowEagerClassLoading = true;
    @Nullable
    private Comparator<Object> dependencyComparator;
    private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
    private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap(16);
// 放到这个map里缓存起来
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);
    private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap(256);
    private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap(64);
    private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap(64);
    private volatile List<String> beanDefinitionNames = new ArrayList(256);
    private volatile Set<String> manualSingletonNames = new LinkedHashSet(16);
    @Nullable
    private volatile String[] frozenBeanDefinitionNames;
    private volatile boolean configurationFrozen = false;

可以看到，每一个bean注册完成之后，对应的BeanDefinition都会放到DefaultListableBeanFactory中的beanDefinitonMap中,所以可以说这个beanFactory的对象管理着所有bean

3、创建、填充bean属性、实例化Bean

实例化一个对象的基本过程是：

// 1、创建SchoolEntity类的实例，entity对象
SchoolEntity entity = new SchoolEntity();

// 2、给entity对象填充属性
entity.setName("jack");
entity.setAge(12);

// 3、使用entity对象做一些事情
Use entity...

System.out.println(entity.getName);

spring里的流程如下：

在第一步的obtainFreshBeanFactory方法执行完毕之后，最终会执行finishBeanFactoryInitialization(beanFactory)->preInstantiateSingletons->this.getBean(这一步会取出beanDefinitionNames中所有beanName进行循环获取bean

)->doGetBean->this.getSingleton(beanName),此时这个bean还不存在，则创建这个bean->

this.createBean->this.doCreateBean->创建好bean之后，将这个bean放到DefaultSingletonBeanRegistry的singletonObjects这个map中

try {
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException var16) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        throw var16;
                    }
                } catch (BeanCreationException var17) {
                    BeanCreationException ex = var17;
                    if (recordSuppressedExceptions) {
                        Iterator var8 = this.suppressedExceptions.iterator();

                        while(var8.hasNext()) {
                            Exception suppressedException = (Exception)var8.next();
                            ex.addRelatedCause(suppressedException);
                        }
                    }

                    throw ex;
                } finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }

                    this.afterSingletonCreation(beanName);
                }
// 添加进map中
                if (newSingleton) {
                    this.addSingleton(beanName, singletonObject);
                }

this.doCreateBean(创建bean对象)->this.populateBean(填充bean的属性)->this.initializeBean实例化bean。

其实以上步骤，官方文档都已经给出了很简洁有力的文档，并且官方建议要尽早的注册。

对于单例，如果没有配置lazy-init，那么spring容器启动的时候，就会提前创建，而对于多例，则是用到的时候才创建

UsefulLink:

1. Spring官方文档