Spring 3.0之前主要基于xml配置，它的启动流程中，做了些什么？
这里基于Spring5.0.8版本：对ClassPathXmlApplicationContext进行讲解，同时没有集成spring-web包，所以启动过程跳过servlet实现：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");application.xml中的简单配置：
<bean id="user" class="com.ytq.cloud.source.entity.User">
<property name="name" value="zhangsan" />
<property name="person" ref="person" />
</bean>
<bean id="person" class="com.ytq.cloud.source.entity.Person">
<property name="name" value="lisi"/>
</bean>
application.xml 只配置了一个Bean对象，以及它的属性name在创建ClassPathXmlApplicationContext对象时，具体会做如下几件事情：
- 确定application.xml的位置，默认去项目路径下找：classpath:/applicaiton.xml
- 通过读取器(xxxReader)读取application.xml文件,将它读取到一个Resource对象中，Resource对象会保存application.xml文件的字节输入流(inputStream);
- xml文件在java中两种主要的解析方式是DOM解析，一个是SAX解析,Spring 中采用了DOM解析，来解析application.xml文件，将application.xml中的每一个解析成AbstractBeanDefinition对象，AbstractBeanDefinition对象中包括Bean的属性，作用域，是否抽象，是否为懒加载等等属性信息；最后将解析的BeanDefinition对象保存到Map对象中（DefaultListableBeanFactory#registerBeanDefinition() 在这个方法中完成）
- 将我们解析的BeanDefinition对象取出，通过反射的方式对单例模式的BeanDefinition进行实例化，并保存在DefaultSingletonBeanRegistry对象的Map容易中(singletonObjects);
这里是启动的主线，中间Spring也做了大量的处理如：BeanFactory的创建于修饰，国际化处理，事件处理（ApplicationEvent）,清除缓存等等；
1：资源文件读取与解析
- 从ClassPathXmlApplicationContext对象的构造方法进入：
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
// 会在父类中创建一个资源解析器ResourcePatternResolver（可以理解为先买把刀，为劈柴做准备），它的实现类new PathMatchingResourcePatternResolver(this);
super(parent);
// 解析路径并保存到数组中
setConfigLocations(configLocations);
if (refresh) {
// 启动过程的工作基本在refresh()方法中完成；
refresh();
}}- 进入refresh()方法，他的实现在AbstractApplicationContext类中，
// 读取application.xml文件，并把它解析成BeanDefinition对象，然后注册到Map容器中；
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 实例化剩余单例模式(非懒加载的)Bean对象
finishBeanFactoryInitialization(beanFactory);- 进入obtainFreshBeanFactory()->refreshBeanFactory()
// 创建BeanFactory子类实现DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
//加载BeanDefinition
loadBeanDefinitions(beanFactory);进入方法->AbstractXmlApplicationContext#loadBeanDefinitions
方法中代码实现：
reader.loadBeanDefinitions(configLocations); reader就是读取器，configxxx就是配置文件路径；
转换为：XmlBeanDefinitionReader.loadBeanDefinitions(new String[]{"application.xml"});
XmlBeanDefinitionReader是Spring读取配置文件的一个工具类；
进行进入方法，这里有好几层方法，还是重载的loadBeanDefinitions
{
这个方法就是讲配置文件读取到Resource资源对象中，并保存着配置文件字节输入流inputstream
其中resourceLoader资源加载器，就是ClassPathXmlApplicationContext构造方法中创建的PathMatchingResourcePatternResolver对象；然后在调用DefaultResourceLoader的getResource方法；
Resource resource = resourceLoader.getResource(location);
// XmlBeanDefinitionReader对Resource的读取与解析
int count = loadBeanDefinitions(resource);
}- 进入XmlBeanDefinitionReader对象的loadBeanDefinitions方法，
// 对流进行编码与解码处理
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 读取流文件；
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
进入doLoadBeanDefinitions方法，这里就是通过DOM方法，对xml流进行解析的过程
Document doc = doLoadDocument(inputSource, resource);
// 通过doc读取里面的每一个element元素,继续进入方法；
int count = registerBeanDefinitions(doc, resource);
进入到->DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions
进入方法->parseBeanDefinitions(root, this.delegate);- 在parseBeanDefinitions解析方法中
这里的root就是document根节点，获取它所有node节点进行遍历，
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
// 解析element元素节点，如果他是bean开头，就解析他的id，class，name等属性，封装到AbstractBeanDefinition对象中；
parseDefaultElement(ele, delegate);
}}}- BeanDefinition的解析构成就此完成，最后将解析生成的AbstractBeanDefinition注册到DefaultListableBeanFactory（registerBeanDefinition方法实现注册过程）对象的Map容器中,key就是id定义名称，value就是AbstractBeanDefinition对象，注册的过程中，会判断beanName在同一个上下文中的唯一性，如果beanName重复，注册失败；
2.单例Bean的实例化
- 进入AbstractApplicationContext的refresh()方法的finishBeanFactoryInitialization(beanFactory)方法：
// 初始化所有非延迟加载的Bean实例，这里的BeanFactory就是上传创建的DefaultListableBeanFactory对象；
进入方法->beanFactory.preInstantiateSingletons();
{
//这里就是取上面解析到的所有BeanDefinition的name名称，进行遍历
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
...
// 我们自己定义的普通bean，走这里实例化过程
getBean(beanName);
}}}
进入方法-->AbstractBeanFacotory.doGetBean()方法
{
// 如果是单例模式就创建单例，如果是原型模式就创建原型模式实例，
这里只复制了创建单例代码，
if (mbd.isSingleton()) {
return createBean(beanName, mbd, args);
}}
进入createBean方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);- 进入到AbstractAutowireCapableBeanFactory的doCreateBean方法，执行对象的创建于属性依赖注入
// Bean对象的创建，根据beanName获取Class对象，通过Clazz.newInstance(args)创建bean对象；
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
try {
// 真正的依赖注入处理方法，在依赖注入时，同时会建立对象之间的依赖关系如:(A依赖B,C等)，将这种依赖关系保存在Map容器中，key是beanName，Value是set集合依赖的所有对象；
populateBean(beanName, mbd, instanceWrapper);
// Bean初始化方法处理(@PostConstruct注解或者@Bean(init-method="xxx")),同时在初始化之前与之后做些功能扩展,初始化方法会在这里处理；
exposedObject = initializeBean(beanName, exposedObject, mbd);
}- populateBean(beanName, mbd, instanceWrapper);依赖注入构成实现：
获取bean的所有属性id与配置的属性值value，同时会解析value值的类型，
BeanDefinitionValueResolver对象的resolveValueIfNecessary(pv, originalValue)方法就是判断value值是什么类型的值，value可能set集合，list，map，string，具体对象；
spring提供了强大的类型转换器，将value转换成具体的类型，如果value引用了一个person对象
1. 会先到Map容器中去获取person对象BeanFactory.getBean("person")如果person存在，通过反射调用User的setPerson(Person person)方法，进行设值。setter方法注入
ReflectionUtils.makeAccessible(writeMethod);
writeMethod.invoke(getWrappedInstance(), value);
2. 如果person在IoC容器中不存在，会调用BeanFactory.createBean("person")方法去创建Person对象，然后通过反射调用setPerson()方法，进行注入；
具体实现在BeanWrapperImpl的setValue()方法；
Bean创建完成之后，DefaultSingletonBeanRegistry对象getSingleton方法中，把创建的Bean添加到Map容器中（singletonObjects），这里就是IOC容器管理所有单例Bean的地方；- 属性注入完成之后，调用initializeBean()初始化方法：
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
...
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 初始之前通过BeanPostProcessor对Bean做修饰处理
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// 初始化方法执行，@PostConstruct注解方法或者@Bean(init-method="initxxx")方法
invokeInitMethods(beanName, wrappedBean, mbd);
if (mbd == null || !mbd.isSynthetic()) {
// 初始之后通过BeanPostProcessor对Bean做修饰处理，这里在Spring注解Annotation启动过程中起了很重要的作用，后面将Spring Annotation启动会说
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}Spring IoC容器的初始化过程基本就完成了；
它包括配置文件读取载入，解析，Bean创建，Bean属性注入几个流程；
后面在完善！！！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
