一、Spring的优势及核心
1、Spring通过DI、AOP和消除样板式代码来简化企业级Java开发。
2、Spring框架之外还存在一个构建在核心框架之上的庞大生态圈，它将Spring扩展到不同的领域，如Web服务、REST、移动开发以及NoSQL等。
3、低侵入式设计，代码的污染极低。
4、独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺。
5、Spring的IOC容器降低了业务对象替换的复杂性，提高了组件之间的解耦。
6、Spring的AOP允许将一些通用任务如安全、事务、日志等进行集中式处理，从而提供了更好的复用。
7、Spring的ORM和DAO提供了与第三方持久层框架的的良好整合，并简化了底层的数据库访问。
8、Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部。
Spring的核心就是IOC和AOP
IOC：控制反转，就是应用本身不负责以来对象的创建和维护，依赖对象的创建及维护交由外部容器负责的，这样控制权就由应用转移到了外部容器，控制权的转移。
DI：依赖注入，指在程序运行期间，由外部容器动态地将依赖对象注入到组件中，一般通过构造函数或者setter方法注入。
AOP：面向切面编程，在不改变原有代码的情况下，增强和主要业务无关的公共代码到之前写好的方法中的指定位置。
二、XML配置启动代码
// 在ClassPath中寻找XML配置文件，根据xml文件内容来构建ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationfile.xml");
1、当然，ApplicationContext的实现类不只有ClassPathXmlApplicationContext，他拥有一套继承类，各有优缺点。
FileSystemXmlApplicationContext的构造函数需要一个xml配置文件在系统中的路径，其他和ClassPathXmlApplicationContext基本一致
AnnotationConfigApplicationContext是基于注解来使用的，他不需要配置文件，采用Java配置类和各种注解来配置，是比较简单的方式
2、怎么实例化ApplicationContext：
一个接口和他的实现类：
public interface UserService {
User select(Integer id)
}//实现类
@Service
public class UserServiceImpl implements UserService{
public void select(Integer id){
System.out.println("查询User");
}
}
然后在resource目录下新建一个配置文件，可以叫spring.xml 或application.xml等，名字随意，最好按照普遍规范来。
<?xml version="1.0" encoding="UTF-8" ?><beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
<bean id="UserService" class="com.engine.service.UserServiceImpl"/>
</beans>
最后创建一个测试类就可以了
@Testpublic void test() throws Exception {
ClassPathXmlApplicationContext ioc=new ClassPathXmlApplicationContext("classpath:/spring.xml");
UserService bean = (UserService) ioc.getBean(UserService.class);
bean.select(1);
}
这样就可以了，这部分具体内容可以看看Spring IOC的基础知识。
三、BeanFactory 简介
顾名思义，Bean的生成工厂，负责生产和管理各个bean实例的。
这里面包括了上一张图的ApplicationContext继承结构，感觉看起来还是很乱的🧐，我们重点关注一下几个类就好。
ApplicationContext，继承了ListableBeanFactory，Listable是通过这个接口，可以获取到多个Bean，而最顶层的BeanFactory接口方法都是获取的单个Bean。
还继承了HierarchicalBeanFactory，Hierarchical单词有点难度了，他是分等级的，等级制度的意思，也就是说我们可以在应用中起多个BeanFactory，然后将他们之间设置为父子关系。
AutowireCapableBeanFactory，看到名字就怀疑他是不是跟@Autowire注解有什么关系呢，他就是用来自动装配Bean的，虽然ApplicationContext与他并没有直接继承关系，但是ApplicationContext接口中的最后一个方法将他们联系起来了：AutowireCapableBeanFactorygetAutowireCapableBeanFactory() throws IllegalStateException;
ConfigurableListableBeanFactory 也是一个特殊的接口，看图，特殊之处在于它继承了第二层所有的三个接口，而 ApplicationContext 没有。
四、启动过程分析
1、ClassPathXmlApplicationContext的构造方法
// 这里包含了启动过程的核心方法，也是我们接下来的重点方法 refresh();
// ApplicationContext 建立起来以后，是可以通过refresh()这个方法重建的，refresh()会将原来的ApplicationContext销毁，
// 然后在重新执行一次初始化操作
public ClassPathXmlApplicationContext( String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
2、refresh()方法的内容：
public void refresh() throws BeansException, IllegalStateException {
// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
synchronized (this.startupShutdownMonitor) {
// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
prepareRefresh();
// 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
// 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
// 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
prepareBeanFactory(beanFactory); try {
// 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
// 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
postProcessBeanFactory(beanFactory);
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
registerBeanPostProcessors(beanFactory);
initMessageSource();
// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了 initApplicationEventMulticaster();
// 从方法名就可以知道，典型的模板方法(钩子方法)，
// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
onRefresh();
// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过 registerListeners();
// 重点，重点，重点
// 初始化所有的 singleton beans
//（lazy-init 的除外）
finishBeanFactoryInitialization(beanFactory);
// 最后，广播事件，ApplicationContext 初始化完成
finishRefresh();
} catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// 把异常往外抛
throw ex;
} finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
这个方法中调用了很多的其他方法，我们来一步一步介绍。
1、创建Bean前的准备工作
这个类实现的比较简单，先是记录了一下启动时间，然后校验一下配置文件。
2、创建Bean容器，加载并注册Bean
然后我们走到下一行：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
这个方法是全文中最重要的一部分之一，这里将会初始化BeanFactory、加载Bean、注册Bean等等，当然Bean的实例并不是在这一步生成的。这里源码就不贴了，感兴趣的小伙伴可以自己去项目中研究一下吧。
ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是说其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相关的操作其实是委托给这个实例来处理的。
3、BeanDefinition 接口定义
常说 BeanFactory 是 Bean 容器，那么 Bean 又是什么呢？BeanDefinition 就是我们所说的 Spring 的 Bean，我们自己定义的各个 Bean 其实会转换成一个个 BeanDefinition 存在于 Spring 的 BeanFactory 中。Bean 在代码层面上可以简单认为是 BeanDefinition 的实例。BeanDefinition 中保存了我们的 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、这个 Bean 依赖了哪些 Bean 等等。
这个方法就是配置是否允许 BeanDefinition 覆盖、是否允许循环引用。
这个方法会根据配置加载各个Bean，然后放到BeanFactory中，读取配置的操作在XmlBeanDefinitionReader中，其负责加载配置、解析。
