概述

在正式分析 Spring 源码之前，我们有必要先来回顾一下 Spring 中最简单的用法。尽管我相信您已经对下面例子非常熟悉了。Bean 是 Spring 中最核心的概念，因为 Spring 就像是个大水桶，而 Bean 就像是水桶中的水，水桶脱离了水也就没什么用处了。

搭建基础框架

XML方案搭建Spring容器

引入jar包

  1.  <properties>
  2.         <java.version>1.8</java.version>
  3.         <spring.version>5.1.5.RELEASE</spring.version>
  4.     </properties>
  6.     <dependencies>
  7.         <dependency>
  8.             <groupId>org.springframework</groupId>
  9.             <artifactId>spring-context</artifactId>
  10.             <version>${spring.version}</version>
  11.         </dependency>
  12.     </dependencies>

引入 spring-context jar,它会自动帮我引入aop、beans、core、expression、jcl 如下图：
图片.png

User 实体类

  1.     /** 
  2.      * User实体类
  3.      * @date: 2021/2/24 17:47
  4.      */
  5.     public class User {
  7.         private String userName;
  8.         private Integer age;
  12.         public void setUserName(String userName) {
  13.             this.userName = userName;
  14.         }
  16.         public void setAge(Integer age) {
  17.             this.age = age;
  18.         }
  20.         @Override
  21.         public String toString() {
  22.             return "User{" +
  23.                     "userName='" + userName + '\'' +
  24.                     ", age=" + age +
  25.                     '}';
  26.         }
  27.     }

spring-config.xml 配置文件

在项目resources目录下创建 spring-config.xml，把User实体类注入到Spring容器中

  1. <?xml version="1.0" encoding="UTF-8"?>
  2.     <beans xmlns="http://www.springframework.org/schema/beans"
  3.            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.            xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.                                 http://www.springframework.org/schema/beans/spring-beans.xsd">
  7.    <bean id="user" class="com.zlp.spring.v1.entity.User">
  8.             <property name="age" value="10" />
  9.             <property name="userName" value="smile" />
  10.    </bean>
  11. </beans>

XmlUserTest 测试类

  1.     /**
  2.      * XML容器测试类
  3.      * @author Zou.LiPing
  4.      * @date: 2021/2/24 17:13
  5.      */
  6.     public class XmlUserTest {
  9.         public static void main(String[] args) {
  11.             ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
  12.             User user = ac.getBean("user", User.class);
  13.             System.out.println(user.toString());
  15.         }
  17.     }

控制打印输出

  1. User{userName='smile', age=10}

Annotation方案搭建 Spring容器

UserEntity 实体类

  1. @Component
  2.     public class UserEntity {
  4.         private String userName = "change";
  5.         private Integer age = 28;
  7.         @Override
  8.         public String toString() {
  9.             return "User{" +
  10.                     "userName='" + userName + '\'' +
  11.                     ", age=" + age +
  12.                     '}';
  13.         }
  14.     }

SpringConfig 配置类

  1.  @Configuration
  2.     @ComponentScan("com.zlp.spring.v2")
  3.     public class SpringConfig {
  6.     }

AnnotationUserTest 测试类

  1.     /** 
  2.      * 注解测试类
  3.      * @author Zou.LiPing
  4.      * @date: 2021/2/24 17:13
  5.      */
  6.     public class AnnotationUserTest {
  8.         private static AnnotationConfigApplicationContext applicationContext;
  10.         public static void main(String[] args) {
  12.             applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
  13.             UserEntity user = applicationContext.getBean("userEntity", UserEntity.class);
  14.             System.out.println(user.toString());
  17.             // 打印注入Spring有哪些对象
  18.             String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
  19.             for (String beanDefinitionName : beanDefinitionNames) {
  20.                 System.out.println(beanDefinitionName);
  21.             }
  22.         }
  23.     }

控制打印输出

  1. User{userName='change', age=28}

Spring 启动流程详解

执行流程图

Spring 容器启动方式（四） - 图2执行流程详解

  1. 加载 Bean 定义信息（xml 配置、注解、配置类）；
  2. 解析 Bean 信息（BeanDefinitionReader 读取器 Bean 信息）；
  3. 读取 Bean 定义信息，用 ConcurrentHashMap 存储（BeanDefinition 存放Bean 实例、作用域等）；
  4. BeanFactoryPostProcessor 扩展接口（BeanDefinition 属性增强器，如 @Value(“${xxxx}”)替换）；
  5. 通过反射来创建 Bean 对象信）；
  6. 初始化对象（在堆中开辟新的空间→属性都是默认值）；
  7. 如果该方法依赖其它的接口（@Autowired），通过 DI 注入（填充属性）；
  8. *aware接口实现（设置aware接口属性）；
  9. 如果实现了 BeanPostProcessor 接口（增强器，可以对方法前置和后置进行扩展）；
  10. 前置增强器（postProcessBeforeInitialization 方法）；
  11. Bean 初始化[init-method]；
  12. 后置增强器（postProcessAfterInitialization 方法）；
  13. Bean基本使用；
  14. 销毁（DisposableBean）；