【spring源码第一天】概述流程
注：全文中的英文注释来源源码，因为自己翻译不靠谱，所以给出原文
对于Java来说还有很多需要学习的，初识源码还有很多错误，忘指正！！！
第一天总结也就是下面这个图，Bean生命周期流程图：
1. 思考
1.1 什么是spirng?
一种框架，一种生态。在这个生态下诞生了很多产品，boot,cloud等等，因此具有很强的扩展性。
1.2 spring的核心？
IOC 控制反转，这是一种思想，将创建对象的过程交给spring容器统一管理。在spring的具体实现是DI(依赖注入)； AOP 面向切面编程， 基于动态代理
1.3 怎么将对象交付给容器的？
xml配置文件， 注解；在扫描配置信息后会生成BeanDefinition对象，存储了bean的具体信息。
1.4 spring怎么存储对象？
我们实际操作过程中会使用getBean获取容器对象，而采用的方式可以分为byName, byType；可以看出两种类型：String和Class
根据我们获取对象的方式，可以得出结论：使用Map集合作为存储； key：String/Class/..
value：bean对象/Object/... 其他的可以另行猜测,开始的时候就猜猜看呗
1.5 怎么实例化对象？
最常听见的答案：反射
2 概述
上面几个问题大致描述了下使用spring的流程：xml文件 -》 对象信息 -》 实例化 -》对象存储 -》 使用； 如图：
2.1 解析
这里解析应该针对不同的文件，例如我们使用的xml， boot中的properties， yaml等，甚至我们使用注解，都需要解析的操作，去让spring知道我们怎么创建bean对象，然后生成BeanDefinition来进行存储。
而spring拥有强大的扩展性，如果我们以后需要其他配置文件类型怎么办？ 因此我们需要一套规范（Interface），然后由具体实现类去完成
/* BeanDefinitionReader:
* 定义资源文件读取并转换为BeanDefinition的各个功能
*
* Simple interface for bean definition readers.
* Specifies load methods with Resource and String location parameters.
*/流程来说应该是实例化，实例化说了通过反射将BeanDefinition对象进行解析，然后newInstance()实例化；但是中间也需要很多额外的操作用于增强
2.2 BeanFactory
BeanFactory是spring中重要的工厂，用于获取基础的spring容器，进而获取bean对象
/**
* BeanFactory
* 定义获取bean及bean的各种属性
* The root interface for accessing a Spring bean container.
*
* beanFactory中有beanDefinition信息
* This interface is implemented by objects that hold a number of bean definitions
*/看注释，bean definitions在factory中，因此可以了解在实例化前一定会从factory中进行反射
BeanFactory还有很多实现，比如AbstractApplicationContext中提供了getBeanDefinitionNames等方法，进行获取
2.3 PostProcessor
后置处理器/增强器，提供了动态操作BeanDefinition信息的能力。
为什么要修改？装逼？，实际上我们常使用的数据库配置，常使用占位符，如 ${driver.url}，现在可以想想他怎么解析的？
Spring中顶级有两个增强器：
我们使用的资源解析增强器：
/**
* spring提供的一个工具类，用于解析bean定义中属性值里面的占位符，此类不能被直接实例化使用
*
* Abstract base class for property resource configurers that resolve placeholders
* in bean definition property values.
* 例子：
*
*
*/BeanFactory结束后，可以进行对象的创建过程。整个流程又分为实例化和初始化，即：
2.4 Aware接口
紧接着，会到Aware接口；这个接口会通过回调方法获取到spring容器中的对象
/**
* A marker superinterface indicating that a bean is eligible to be notified by the
* Spring container of a particular framework object through a callback-style method.
*
public interface Aware {
}在Aware下有很多是实现的接口，可以通过实现获取不同的spring容器对象：
自定义样例，将获取的容器对象作为自己的一个成员变量就行赋值和调用：
public class B implements ApplicationContextAware {
private ApplicationContext applicationContext;
public void show() {
System.out.println("获取applicationContext对象----");
A bean = applicationContext.getBean(A.class);
System.out.println(bean);
System.out.println("获取applicationContext对象 end----");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
}
2.5 BeanPostProcessor
增强Bean信息的后置处理器，相比于BeanFactory增强器，提供了bean初始方法init-method前后两种增强方式：
public interface BeanPostProcessor {
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}
常见的场景是实现aop，用于动态代理，可以找一个接口：
查看流程：
protected Object createProxy(Class beanClass, @Nullable String beanName,
@Nullable Object[] specificInterceptors, TargetSource targetSource)
进入最后：return proxyFactory.getProxy(getProxyClassLoader()); // getProxy方法
继续：
public Object getProxy(@Nullable ClassLoader classLoader) {
// createAopProxy() 用来创建我们的代理工厂
return createAopProxy().getProxy(classLoader);
}
最后进行 AopProxy接口，其实现类有JDK和CGlib两种
综上，我们可以得出后续流程，也就是整个bean的生命周期：
2.6 FactoryBean和BeanFactory的区别？
两者都是用来创建对象的，BeanFactory是spring容器的入口，对象的创建遵循完整的生命周期，有spring进行管理。
而FactoryBean由自定义实现，通过调用getObject得到具体对象，整个过程自己可以控制；
/** * If a bean implements this * interface, it is used as a factory for an object to expose, not directly as a * bean instance that will be exposed itself. * * but the object exposed for bean * references ({@link #getObject()}) is always the object that it creates. */从源码注释中：实现FactoryBean接口的对象会被作为一种暴露工厂，提供暴露对象的能力，使用getObject总是得到他所创建的对象
自定义样例：
public class CFactoryBean implements FactoryBean {
@Override
public A getObject() throws Exception {
return new A();
}
@Override
public Class getObjectType() {
return null;
}
}
@Test
public void Test08() {
String config = "applicationContext.xml";
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
A a = (A) ac.getBean("cFactoryBean");
System.out.println(a);
}
这里实现类一个CFactoryBean的工厂，在实现接口后，他就具有了暴露
总结
第一天没总结完。。。太晚了，明天补
给自己加加油！！！
第一天总结：主要得到整个spring加载的大致流程，其中内部的细节还没有深究；其中涉及了一些重要的接口：BeanFactory， BeanDefinition, BeanDefinitionReader， BeanPostProcessor， BeanFactoryPostProcessor， Aware等等；可以先了解这些接口的大致作用；
对于整个加载流程可以从：解析文件 -》 加载对象 -》 使用对象 -》 销毁对象，逐步细化