1. 学习来源

https://monkback.github.io/post/spring/spring%E5%AE%B9%E5%99%A8%E4%B8%8Eweb%E5%AE%B9%E5%99%A8/

https://www.freesion.com/article/96551187760/

Spring 面试题知识点合集，B 站高质量面试教程！

https://www.bilibili.com/video/BV1t44y1C73F?p=3

尚硅谷 spring 源码解析

https://www.bilibili.com/video/BV114411c7hV?p=31

最新 Spring 全家桶 -2021 面试 - 重灾区：Spring/SpringCloud/SpringBoot/SpringMVC，肝完就跳槽

https://www.bilibili.com/video/BV1x64y1x71b?p=55

https://www.bilibili.com/video/BV19v411K7ss?spm_id_from=333.999.0.0

2. 源码构建

gitee/leifengyang/spring-framework

repositories {  
    maven { url "http://maven.aliyun.com/nexus/content/groups/public/" }  
    maven { url "https://maven.aliyun.com/repository/spring" }  
}

/Users/taylor/Nutstore Files/Obsidian_data/pages/002-schdule/001-Arch/001-Subject/013-DemoCode/spring-framework

3. 框架结构

https://www.bilibili.com/video/BV1664y1s7dF/?spm_id_from=333.788&vd_source=c5b2d0d7bc377c0c35dbc251d95cf204

[[AbstractApplicationContext.java]]

3.1. Resource

3.2. DefaultListableBeanFactory

3.3. Beanfactory

3.4. BeanDefinition

3.5. Aware

3.6. bean 注解创建

4. Bean 的生命周期

4.1. 生命周期阶段

构造（对象创建）

单实例：在容器启动的时候创建对象

多实例：在每次获取的时候创建对象

BeanPostProcessor.postProcessBeforeInitialization
初始化

对象创建完成，并赋值好，调用初始化方法。。。

BeanPostProcessor.postProcessAfterInitialization

销毁

```
单实例：容器关闭的时候  
```

多实例：容器不会管理这个bean；容器不会调用销毁方法；

4.2. 生命周期管理

我们可以自定义初始化和销毁方法；容器在 bean 进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法

1）、指定初始化和销毁方法；
通过@Bean 指定 init-method 和 destroy-method；
2）、通过让 Bean 实现 InitializingBean（定义初始化逻辑），
DisposableBean（定义销毁逻辑）;
3）、可以使用 JSR250；
@PostConstruct：在 bean 创建完成并且属性赋值完成；来执行初始化方法
@PreDestroy：在容器销毁 bean 之前通知我们进行清理工作
4）、BeanPostProcessor【interface】：bean 的后置处理器；
在 bean 初始化前后进行一些处理工作；
postProcessBeforeInitialization: 在初始化之前工作
postProcessAfterInitialization: 在初始化之后工作

4.3. 实例化

4.3.1. 注册 Bean 的方式⭐️🔴

❕ ^1on5ia

第 1~3 种是从 BD 开始，注册 BD 进去就相当于注册了 Bean
第 4 种，直接注入 Class，跳过了 BD 到 Class 的反射 (创建实例之前的 resolveBeanClass 方法)

#todo

[[../../../../cubox/006-ChromeCapture/Spring源码笔记雷丰阳 BV1gW411W7wy - 飞飞很要强 - 博客园]]

给容器中注册组件

4.3.1.1. 古老的 xml 方式

使用 xml 的方式来声明 Bean 的定义，Spring 容器在启动的时候会加载并解析这个 xml，把 bean 装载到 IOC 容器中。

4.3.1.2. @ComponentScan+ 组件标注注解

（@Controller/@Service/@Repository/@Component）
局限于我们自己写的类，可以自己加上注解，如果是第三方则需要用@Bean 的方式

4.3.1.3. @Configuration+@Bean

[导入的第三方包里面的组件]

4.3.1.4. @Import

❕ ^j2peg1

4.3.1.4.1. 作用

快速给容器中导入一个组件

4.3.1.4.2. 使用方法 -3 种

4.3.1.4.2.1. 指定一个类

@Import(要导入到容器中的组件 id)；容器中就会自动注册这个组件，id 默认是全类名

4.3.1.4.2.2. ImportSelector

implements ImportSelector : 返回需要导入的组件的全类名数组；
implements ImportSelector，重写 selectImports 方法，返回 全类名String[]

例子：[[MyImportSelector.java]]

4.3.1.4.2.3. ImportBeanDefinitionRegistrar

implements ImportBeanDefinitionRegistrar : 手动注册 bean 到容器中
implements ImportBeanDefinitionRegistrar，重写 registerBeanDefinitions 方法，通过 registry.registerBeanDefinition 注册 RootBeanDefinition 类型的自定义 beanDefinition

例子：[[MyImportBeanDefinitionRegistrar.java]]

4.3.1.4.3. 源码示例⭐️🔴

4.3.1.5. implements FactoryBean

(1）、默认获取到的是工厂 bean 调用 getObject 创建的对象
(2）、要获取工厂 Bean 本身，我们需要给 id 前面加一个&，即
&colorFactoryBean

implements FactoryBean<Color> 重写 getObject() 方法

例子：spring-annotation：[[ColorFactoryBean.java]]

4.3.2. @Bean 与@Configuration

https://blog.csdn.net/z69183787/article/details/121979457

4.3.2.1. 结论

如果不加@Configuration，或者加了其他注解，比如@Component，结果是一样的，都没有使用 Spring 管理的 bean

ConfigurationClassPostProcessor 中的 postProcessBeanFactory 方法中 enhanceConfigurationClasses，使用 cglib 对配置类进行代理，因为@Bean 方法到时候要进行创建 Bean 的实例。即如果加了@Configuration 则会在这里创建 cglib 代理，当调用@Bean 方法时会先检测容器中是否存在。而且所有带有 @Configuration 注解的 bean 都会变成增强的类。

https://blog.csdn.net/qq_37419449/article/details/121156300
https://www.cnblogs.com/lvbinbin2yujie/p/10279416.html#titleThree

4.3.2.2. 测试

[[pages/002-schdule/001-Arch/001-Subject/013-DemoCode/Spring02/src/com/atguigu/spring/test/App.java]]

4.3.2.3. full 模式和 lite 模式

Spring-8、BeanDefinition

4.3.3. @Import 和 @ImportSelector⭐️🔴

❕ ^514kuw

4.3.3.1. ImportSelector

此接口是 spring 中导入外部配置的核心接口，根据给定的条件（通常是一个或多个注解属性即@Conditional 条件注解）判断要导入哪个配置类
如果该接口的实现类同时实现了一些 Aware 接口，那么在调用 selectImports 方法之前先调用上述接口中的回调方法
如果需要在所有的@Configuration 处理完再导入，可以实现 DeferredImportSelector 接口

4.3.3.2. DeferredImportSelector

是 ImportSelector 的一个子类
DeferredImportSelector 的设计目的是在所有其他的配置类被处理后才进行处理

优先级最低，就可以在最后面坐兜底的默认配置。

[[MySpringBoot#^bypdob]]

https://www.bilibili.com/video/BV15b4y117RJ?p=173&spm_id_from=pageDriver&vd_source=c5b2d0d7bc377c0c35dbc251d95cf204

4.4. 初始化和销毁

4.4.1. @Bean

4.4.2. 实现 InitializingBean 和 DisposableBean 接口

4.4.3. 使用 JSR250

@PostConstruct：在 bean 创建完成并且属性赋值完成；来执行初始化方法，在真正初始化方法之前执行
@PreDestroy：在容器销毁 bean 之前通知我们进行清理工作

4.4.4. @PostConstruct 原理⭐️🔴⭐️🔴

Spring-11、@PostConstruct

4.4.5. BeanPostProcessor【interface】

bean 的后置处理器，在 bean 初始化前后进行一些处理工作；
postProcessBeforeInitialization: 在初始化之前工作
postProcessAfterInitialization: 在初始化之后工作

5. 启动流程

5.1. SpringMVC 启动

Spring-4、SpringMVC

5.2. SpringBoot 启动

[[3、SpringBoot-基础#^214fh8]]

5.3. SpringBoot+Tomcat 启动

[[3、SpringBoot-基础#^kb445n]]

5.4. Tomcat+SpringBoot 启动

[[3、SpringBoot-基础#^er3z4j]]

6. 事务管理

Spring-5、声明式事务-@EnableTransactionManagement

7. 包扫描

8. 自动装配

[[3、SpringBoot-基础#^dxovlh]]

9. PostProcessor

10. FactoryBean 和 BeanFactory

10.1. FactoryBean

singletonObject 中也有 helloFactory，类型就是 FactoryBean
而 factoryBeanObjectCache 中也有 helloFactory，类型却是 Hello

10.2. BeanFactory

11. Spring SpringMVC SpringBoot

2019 最新 | 深思阿里 p7 面试题 -spring 整合 springMVC Servlet3.x 最新规范解读

https://www.bilibili.com/video/BV1VE411d7hg?from=search&seid=16332531297836154700&spm_id_from=333.337.0.0

11.1. 区别

12. 异步处理

/Users/weileluo/001-study/尚硅谷/尚硅谷 Spring 注解驱动开发/Spring 注解驱动开发/视频/60、springmvc- 异步请求 - 返回 Callable.avi

13. 2 种定义 Bean 的方式

14. IOC

Spring-2、IOC

15. AOP

Spring-3、AOP实现原理-@EnableAspectJAutoProxy

16. SpringMVC

Spring-4、SpringMVC

17. 整合 Mybatis

Spring-6、整合Mybatis-@MapperScan

18. Spring 中用到的设计模式

https://www.processon.com/mindmap/639819cb1efad451e01ed494

https://blog.csdn.net/weixin_44259720/article/details/95996541

[[【雷丰阳设计模式与框架源码】【01】总览设计模式、设计模式7大原则 - W3cJava]]

18.1. 单例、原型模式

18.2. 简单工厂模式

BeanFactory.getBean

18.3. 建造者模式

Mybatis 的 mapper 就是使用了 BeanDefinitionBuilder

18.4. 代理模式

ObjenesisCglibAopPorxy 是对 Cglib 的一个补充，因为 Cglib 要求必须有无参构造，而 ObjenesisCglibAopProxy 可以不要求必须有无参构造。 ❕ ^8r3nrd

18.5. 适配器模式

18.6. 装饰者模式

SpringBoot 的 rest 原理

18.7. 门面模式 (外观模式)

AbstractApplicationContext.getBean

18.8. 模板方法模式

父子容器启动

18.9. 策略模式

18.10. 观察者模式

主要用于当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知，在 Spring 中一般以 Listener 结尾，比如 ApplicationListener 等等。

19. 自定义 Spring 框架

19.1. 7.2 spring 核心功能结构

Spring 大约有 20 个模块，由 1300 多个不同的文件构成。这些模块可以分为:

核心容器、AOP 和设备支持、数据访问与集成、Web 组件、通信报文和集成测试等，下面是 Spring 框架的总体架构图：

核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4 个模块组成。

spring-beans 和 spring-core 模块是 Spring 框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。BeanFactory 使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory 属于延时加载，也就是说在实例化容器对象后并不会自动实例化 Bean，只有当 Bean 被使用时，BeanFactory 才会对该 Bean 进行实例化与依赖关系的装配。
spring-context 模块构架于核心模块之上，扩展了 BeanFactory，为它添加了 Bean 生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与 BeanFactory 不同，ApplicationContext 实例化后会自动对所有的单实例 Bean 进行实例化与依赖关系的装配，使之处于待用状态。
spring-context-support 模块是对 Spring IoC 容器及 IoC 子容器的扩展支持。
spring-context-indexer 模块是 Spring 的类管理组件和 Classpath 扫描组件。
spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统 EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL 的特性是基于 Spring 产品的需求而设计的，可以非常方便地同 Spring IoC 进行交互。

19.1.1. 7.1.1 bean 概述

Spring 就是面向 Bean 的编程（BOP,Bean Oriented Programming），Bean 在 Spring 中处于核心地位。Bean 对于 Spring 的意义就像 Object 对于 OOP 的意义一样，Spring 中没有 Bean 也就没有 Spring 存在的意义。Spring IoC 容器通过配置文件或者注解的方式来管理 bean 对象之间的依赖关系。

spring 中 bean 用于对一个类进行封装。如下面的配置：


<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">  
    <property name="userDao" ref="userDao"></property>  
</bean>  
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>

public interface BeanFactory {  
  
  String FACTORY_BEAN_PREFIX = "&";  
  
  //根据bean的名称获取IOC容器中的的bean对象  
  Object getBean(String name) throws BeansException;  
  //根据bean的名称获取IOC容器中的的bean对象，并指定获取到的bean对象的类型，这样我们使用时就不需要进行类型强转了  
  <T> T getBean(String name, Class<T> requiredType) throws BeansException;  
  Object getBean(String name, Object... args) throws BeansException;  
  <T> T getBean(Class<T> requiredType) throws BeansException;  
  <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;  
    
  <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);  
  <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);  
  
  //判断容器中是否包含指定名称的bean对象  
  boolean containsBean(String name);  
  //根据bean的名称判断是否是单例  
  boolean isSingleton(String name) throws NoSuchBeanDefinitionException;  
  boolean isPrototype(String name) throws NoSuchBeanDefinitionException;  
  boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;  
  boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;  
  @Nullable  
  Class<?> getType(String name) throws NoSuchBeanDefinitionException;  
  String[] getAliases(String name);  
}

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>  
  
bean标签还有很多属性：  
  scope、init-method、destory-method等。

public interface BeanDefinitionReader {  
  
  //获取BeanDefinitionRegistry注册器对象  
  BeanDefinitionRegistry getRegistry();  
  
  @Nullable  
  ResourceLoader getResourceLoader();  
  
  @Nullable  
  ClassLoader getBeanClassLoader();  
  
  BeanNameGenerator getBeanNameGenerator();  
  
  /*  
    下面的loadBeanDefinitions都是加载bean定义，从指定的资源中  
  */  
  int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;  
  int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException;  
  int loadBeanDefinitions(String location) throws BeanDefinitionStoreException;  
  int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException;  
}

public interface BeanDefinitionRegistry extends AliasRegistry {  
  
  //往注册表中注册bean  
  void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
      throws BeanDefinitionStoreException;  
  
  //从注册表中删除指定名称的bean  
  void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;  
  
  //获取注册表中指定名称的bean  
  BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;  
      
  //判断注册表中是否已经注册了指定名称的bean  
  boolean containsBeanDefinition(String beanName);  
      
  //获取注册表中所有的bean的名称  
  String[] getBeanDefinitionNames();  
      
  int getBeanDefinitionCount();  
  boolean isBeanNameInUse(String beanName);  
}

-   DefaultListableBeanFactory
    
    在该类中定义了如下代码，就是用来注册bean
    
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
    
-   SimpleBeanDefinitionRegistry
    
    在该类中定义了如下代码，就是用来注册bean
    
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);
    
    <?xml version="1.0" encoding="UTF-8"?>  
    <beans>  
        <bean id="userService" class="com.itheima.service.impl.UserServiceImpl">  
            <property name="userDao" ref="userDao"></property>  
        </bean>  
        <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"></bean>  
    </beans>
    
    public class PropertyValue {  
      
      private String name;  
      private String ref;  
      private String value;  
      
      public PropertyValue() {  
      }  
      
      public PropertyValue(String name, String ref,String value) {  
        this.name = name;  
        this.ref = ref;  
        this.value = value;  
      }  
      
      public String getName() {  
        return name;  
      }  
      
      public void setName(String name) {  
        this.name = name;  
      }  
      
      public String getRef() {  
        return ref;  
      }  
      
      public void setRef(String ref) {  
        this.ref = ref;  
      }  
      
      public String getValue() {  
        return value;  
      }  
      
      public void setValue(String value) {  
        this.value = value;  
      }  
    }
    
    public class MutablePropertyValues implements Iterable<PropertyValue> {  
      
        private final List<PropertyValue> propertyValueList;  
      
        public MutablePropertyValues() {  
            this.propertyValueList = new ArrayList<PropertyValue>();  
        }  
      
        public MutablePropertyValues(List<PropertyValue> propertyValueList) {  
            this.propertyValueList = (propertyValueList != null ? propertyValueList : new ArrayList<PropertyValue>());  
        }  
      
        public PropertyValue[] getPropertyValues() {  
            return this.propertyValueList.toArray(new PropertyValue[0]);  
        }  
      
        public PropertyValue getPropertyValue(String propertyName) {  
            for (PropertyValue pv : this.propertyValueList) {  
                if (pv.getName().equals(propertyName)) {  
                    return pv;  
                }  
            }  
            return null;  
        }  
      
        @Override  
        public Iterator<PropertyValue> iterator() {  
            return propertyValueList.iterator();  
        }  
      
        public boolean isEmpty() {  
            return this.propertyValueList.isEmpty();  
        }  
      
        public MutablePropertyValues addPropertyValue(PropertyValue pv) {  
            for (int i = 0; i < this.propertyValueList.size(); i++) {  
                PropertyValue currentPv = this.propertyValueList.get(i);  
                if (currentPv.getName().equals(pv.getName())) {  
                    this.propertyValueList.set(i, new PropertyValue(pv.getName(),pv.getRef(), pv.getValue()));  
                    return this;  
                }  
            }  
            this.propertyValueList.add(pv);  
            return this;  
        }  
      
        public boolean contains(String propertyName) {  
            return getPropertyValue(propertyName) != null;  
        }  
    }
    
    public class BeanDefinition {  
        private String id;  
        private String className;  
      
        private MutablePropertyValues propertyValues;  
      
        public BeanDefinition() {  
            propertyValues = new MutablePropertyValues();  
        }  
      
        public String getId() {  
            return id;  
        }  
      
        public void setId(String id) {  
            this.id = id;  
        }  
      
        public String getClassName() {  
            return className;  
        }  
      
        public void setClassName(String className) {  
            this.className = className;  
        }  
      
        public void setPropertyValues(MutablePropertyValues propertyValues) {  
            this.propertyValues = propertyValues;  
        }  
      
        public MutablePropertyValues getPropertyValues() {  
            return propertyValues;  
        }  
    }
    
    public interface BeanDefinitionRegistry {  
      
        //注册BeanDefinition对象到注册表中  
        void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);  
      
        //从注册表中删除指定名称的BeanDefinition对象  
        void removeBeanDefinition(String beanName) throws Exception;  
      
        //根据名称从注册表中获取BeanDefinition对象  
        BeanDefinition getBeanDefinition(String beanName) throws Exception;  
      
        boolean containsBeanDefinition(String beanName);  
      
        int getBeanDefinitionCount();  
      
        String[] getBeanDefinitionNames();  
    }
    
    public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {  
      
        private Map<String, BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();  
      
        @Override  
        public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {  
            beanDefinitionMap.put(beanName,beanDefinition);  
        }  
      
        @Override  
        public void removeBeanDefinition(String beanName) throws Exception {  
            beanDefinitionMap.remove(beanName);  
        }  
      
        @Override  
        public BeanDefinition getBeanDefinition(String beanName) throws Exception {  
            return beanDefinitionMap.get(beanName);  
        }  
      
        @Override  
        public boolean containsBeanDefinition(String beanName) {  
            return beanDefinitionMap.containsKey(beanName);  
        }  
      
        @Override  
        public int getBeanDefinitionCount() {  
            return beanDefinitionMap.size();  
        }  
      
        @Override  
        public String[] getBeanDefinitionNames() {  
            return beanDefinitionMap.keySet().toArray(new String[1]);  
        }  
    }
    
    public interface BeanDefinitionReader {  
      
      //获取注册表对象  
        BeanDefinitionRegistry getRegistry();  
      //加载配置文件并在注册表中进行注册  
        void loadBeanDefinitions(String configLocation) throws Exception;  
    }
    
    public class XmlBeanDefinitionReader implements BeanDefinitionReader {  
      
        private BeanDefinitionRegistry registry;  
      
        public XmlBeanDefinitionReader() {  
            this.registry = new SimpleBeanDefinitionRegistry();  
        }  
      
        @Override  
        public BeanDefinitionRegistry getRegistry() {  
            return registry;  
        }  
      
        @Override  
        public void loadBeanDefinitions(String configLocation) throws Exception {  
      
            InputStream is = this.getClass().getClassLoader().getResourceAsStream(configLocation);  
            SAXReader reader = new SAXReader();  
            Document document = reader.read(is);  
            Element rootElement = document.getRootElement();  
            //解析bean标签  
            parseBean(rootElement);  
        }  
      
        private void parseBean(Element rootElement) {  
      
            List<Element> elements = rootElement.elements();  
            for (Element element : elements) {  
                String id = element.attributeValue("id");  
                String className = element.attributeValue("class");  
                BeanDefinition beanDefinition = new BeanDefinition();  
                beanDefinition.setId(id);  
                beanDefinition.setClassName(className);  
                List<Element> list = element.elements("property");  
                MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();  
                for (Element element1 : list) {  
                    String name = element1.attributeValue("name");  
                    String ref = element1.attributeValue("ref");  
                    String value = element1.attributeValue("value");  
                    PropertyValue propertyValue = new PropertyValue(name,ref,value);  
                    mutablePropertyValues.addPropertyValue(propertyValue);  
                }  
                beanDefinition.setPropertyValues(mutablePropertyValues);  
      
                registry.registerBeanDefinition(id,beanDefinition);  
            }  
        }  
    }
    
    public interface BeanFactory {  
      //根据bean对象的名称获取bean对象  
        Object getBean(String name) throws Exception;  
      //根据bean对象的名称获取bean对象，并进行类型转换  
        <T> T getBean(String name, Class<? extends T> clazz) throws Exception;  
    }
    
    public interface ApplicationContext extends BeanFactory {  
      //进行配置文件加载并进行对象创建  
        void refresh() throws IllegalStateException, Exception;  
    }
    
    public abstract class AbstractApplicationContext implements ApplicationContext {  
      
        protected BeanDefinitionReader beanDefinitionReader;  
        //用来存储bean对象的容器   key存储的是bean的id值，value存储的是bean对象  
        protected Map<String, Object> singletonObjects = new HashMap<String, Object>();  
      
        //存储配置文件的路径  
        protected String configLocation;  
      
        public void refresh() throws IllegalStateException, Exception {  
      
            //加载BeanDefinition  
            beanDefinitionReader.loadBeanDefinitions(configLocation);  
      
            //初始化bean  
            finishBeanInitialization();  
        }  
      
        //bean的初始化  
        private void finishBeanInitialization() throws Exception {  
            BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();  
            String[] beanNames = registry.getBeanDefinitionNames();  
      
            for (String beanName : beanNames) {  
                BeanDefinition beanDefinition = registry.getBeanDefinition(beanName);  
                getBean(beanName);  
            }  
        }  
    }
    
    public class ClassPathXmlApplicationContext extends AbstractApplicationContext{  
      
        public ClassPathXmlApplicationContext(String configLocation) {  
            this.configLocation = configLocation;  
            //构建XmlBeanDefinitionReader对象  
            beanDefinitionReader = new XmlBeanDefinitionReader();  
            try {  
                this.refresh();  
            } catch (Exception e) {  
            }  
        }  
      
        //根据bean的id属性值获取bean对象  
        @Override  
        public Object getBean(String name) throws Exception {  
      
            //return singletonObjects.get(name);  
            Object obj = singletonObjects.get(name);  
            if(obj != null) {  
                return obj;  
            }  
      
            BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();  
            BeanDefinition beanDefinition = registry.getBeanDefinition(name);  
            if(beanDefinition == null) {  
                return null;  
            }  
            String className = beanDefinition.getClassName();  
            Class<?> clazz = Class.forName(className);  
            Object beanObj = clazz.newInstance();  
            MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();  
            for (PropertyValue propertyValue : propertyValues) {  
                String propertyName = propertyValue.getName();  
                String value = propertyValue.getValue();  
                String ref = propertyValue.getRef();  
                if(ref != null && !"".equals(ref)) {  
      
                    Object bean = getBean(ref);  
                    String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);  
                    Method[] methods = clazz.getMethods();  
                    for (Method method : methods) {  
                        if(method.getName().equals(methodName)) {  
                            method.invoke(beanObj,bean);  
                        }  
                    }  
                }  
      
                if(value != null && !"".equals(value)) {  
                    String methodName = StringUtils.getSetterMethodNameByFieldName(propertyName);  
                    Method method = clazz.getMethod(methodName, String.class);  
                    method.invoke(beanObj,value);  
                }  
            }  
            singletonObjects.put(name,beanObj);  
            return beanObj;  
        }  
      
        @Override  
        public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {  
      
            Object bean = getBean(name);  
            if(bean != null) {  
                return clazz.cast(bean);  
            }  
            return null;  
        }  
    }

了解 Spring 底层对对象的大体管理机制。

了解设计模式在具体的开发中的使用。

以后学习 spring 源码，通过该案例的实现，可以降低 spring 学习的入门成本。

spring 框架底层是很复杂的，进行了很深入的封装，并对外提供了很好的扩展性。而我们自定义 SpringIOC 有以下几个目的：

7.4.5.3 整个设计和 Spring 的设计还是有一定的出入

7.4.5.2 符合大部分设计原则

spring 框架其实使用到了很多设计模式，如 AOP 使用到了代理模式，选择 JDK 代理或者 CGLIB 代理使用到了策略模式，还有适配器模式，装饰者模式，观察者模式等。

工厂模式。这个使用工厂模式 + 配置文件的方式。
- 单例模式。Spring IOC 管理的 bean 对象都是单例的，此处的单例不是通过构造器进行单例的控制的，而是 spring 框架对每一个 bean 只创建了一个对象。
- 模板方法模式。AbstractApplicationContext 类中的 finishBeanInitialization() 方法调用了子类的 getBean() 方法，因为 getBean() 的实现和环境息息相关。
- 迭代器模式。对于 MutablePropertyValues 类定义使用到了迭代器模式，因为此类存储并管理 PropertyValue 对象，也属于一个容器，所以给该容器提供一个遍历方式。
7.4.5.1 使用到的设计模式
7.4.5 自定义 Spring IOC 总结
- 在构造方法中，创建 BeanDefinitionReader 对象。
- 在构造方法中，调用 refresh() 方法，用于进行配置文件加载、创建 bean 对象并存储到容器中。
- 重写父接口中的 getBean() 方法，并实现依赖注入操作。
该类主要是加载类路径下的配置文件，并进行 bean 对象的创建，主要完成以下功能：
7.4.4.4 ClassPathXmlApplicationContext 类
注意：该类 finishBeanInitialization() 方法中调用 getBean() 方法使用到了模板方法模式。
- 作为 ApplicationContext 接口的子类，所以该类也是非延时加载，所以需要在该类中定义一个 Map 集合，作为 bean 对象存储的容器。
- 声明 BeanDefinitionReader 类型的变量，用来进行 xml 配置文件的解析，符合单一职责原则。
  BeanDefinitionReader 类型的对象创建交由子类实现，因为只有子类明确到底创建 BeanDefinitionReader 哪儿个子实现类对象。
7.4.4.3 AbstractApplicationContext 类
- 加载配置文件。
- 根据注册表中的 BeanDefinition 对象封装的数据进行 bean 对象的创建。
该接口的所以的子实现类对 bean 对象的创建都是非延时的，所以在该接口中定义 refresh() 方法，该方法主要完成以下两个功能：
7.4.4.2 ApplicationContext 接口
在该接口中定义 IOC 容器的统一规范即获取 bean 对象。
7.4.4.1 BeanFactory 接口
7.4.4 IOC 容器相关类
XmlBeanDefinitionReader 类是专门用来解析 xml 配置文件的。该类实现 BeanDefinitionReader 接口并实现接口中的两个功能。
7.4.3.2 XmlBeanDefinitionReader 类
- 获取注册表的功能，让外界可以通过该对象获取注册表对象。
- 加载配置文件，并注册 bean 数据。
BeanDefinitionReader 是用来解析配置文件并在注册表中注册 bean 的信息。定义了两个规范：
7.4.3.1 BeanDefinitionReader 接口
7.4.3 定义解析器相关类
该类实现了 BeanDefinitionRegistry 接口，定义了 Map 集合作为注册表容器。
7.4.2.2 SimpleBeanDefinitionRegistry 类
- 注册 BeanDefinition 对象到注册表中
- 从注册表中删除指定名称的 BeanDefinition 对象
- 根据名称从注册表中获取 BeanDefinition 对象
- 判断注册表中是否包含指定名称的 BeanDefinition 对象
- 获取注册表中 BeanDefinition 对象的个数
- 获取注册表中所有的 BeanDefinition 的名称
BeanDefinitionRegistry 接口定义了注册表的相关操作，定义如下功能：
7.4.2.1 BeanDefinitionRegistry 接口
7.4.2 定义注册表相关类
BeanDefinition 类用来封装 bean 信息的，主要包含 id（即 bean 对象的名称）、class（需要交由 spring 管理的类的全类名）及子标签 property 数据。
7.4.1.3 BeanDefinition 类
一个 bean 标签可以有多个 property 子标签，所以再定义一个 MutablePropertyValues 类，用来存储并管理多个 PropertyValue 对象。
7.4.1.2 MutablePropertyValues 类
用于封装 bean 的属性，体现到上面的配置文件就是封装 bean 标签的子标签 property 标签数据。
7.4.1.1 PropertyValue 类
7.4.1 定义 bean 相关的 pojo 类
现要对下面的配置文件进行解析，并自定义 Spring 框架的 IOC 对涉及到的对象进行管理。
7.4 自定义 SpringIOC
ClassPathXmlApplicationContext 对 Bean 配置资源的载入是从 refresh（）方法开始的。refresh（）方法是一个模板方法，规定了 IoC 容器的启动流程，有些逻辑要交给其子类实现。它对 Bean 配置资源进行载入，ClassPathXmlApplicationContext 通过调用其父类 AbstractApplicationContext 的 refresh（）方法启动整个 IoC 容器对 Bean 定义的载入过程。
7.3.5 创建容器

从上面类图可以看到 BeanDefinitionRegistry 接口的子实现类主要有以下几个：

继承结构图如下：

BeanDefinitionReader 用来解析 bean 定义，并封装 BeanDefinition 对象，而我们定义的配置文件中定义了很多 bean 标签，所以就有一个问题，解析的 BeanDefinition 对象存储到哪儿？答案就是 BeanDefinition 的注册中心，而该注册中心顶层接口就是 BeanDefinitionRegistry。

19.1.2. 7.3.4 BeanDefinitionRegistry 解析

看看 BeanDefinitionReader 接口定义的功能来理解它具体的作用：

Bean 的解析过程非常复杂，功能被分得很细，因为这里需要被扩展的地方很多，必须保证足够的灵活性，以应对可能的变化。Bean 的解析主要就是对 Spring 配置文件的解析。这个解析过程主要通过 BeanDefinitionReader 来完成，看看 Spring 中 BeanDefinitionReader 的类结构图，如下图所示。

19.1.3. 7.3.3 BeanDefinitionReader 解析

其继承体系如下图所示。

Spring IoC 容器管理我们定义的各种 Bean 对象及其相互关系，而 Bean 对象在 Spring 实现中是以 BeanDefinition 来描述的，如下面配置文件

19.1.4. 7.3.2 BeanDefinition 解析

ClasspathXmlApplicationContext : 根据类路径加载 xml 配置文件，并创建 IOC 容器对象。
FileSystemXmlApplicationContext ：根据系统路径加载 xml 配置文件，并创建 IOC 容器对象。
AnnotationConfigApplicationContext ：加载注解类配置，并创建 IOC 容器。

要知道工厂是如何产生对象的，我们需要看具体的 IoC 容器实现，Spring 提供了许多 IoC 容器实现，比如：

BeanFactory 有一个很重要的子接口，就是 ApplicationContext 接口，该接口主要来规范容器中的 bean 对象是非延时加载，即在创建容器对象的时候就对象 bean 进行初始化，并存储到一个容器中。

在 BeanFactory 里只对 IoC 容器的基本行为做了定义，根本不关心你的 Bean 是如何定义及怎样加载的。正如我们只关心能从工厂里得到什么产品，不关心工厂是怎么生产这些产品的。

这三个接口共同定义了 Bean 的集合、Bean 之间的关系及 Bean 行为。最基本的 IoC 容器接口是 BeanFactory，来看一下它的源码：

ListableBeanFactory 接口表示这些 Bean 可列表化。
HierarchicalBeanFactory 表示这些 Bean 是有继承关系的，也就是每个 Bean 可能有父 Bean
AutowireCapableBeanFactory 接口定义 Bean 的自动装配规则。

每个接口都有它的使用场合，主要是为了区分在 Spring 内部操作过程中对象的传递和转化，对对象的数据访问所做的限制。例如，

那么为何要定义这么多层次的接口呢？

其中，BeanFactory 作为最顶层的一个接口，定义了 IoC 容器的基本功能规范，BeanFactory 有三个重要的子接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是从类图中我们可以发现最终的默认实现类是 DefaultListableBeanFactory，它实现了所有的接口。

Spring 中 Bean 的创建是典型的工厂模式，这一系列的 Bean 工厂，即 IoC 容器，为开发者管理对象之间的依赖关系提供了很多便利和基础服务，在 Spring 中有许多 IoC 容器的实现供用户选择，其相互关系如下图所示。

19.1.5. 7.3.1 BeanFactory 解析

19.2. 7.3 Spring IOC 相关接口分析

spring 将 bean 对象交由一个叫 IOC 容器进行管理。
bean 对象之间的依赖关系在配置文件中体现，并由 spring 完成。

为什么 Bean 如此重要呢？
基本原理

20. 其他

20.1. 属性赋值用的是深拷贝

20.2. 装配用了多态特性

20.3. InstantiationStrategy

[[【死磕 Spring】—– IOC 之 bean 的实例化策略：InstantiationStrategy - 腾讯云开发者社区-腾讯云]]

21. 实战经验

22. 参考与感谢

22.1. 雷丰阳 -SpringSource

https://www.bilibili.com/video/BV1Uq4y1n7mS/?spm_id_from=333.788&vd_source=c5b2d0d7bc377c0c35dbc251d95cf204
有注释可运行： [[pages/002-schdule/001-Arch/001-Subject/013-DemoCode/spring-framework/springsource-test/src/main/java/com/atguigu/spring/MainTest.java]]

22.2. spring 注解驱动开发 _spring 源码版 - 雷丰阳 - 尚硅谷