SpringBoot（1）Spring基础

一、Spring相关概念

框架设计原则

  • 使用POJO（Plain Old Java Object，普通Java对象）取代EJB（Enterprise Java bean，企业级Java Bean），进行轻量级（1MB的jar包）和最小侵入式开发。
  • 通过IoC（Inversion of Control，控制反转）的DI（Dependency Injection，依赖注入），配合基于接口编程实现松耦合。
  • 通过AOP（Aspect Oriented Programming，面向切面编程），和默认习惯进行声明式编程。配合模板（template）减少模块化代码，用于事务管理、权限控制、日志记录、性能统计等。

常用jar包

  • org.springframework.aop，Spring的面向切面编程，提供AOP（面向切面编程）的实现
  • org.springframework.beans，所有应用都用到，包含访问配置文件，创建和管理bean等，是Spring IOC的基础实现。
  • org.springframework.context，提供在基础IOC功能上的扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持。
  • org.springframework.core，Spring的核心工具包，其他包依赖此包
  • org.springframework.expression，Spring表达式语言
  • org.springframework.jcl，日志框架
  • org.springframework.test，对JUNIT等测试框架的简单封装
  • org.springframework.web，包含Web应用开发时，用到Spring框架时所需的核心类。
  • org.springframework.webmvc，基于web框架，提供MVC模式支持。

控制反转（IoC，Inversion of Control）

  • 控制反转，不是什么技术，而是一种设计思想。它能指导我们如何设计出松耦合、更优良的程序。
  • 传统Java程序设计，直接在“对象”内部通过new创建了“依赖对象”，是“对象”主动去创建“依赖对象”，由“对象”直接控制“依赖对象”。
  • 在IoC中，有专门容器来协助“对象”创建并注入“依赖对象”，即由专有容器来控制“依赖对象”的创建。“对象”只是被动的接受“依赖对象”，而不是像传统方式一样直接控制“依赖对象”，因此被称为控制反转。

依赖注入（DI，Dependency Injection）

  • 和IoC的关系：IoC和依赖注入本质上描述的是同一种概念，但如非要区分，可以认为IoC是一种思想，依赖注入是一种实现方式，即控制反转通过依赖注入来实现。
  • 依赖注入指的是容器负责创建对象和维护对象间的依赖关系，而不是通过对象本身负责自己的创建和解决自己的依赖。
  • 依赖注入是注入某个对象所需要的属性（包括对象、资源、常量数据）。主要为了解耦，体现了一种“组合”的理念，组合则使耦合度大大降低。如果需要某个类具备某项功能的时候，也可以使用继承，但继承一个具有此功能的父类，子类将和父类耦合。

Spring中的IoC

  • 对于Spring框架来说，就是由Spring的IoC容器（ApplicationContext）来负责控制对象的生命周期和对象间的关系。
  • IoC容器用来帮“对象”查找“依赖对象”、创建“依赖对象”、把“依赖对象”交给“对象”。即IoC容器负责创建Bean，并将功能类Bean注入到你需要的Bean中。
  • Spring提供3种元数据配置方式，基于xml配置、基于注解配置和基于Java类配置，来实现Bean的创建和注入。推荐使用Java配置和注解混合配置。全局配置使用Java类配置，业务Bean的配置使用注解配置。
  • IoC容器通过解析配置的元数据（如dom4j解析xml，扫描注解），进行Bean初始化、配置和管理依赖，底层原理是利用java的反射来实现。
  • 创建对象时，向类里面的属性设置值，可以称为属性注入。方式有三种：有参构造器注入、set方法(包括P名称空间注入)、接口方法注入。Spring支持前两种注入，还可以支持静态工厂和实例工厂的注入。
  • 手动装配需要使用property进行设置。针对自动装配，xml使用autowire属性，注解使用@Autowired，xml中autowire属性可设置为no、byName、byType、constructor和Autodetect。

接口多态、工厂模式、spring依赖注入区别

  • 接口多态，耦合，更换时需要所有对象创建的地方修改。
  • 工厂模式，解耦，只需要修改工厂方法，直接去工厂获取对象。
  • spring依赖注入，不需要写工厂方法，由spring自动扫描、获取，实现动态的拆装组建和组件重用。

二、Spring IoC代码实践

实体类，UserDao.java和UserService.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class UserDao {
    private String age;

    public UserDao() {
    }

    public void printName(){
        System.out.println("herr");
    }

    public UserDao(String age) {
        this.age = age;
    }

    public void printAge(){
        System.out.println(age);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class UserService {

    private UserDao userDao;
    private String stringValue;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void setStringValue(String stringValue) {
        this.stringValue = stringValue;
    }

    public void printName(){
        userDao.printName();
    }

    public void printString(){
        System.out.println(stringValue);
    }
}

传统实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class NormalTest {

    @Test
    //传统方式创建对象，使用new
    public void testNormalCreate(){
        UserDao userDao =new UserDao();
        userDao.printName();
    }

    @Test
    //传统方式创建对象，使用静态工厂模式
    public void testFactoryCreate(){
        UserDao userDao = StaticBeanFactory.getUserDao();
        userDao.printName();
    }

    @Test
    //传统方式创建对象，使用java反射
    public void testReflectionCreate() throws Exception {
        Class clazz= Class.forName("com.herr.xml.UserDao");
        UserDao userDao =(UserDao) clazz.newInstance();
        userDao.printName();
    }
    
    @Test
    //传统方式属性注入，通过有参构造器
    public void testeNormalConstuctorCreate(){
        UserDao userDao = new UserDao("18");
        userDao.printAge();
    }

    @Test
    //传统方式属性注入，通过setter
    public void testNormalSetter(){
        UserService userService =new UserService();
        userService.setStringValue("normal setter://");
        userService.printString();
    }
}

Spring基于xml的配置

xml-bean.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 没有autowire属性的都是手动装配 -->
    <!-- 默认，需要类中有"无参构造方法"，bean有scope属性，默认为singleton（单例），还有prototype（多例） -->
    <bean id="userDao" class="com.herr.xml.UserDao" scope="singleton"/>

    <!-- 静态工厂创建 -->
    <bean id="userDao2" class="com.herr.xml.StaticBeanFactory" factory-method="getUserDao"/>

    <!-- 实例工厂创建 -->
    <bean id="beanFactory" class="com.herr.xml.BeanFactory"/>
    <bean id="userDao3" factory-bean="beanFactory" factory-method="getUserDao"/>

    <!-- 有参构造属性注入，需要类中有"有参构造方法" -->
    <bean id="userConstructor" class="com.herr.xml.UserDao">
        <!-- 有参构造使用constructor-arg标签 -->
        <constructor-arg name="age" value="18"/>
    </bean>

    <!-- setter属性注入，需要类中有"setter方法" -->
    <bean id="userService" class="com.herr.xml.UserService">
        <!-- 注入dao对象，name为service类里面的属性，ref为dao配置bean中的id值 -->
        <property name="userDao" ref="userDao"></property>
        <!-- 注入value、list、map等复杂类型都可，value为字符串的值。-->
        <property name="stringValue" value="setter://"></property>
    </bean>

    <!-- P标签注入，需要类中有"setter方法"，用来简化property -->
    <bean id="userServiceP" class="com.herr.xml.UserService" p:stringValue="p://"/>

    <!-- autowire默认为no，即不自动注入。如注入需要使用property属性设置 -->
    <bean id="userServiceNotAuto" class="com.herr.xml.UserService" autowire="no"></bean>

    <!-- 根据名字自动注入，会找UserService类属性userDao同名的Bean，即xml中第1个配置的bean -->
    <bean id="userServiceAuto" class="com.herr.xml.UserService" autowire="byName"></bean>
    <!-- 由于有多个定义的bean是UserDao类型的，会报错 -->
    <!-- <bean id="userServiceAuto" class="com.herr.xml.UserService" autowire="byType"></bean> -->

</beans>

使用Spring的xml配置方式，可以对比上方的传统方式，便于理解IoC。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
//com.herr.xml为使用xml配置方式，由XMLTest.java进行测试。  
public class XMLTest {

    @Test
    //Spring的xml配置创建对象，使用类的默认的无参构造器
    public void testSpringCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userDao");
        userDao.printName();
    }

    @Test
    //Spring的xml配置创建对象。使用静态工厂创建，创建静态方法，返回类的对象
    public void testSpringStaticFactoryCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userDao2");
        userDao.printName();
    }

    @Test
    //Spring的xml配置创建对象。使用实例工厂创建，创建实例方法，返回类的对象
    public void testSpringFactoryCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userDao3");
        userDao.printName();
    }

    @Test
    //Spring的xml配置，通过有参构造注入属性
    public void testSpringConstructor(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserDao userDao =(UserDao) context.getBean("userConstructor");
        userDao.printAge();
    }

    @Test
    //Spring的xml配置，通过setter注入属性
    public void testSpringSetter(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userService");
        userService.printName();
        userService.printString();
    }

    @Test
    //Spring的xml配置，通过P标签注入属性
    public void testSpringForPLabel(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userServiceP");
        userService.printString();
    }

    @Test
    //Spring的xml配置，自动根据name注入属性
    public void testSpringForAutowire(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userServiceAuto");
        userService.getUserDao().printName();
    }

    @Test
    //Spring的xml配置，不自动或手动注入属性，userDao会报空指针异常，因为没有进行属性装配。
    public void testSpringForNotAutowire(){
        ApplicationContext context=new ClassPathXmlApplicationContext("xml-bean.xml");
        UserService userService =(UserService) context.getBean("userServiceNotAuto");
        userService.getUserDao().printName();
    }
}

class BeanFactory {
    //使用实例方法返回UserDao对象
    public UserDao getUserDao(){
        return new UserDao();
    }
}

class StaticBeanFactory {
    //使用静态方法返回UserDao对象
    public static UserDao getUserDao(){
        return new UserDao();
    }
}

Spring基于注解的配置

1、声明Bean的注解，以下方式是等效的。

  • @Component，没有明确角色。
  • @Controller，在展现层/控制层（web层）使用。@RestController，相当于@Controller和@ResponseBody的组合
  • @Service，在业务逻辑层（service层）使用
  • @Repository，在数据访问层/持久层（dao层）使用。

2、注入Bean的注解，可注解在set方法或者属性上（优先属性）。

  • @Autowired，为Spring提供的注解，默认使用type进行匹配，如果有匹配到多个，会根据name来查找，如果匹配为空，会抛出异常，可使用required=false来处理。如果需要按name进行装配，则需要配合@Qualifier。
  • @Resource，@Inject，为JSR提供的注解，默认使用name进行匹配，如果没有匹配到name，会继续按type。

annotation-bean.xml文件，只用来配置注解扫描

1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!--相比xml配置，注解配置在上方需要添加context相关schema-->
    <!-- 开启注解扫描，到包里面扫描类、方法和属性是否有注解 -->
    <context:component-scan base-package="com.herr.annotation"/>

</beans>

实体类，PersonDao和PersonService

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.herr.annotation;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//默认为@Component(value="personDao")，相当于<bean id="" class="">
@Component(value = "personDao123")
//默认为@Scope(value = "singleton")，为单例时，如同时实例化两个对象，两个对象地址一致。
//@Scope(value = "prototype")
public class PersonDao {

    public void printName(){
        System.out.println("herr");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.herr.annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class PersonService {
    //自动注入，根据类名type来找。如需要根据name进行，需要配合@Qualifier
    //使用注解方式时不需要set方法
    @Autowired
    private PersonDao personDao;

    //@Resource，@Inject，为JSR提供的注解，默认使用name进行匹配
    @Resource(name = "personDao123")
    private PersonDao personDao123;

    public void printNameByAutowired(){
        System.out.println(personDao);
        personDao.printName();
    }

    public void printNameByResource(){
        System.out.println(personDao123);
        personDao123.printName();
    }

}

测试Bean创建和注入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//com.herr.annotation为使用注解配置方式，由AnnotationTest.java进行测试。  
public class AnnotationTest {

    @Test
    //Spring的注解方式，创建对象
    public void testSpringAnnotationCreate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("annotation-bean.xml");
        PersonDao personDao =(PersonDao) context.getBean("personDao123");
        personDao.printName();
    }

    @Test
    //Spring的注解方式，通过setter注入属性
    public void testSpringAnnotationSetter(){
        ApplicationContext context=new ClassPathXmlApplicationContext("annotation-bean.xml");
        PersonService personService =(PersonService) context.getBean("personService");
        //当PersonService的注入属性PersonDao的Scope为单例时，两个对象打印出的地址一致。如为多例时，地址不一致。
        personService.printNameByAutowired();
        personService.printNameByResource();
    }
}

基于Java类配置

可通过@Configuration和@Bean来实现。@Configuration声明当前类是一个配置类，相当于一个xml文件。@Bean注解在方法上，声明当前方法的返回值是一个Bean。

配置类，JavaConfig、JavaImportConfig、MixConfig

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Configuration
public class JavaConfig {

    // 任何标志了@Bean的方法，其返回值将作为一个bean注册到Spring的IOC容器中
    // 方法名默认成为该bean定义的id，即userDao2
    @Bean
    public UserDao userDao2(){
        return new UserDao();
    }

    // 如果一个bean依赖另一个bean，则直接调用对应JavaConfig类中依赖bean的创建方法即可
    // 1、参数写法，方便跨java类使用
    @Bean
    public UserService userService(UserDao userDao){
        UserService userService=new UserService();
        userService.setUserDao(userDao);
        return userService;
    }

    @Bean
    public UserService userService2(){
        UserService userService=new UserService();
        //2、直接调用userDao2()
        userService.setUserDao(userDao2());
        return userService;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
@Import(JavaConfig.class)
public class JavaImportConfig {

    @Bean
    public UserService userService3(UserDao userDao){
        UserService userService=new UserService();
        userService.setUserDao(userDao);
        return userService;
    }

}

以上java配置中的userDao方法，等同于在xml的配置。

1
2
3
<beans>    
    <bean id="userDao2" class="com.herr.xml.UserDao"/>    
</beans> 
1
2
3
4
5
@Configuration
//配置扫描包里的所有注解，注意包名需要对应
@ComponentScan("com.herr.annotation")
public class MixConfig {
}

基于注解和基于java类的混合配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// com.herr.mix为使用java类和注解混合方式配置，由MixTest.java进行测试。  
public class MixTest {

    @Test
    //Spring的java类配置方式，创建对象
    public void testSpringJavaConfigCreate() {
        ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class, JavaImportConfig.class);
        //根据type获取
        UserDao userDao = context.getBean(UserDao.class);
        //根据name获取
        UserDao userDao2 = (UserDao) context.getBean("userDao2");
        //发现2个UserService的bean会报错
        //UserService userService = context.getBean(UserService.class);
        UserService userService = (UserService) context.getBean("userService2");
        UserService userService3 = (UserService) context.getBean("userService3");
        userDao.printName();
        userService.getUserDao().printName();
    }

    @Test
    //Spring的java类配置方式，自动扫描com.herr.annotation包注解，创建对象
    public void testSpringMixConfigCreate() {
        ApplicationContext context = new AnnotationConfigApplicationContext(MixConfig.class);
        PersonDao personDao = context.getBean(PersonDao.class);
        personDao.printName();
    }
}

三、AOP相关概念

相关概念

  • 切面（aspect），类是对物体特征的抽象，切面就是对横切关注点的抽象，抽象成一个类。
  • 横切关注点，对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点。
  • 连接点（joinpoint），是在应用执行过程中能够插入切面的一个点，是一个虚拟的概念。因为Spring基于动态代理，所以连接点只能是方法，实际上连接点还可以是字段或者构造器。
  • 切点（pointcut），对连接点进行拦截的规则，可基于注解或基于方法规则。
  • 建言（advice，也叫通知），所谓建言指的就是指拦截到连接点之后要执行的代码，分为前置、后置、环绕、异常、最终五类。
  • 目标对象，代理的目标对象
  • 织入（weave），将切面应用到目标对象并导致代理对象创建的过程
  • 引入（introduction），在不修改代码的前提下，引入可以在运行期，为类动态的添加一些方法或字段。

面向切面编程（AOP，Aspect Oriented Programming）

  • AOP是面向对象编程（OOP）的延续。这种采用切面进行横向抽取机制的方式，采用传统的OOP思想显然是无法办到的，因为OOP只能实现父子关系的纵向的重用。
  • AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，而一些公用的权限认证、日志、事务则是横切关注点，他分布在核心关注点的各处。AOP的作用在于将系统中的核心关注点和横切关注点分离开来，即把业务逻辑和系统服务分开。
  • Spring IOC用于解决对象依赖之间的解耦，而Spring AOP则用于解决业务依赖之间的解耦。AOP可以剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，便于减少系统的重复代码。
  • Spring中的AOP是基于动态代理实现的，即JDK动态代理和Cglib动态代理。对目标对象，动态创建代理对象，在不修改目标对象代码情况下，实现功能增强。如需要了解动态代理，可参考《Java基础》里的“动态代理”章节。

AOP应用场景

  • Authentication，权限、安全
  • Caching，缓存
  • Context passing，内容传递
  • Error handling，错误处理
  • Lazy loading，懒加载
  • Debugging，调试
  • logging tracing profiling and monitoring，日志的记录跟踪 优化 校准
  • Performance optimization，性能优化
  • Persistence，持久化
  • Resource pooling，资源池
  • Synchronization，同步
  • Transactions，事务

AspectJ

  • AspectJ是一个面向切面的框架，基于静态代理，在编译时将Aspect织入Java字节码，运行的时候就是经过增强之后的AOP对象。
  • AspectJ的拦截方式分为基于注解拦截和基于方法规则拦截两种，Spring本身在事务处理（@Transactional）和数据缓存（@Cacheable）上有使用注解拦截。
  • 定义连接点，使用@interface定义一个注解，符合条件的每一个被拦截处为连接点，在连接点的方法前使用该注解。
  • 定义切面，使用@Aspect声明某个类是一个切面。需要使用@EnableAspectJAutoProxy允许AspectJ。
  • 可定义切点，使用@Pointcut定义，可基于注解（使用@annotation）或方法（使用execution）。使用@PointCut专门定义拦截规则，是为了在各种建言中复用切点。当然也可以不用抽象，直接在建言中创建。
  • 定义建言，使用@After、@Before、@Around定义建言（Advice），可直接将拦截规则（切点）作为参数。

四、Spring AOP代码实践

1、pom.xml

1
2
3
4
5
6
7
8
9
10
<dependencies>
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjrt</artifactId>
       </dependency>
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
       </dependency>
   </dependencies>

2、Action.java，基于注解定义切片时使用

1
2
3
4
5
6
7
8
9
10
package com.herr.aop;

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Action {
    String name();
}

3、AnnotationService.java，业务代码，通过注解设置连接点

1
2
3
4
5
6
7
8
9
10
11
package com.herr.aop;

import org.springframework.stereotype.Service;

@Service
public class AnnotationService {
    @Action(name="注解式拦截的add操作")
    public void add(){
       System.out.println("AnnotationService.add()");
    }
}

4、MethodService.java，业务代码，连接点没有特殊标记，可直接基于方法拦截

1
2
3
4
5
6
7
8
9
10
package com.herr.aop;

import org.springframework.stereotype.Service;

@Service
public class MethodService {
    public void add(){
        System.out.println("MethodService.add()");
    }
}

5、AopConfig.java，AOP配置

1
2
3
4
5
6
7
8
9
10
11
package com.herr.aop;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.herr.aop")
@EnableAspectJAutoProxy
public class AopConfig {
}

6、LogAspect.java，定义切面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.herr.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class LogAspect {

    //定义切点，基于注解，凡是使用了该注解的连接点
    @Pointcut("@annotation(com.herr.aop.Action)")
    public void annotationPointCut(){

    }

    //建言指的就是指拦截到连接点之后要执行的代码，分为前置、后置、环绕、异常、最终。@Before代表前置
    @After("annotationPointCut()")
    public void after(JoinPoint joinPoint){
        MethodSignature signature=(MethodSignature)joinPoint.getSignature();
        Method method=signature.getMethod();
        Action action=method.getAnnotation(Action.class);
        System.out.println("注解式拦截，"+action.name());
    }

    /**
     * 可使用execution定义基于方法的切点
     * *代表返回任意类型
     * com.herr.aop.MethodService.*代表对应的方法
     * (..)代表使用任意参数
     */
    @Before("execution(* com.herr.aop.MethodService.*(..))")
    public void before(JoinPoint joinPoint){
        MethodSignature signature=(MethodSignature)joinPoint.getSignature();
        Method method=signature.getMethod();
        System.out.println("方法式拦截，"+method.getName());
    }
}

7、AopTest.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.herr.aop;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class AopTest {

    @Test
    //Spring的java类配置方式，创建对象
    public void testSpringJavaConfigCreate(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AopConfig.class);
        AnnotationService annotationService=context.getBean(AnnotationService.class);
        MethodService methodService=context.getBean(MethodService.class);
        annotationService.add();
        methodService.add();
    }
}

四、Spring IoC源码解析

BeanFactory

  • BeanFactory，以Factory结尾，表示它是一个工厂类(接口)，它负责生产和管理bean的一个工厂。
  • 在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
  • BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，如 DefaultListableBeanFactory、ApplicationContext等。

  • ListableBeanFactory，被ApplicationContext继承。可以获取多个Bean，而顶层的BeanFactory是获取单个Bean的。
  • HierarchicalBeanFactory，在应用中起多个BeanFactory，然后可以将各个BeanFactory设置为层级关系。被ApplicationContext继承。
  • AutowireCapableBeanFactory，用于自动装配Bean。ApplicationContext使用了组合。
  • ConfigurableListableBeanFactory也是一个特殊的接口，它继承了第二层所有的3个接口，而ApplicationContext 没有。
  • DefaultListableBeanFactory，是一个比较通用的 BeanFactory 实现，它同时也实现了 BeanDefinitionRegistry 接口，因此它就承担了 Bean 的注册管理工作。
  • FactoryBean，这个类和BeanFactory容易混淆，是个工厂类接口，用户通过实现该接口来单独定制实例化bean，而不用使用传统的BeanFactory流程。

ApplicationContext

ApplicationContext，是spring继BeanFactory之外的另一个核心接口或容器，允许容器通过应用程序上下文环境创建、获取、管理bean。为应用程序提供配置的中央接口。一个ApplicationContext提供:

  • 访问应用程序组件的Bean工厂方法。从org.springframework.beans.factory.ListableBeanFactory继承。
  • 以通用方式加载文件资源的能力。继承自org.springframe.core.io。ResourceLoader接口。
  • 向注册侦听器发布事件的能力。继承自ApplicationEventPublisher接口。
  • 解析消息的能力，支持国际化。继承自MessageSource接口。

  • ClassPathXmlApplicationContext，根据ClassPath中的xml构建上下文。
  • FileSystemXmlApplicationContext，根据文件系统中的xml配置构建。
  • AnnotationConfigApplicationContext，是基于注解来构建，它不需要配置文件，采用java配置类和各种注解来配置。

BeanDefinition

我们定义的各个 Bean ，会转换成一个个 BeanDefinition 存在于 Spring 的 BeanFactory 中（一般在DefaultListableBeanFactory类的beanDefinitionMap属性）。BeanDefinition 中保存了 Bean 信息，比如这个 Bean 指向的是哪个类、是否是单例的、是否懒加载、依赖了哪些 Bean 等等。

BeanDefinitionRegistry 接口则包含 registerBeanDefinition、removeBeanDefinition、getBeanDefinition 等注册管理 BeanDefinition 的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    //默认只提供 sington 和 prototype 两种，其他的属于基于web的扩展
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";

    //父 Bean
    void setParentName(@Nullable String var1);
    @Nullable
    String getParentName();

    //Bean的类名称
    void setBeanClassName(@Nullable String var1);
    @Nullable
    String getBeanClassName();

    //Bean的scope
    void setScope(@Nullable String var1);
    @Nullable
    String getScope();

    //懒加载
    void setLazyInit(boolean var1);
    boolean isLazyInit();

    //Bean的依赖Bean
    void setDependsOn(@Nullable String... var1);
    @Nullable
    String[] getDependsOn();

    //Bean的注入
    void setAutowireCandidate(boolean var1);
    boolean isAutowireCandidate();

    void setPrimary(boolean var1);
    boolean isPrimary();

    //Bean的工厂名称
    void setFactoryBeanName(@Nullable String var1);
    @Nullable
    String getFactoryBeanName();

    //Bean的工厂方法
    void setFactoryMethodName(@Nullable String var1);
    @Nullable
    String getFactoryMethodName();

    //构造器
    ConstructorArgumentValues getConstructorArgumentValues();
    default boolean hasConstructorArgumentValues() {
        return !this.getConstructorArgumentValues().isEmpty();
    }

    //属性值注入
    MutablePropertyValues getPropertyValues();
    default boolean hasPropertyValues() {
        return !this.getPropertyValues().isEmpty();
    }

    ...
    //是否Singleton
    boolean isSingleton();
    //是否Prototype
    boolean isPrototype();
    //是否抽象类
    boolean isAbstract();

    @Nullable
    String getResourceDescription();

    @Nullable
    BeanDefinition getOriginatingBeanDefinition();
}

核心源码

版本是5.2.9，以ClassPathXmlApplicationContext举例，相关代码如下,使用了ClassPathXmlApplicationContext进行初始化。

1
2
3
4
5
6
7
@Test
//Spring的注解方式，创建对象
public void testSpringAnnotationCreate(){
    ApplicationContext context=new ClassPathXmlApplicationContext("annotation-bean.xml");
    PersonDao personDao =(PersonDao) context.getBean("personDao123");
    personDao.printName();
}

ClassPathXmlApplicationContext类中进行了refresh操作，销毁原来的ApplicationContext，重新执行初始化操作。

1
2
3
4
5
6
7
8
9
10
11
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
    this(new String[]{configLocation}, true, (ApplicationContext)null);
}

public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
    super(parent);
    this.setConfigLocations(configLocations);
    if (refresh) {
        this.refresh();
    }
}

调用AbstractApplicationContext类进行refresh操作，核心方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public void refresh() throws BeansException, IllegalStateException {
    //上锁，避免重复创建
    synchronized(this.startupShutdownMonitor) { 
        // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
        this.prepareRefresh();
        // 重要。容器准备阶段，配置文件被解析成一个个Bean定义，注册到BeanFactory，最重要的部分，初始化BeanFactory，加载Bean，注册Bean到相应的 BeanDefinitionRegistry，但未初始化Bean
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); //切入代码，核心
        this.prepareBeanFactory(beanFactory);

        try {
            //Bean如果实现BeanFactoryPostProcessor接口，可在Bean加载注册完成，但未初始化前，执行该方法
            this.postProcessBeanFactory(beanFactory);
            this.invokeBeanFactoryPostProcessors(beanFactory);
            //注册 BeanPostProcessor 的实现类
            this.registerBeanPostProcessors(beanFactory);
            //国际化，初始化MessageSource
            this.initMessageSource();
            //初始化事件广播器
            this.initApplicationEventMulticaster();
            //子类可以根据模板方法自定义
            this.onRefresh();
            //注册事件监听器
            this.registerListeners();
            //重要。Bean的实例化阶段，初始化所有的 singleton beans（lazy-init 的除外）
            this.finishBeanFactoryInitialization(beanFactory);
            //广播事件，初始化完成
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}

obtainFreshBeanFactory方法会初始化 BeanFactory、加载 Bean、注册 Bean 等等。

1
2
3
4
5
6
7
8
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    this.refreshBeanFactory();
    return this.getBeanFactory();
}
// 抽象方法，由ClassPathXmlApplicationContext的父类抽象类AbstractRefreshableApplicationContext实现
protected abstract void refreshBeanFactory() throws BeansException, IllegalStateException;

public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

AbstractRefreshableApplicationContext的refreshBeanFactory方法。

DefaultListableBeanFactory实现了ConfigurableListableBeanFactory接口，而ConfigurableListableBeanFactory接口继承了BeanFactory下面一层的所有三个接口。DefaultListableBeanFactory是最高实现类，基本包含了BeanFactory相关的所有操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
protected final void refreshBeanFactory() throws BeansException {
    // 如果ApplicationContext加载过BeanFactory，则销毁所有Bean，然后关闭BeanFactory
    if (this.hasBeanFactory()) {
        this.destroyBeans();
        this.closeBeanFactory();
    }

    try {
        // 初始化DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = this.createBeanFactory();
        // 序列化
        beanFactory.setSerializationId(this.getId());
        // 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
        this.customizeBeanFactory(beanFactory);
        // 加载 Bean 到 BeanFactory 中
        this.loadBeanDefinitions(beanFactory);//切入代码
        // ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相关的操作其实是给它处理。
        this.beanFactory = beanFactory;
    } catch (IOException var2) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2);
    }
}

//配置是否允许 BeanDefinition 覆盖、是否允许循环引用
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    // 覆盖默认为null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }

    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }

}
//抽象方法，由于使用的是ClassPathXmlApplicationContext，由其父类AbstractXmlApplicationContext实现
protected abstract void loadBeanDefinitions(DefaultListableBeanFactory var1) throws BeansException, IOException;

AbstractXmlApplicationContext类，使用XmlBeanDefinitionReader负责加载配置、解析。以下步骤较多，均为解析xml文件，加载Bean。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
   protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
       XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
       beanDefinitionReader.setEnvironment(this.getEnvironment());
       beanDefinitionReader.setResourceLoader(this);
       beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
       this.initBeanDefinitionReader(beanDefinitionReader);
       this.loadBeanDefinitions(beanDefinitionReader); //切入代码
   }

   protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
       Resource[] configResources = this.getConfigResources();
       if (configResources != null) {
           reader.loadBeanDefinitions(configResources);
       }

       String[] configLocations = this.getConfigLocations();
       if (configLocations != null) {
           reader.loadBeanDefinitions(configLocations); //切入代码
       }

   }
   protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations); //切入代码
	}
}

   
   //AbstractBeanDefinitionReader类
   @Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
	Assert.notNull(locations, "Location array must not be null");
	int count = 0;
	for (String location : locations) {
		count += loadBeanDefinitions(location); //切入代码
	}
	return count;
}

   @Override
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
	return loadBeanDefinitions(location, null); //切入代码
}

   public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
	ResourceLoader resourceLoader = getResourceLoader();
       ...
	if (resourceLoader instanceof ResourcePatternResolver) {
		try {
			Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
			int count = loadBeanDefinitions(resources); //切入代码
			...
			return count;
		}
		...
	}
	...
}

   ... //切入代码

   public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
	...

	try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
		InputSource inputSource = new InputSource(inputStream);
		if (encodedResource.getEncoding() != null) {
			inputSource.setEncoding(encodedResource.getEncoding());
		}
		return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); //切入代码，do***，代表实际干活的
	}
	...
}

   protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
		throws BeanDefinitionStoreException {
	try {
		Document doc = doLoadDocument(inputSource, resource);
		int count = registerBeanDefinitions(doc, resource);//切入代码
           ...
		return count;
	}
	...
}

   public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
	BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
	int countBefore = getRegistry().getBeanDefinitionCount(); 
	documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); //切入代码
	return getRegistry().getBeanDefinitionCount() - countBefore;
}

   //DefaultBeanDefinitionDocumentReader类
   @Override
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
	this.readerContext = readerContext;
	doRegisterBeanDefinitions(doc.getDocumentElement());
}

   protected void doRegisterBeanDefinitions(Element root) {
       //负责解析Bean定义
	BeanDefinitionParserDelegate parent = this.delegate;
	this.delegate = createDelegate(getReaderContext(), root, parent);

	if (this.delegate.isDefaultNamespace(root)) {
           //profile，环境配置
		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
		if (StringUtils.hasText(profileSpec)) {
			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
		}
	}

	preProcessXml(root); //子类的钩子方法
	parseBeanDefinitions(root, this.delegate); //切入代码，核心解析方法
	postProcessXml(root);//子类的钩子方法

	this.delegate = parent;
}

   protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	if (delegate.isDefaultNamespace(root)) {
		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)) {
					parseDefaultElement(ele, delegate); //解析的节点有 <import>、<alias>、<bean>、<beans> 
				}
				else {
					delegate.parseCustomElement(ele);//解析的节点有<mvc>、<task>、<context>、<aop>
				}
			}
		}
	}
	else {
		delegate.parseCustomElement(root);
	}
}

   private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
       // 处理 <import> 标签
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
       // 处理 <alias> 标签
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
       // 处理 <bean> 标签
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate); //切入代码
	}
       // 处理 <beans> 标签
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// 递归
		doRegisterBeanDefinitions(ele);
	}
}

   //Bean处理
   protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
       //解析<bean>节点，转换为BeanDefinitionHolder。//切入代码1
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 注册Bean。//切入代码2
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// Send registration event.
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

   //BeanDefinitionParserDelegate类
   @Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
	return parseBeanDefinitionElement(ele, null);
}

   @Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
	...
	AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); //切入代码
	if (beanDefinition != null) {
		...
		String[] aliasesArray = StringUtils.toStringArray(aliases);
		return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
	}

	return null;
}

   //根据 <bean> 配置创建了一个 BeanDefinitionHolder实例
   @Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
		Element ele, String beanName, @Nullable BeanDefinition containingBean) {

	this.parseState.push(new BeanEntry(beanName));

	String className = null;
	if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
		className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
	}
	String parent = null;
	if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
		parent = ele.getAttribute(PARENT_ATTRIBUTE);
	}

	try {
		AbstractBeanDefinition bd = createBeanDefinition(className, parent);

		parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
		bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

		// 解析 <meta>
           parseMetaElements(ele, bd);
           // 解析 <lookup-method>
           parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
           // 解析 <replaced-method>
           parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
           // 解析 <constructor-arg>
           parseConstructorArgElements(ele, bd);
           // 解析 <property>
           parsePropertyElements(ele, bd);
           // 解析 <qualifier>
           parseQualifierElements(ele, bd);

		bd.setResource(this.readerContext.getResource());
		bd.setSource(extractSource(ele));

		return bd;
	}
	...

	return null;
}

以上的流程为根据xml解析节点，转换为BeanDefinitionHolder。里面包含了BeanDefinition。
下面开始Bean的注册。还是从刚才DefaultBeanDefinitionDocumentReader类的processBeanDefinition方法开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
   //Bean处理
   protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
       //解析<bean>节点，转换为BeanDefinitionHolder。切入代码
	BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
	if (bdHolder != null) {
		bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
		try {
			// 注册Bean。//切入代码
			BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
		}
		catch (BeanDefinitionStoreException ex) {
			getReaderContext().error("Failed to register bean definition with name '" +
					bdHolder.getBeanName() + "'", ele, ex);
		}
		// Send registration event.
		getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
	}
}

来到BeanDefinitionReaderUtils类

1
2
3
4
5
6
7
public static void registerBeanDefinition(
		BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
		throws BeanDefinitionStoreException {
	String beanName = definitionHolder.getBeanName();
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); //使用BeanDefinitionRegistry类注册这个Bean
	...
}

DefaultListableBeanFactory实现了BeanDefinitionRegistry的接口。它初始化了 Bean 容器， 配置也相应的转换为了一个个 BeanDefinition，然后注册了各个 BeanDefinition 到注册中心，并且发送了注册事件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
@Override
	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {
        //判断Bean是否已注册，已注册的Bean会放到beanDefinitionMap
		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
        //如果有相同名称的Bean注册
		if (existingDefinition != null) {
            //根据是否被允许覆盖抛异常
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				...
                //用框架定义的Bean覆盖用户自定义的Bean
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				//用新的Bean覆盖旧的Bean
			}
			else {
				...
			}
            //覆盖
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
            //未注册，需要注册，但还未初始化。在Spring容器启动的最后，才会预初始化所有的 singleton beans
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// 仍然在注册阶段，大部分情况走这个分支
                //beanDefinitionMap保存了所有的beanDefinition
				this.beanDefinitionMap.put(beanName, beanDefinition);
                //会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
				this.beanDefinitionNames.add(beanName);
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			clearByTypeCache();
		}
	}

回到AbstractApplicationContext类的refresh方法，上面的代码都是执行的obtainFreshBeanFactory方法，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void refresh() throws BeansException, IllegalStateException {
    //上锁，避免重复创建
    synchronized(this.startupShutdownMonitor) { 
        // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
        this.prepareRefresh();
        // 配置文件被解析成一个个Bean定义，注册到BeanFactory，最重要的部分，初始化BeanFactory，加载Bean，注册Bean，但未初始化Bean
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); //切入代码，核心
        // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
        this.prepareBeanFactory(beanFactory); //切入代码，核心

        try {
            ...
            //初始化所有的 singleton beans（lazy-init 的除外）
            this.finishBeanFactoryInitialization(beanFactory); //切入代码，核心
            ...
        }
    }
}

prepareBeanFactory用来准备Bean容器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 这是BeanFactory的加载类，为当前ApplicationContext的加载类
		beanFactory.setBeanClassLoader(getClassLoader());
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// Register early post-processor for detecting inner beans as ApplicationListeners.
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// environment的Bean，没有自定义就自动生成默认
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
        // systemProperties的Bean，没有自定义就自动生成默认
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
        // systemEnvironment的Bean，没有自定义就自动生成默认
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

finishBeanFactoryInitialization用来初始化所有的 singleton beans。十分重要。

到目前为止，BeanFactory 已经创建完成，并且所有的实现了 BeanFactoryPostProcessor 接口的 Bean 都已经初始化并且其中的 postProcessBeanFactory(factory) 方法已经得到执行了。所有实现了 BeanPostProcessor 接口的 Bean 也都完成了初始化。剩下的就是初始化其他还没被初始化的 singleton beans 了，我们知道它们是单例的，如果没有设置懒加载，那么 Spring 会在接下来初始化所有的 singleton beans。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化名字为 conversionService 的 Bean
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }
    ...

    // 开始初始化前，不允许进行Bean的解析、加载和注册了
    beanFactory.freezeConfiguration();

    // 初始化所有剩余的非懒加载的 singleton beans
    beanFactory.preInstantiateSingletons();
}

回到了DefaultListableBeanFactory这个类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Override
public void preInstantiateSingletons() throws BeansException {
    //获取所有BeanNames
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // 遍历进行初始化
    for (String beanName : beanNames) {
        //Bean继承
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //非抽象、非懒加载、且是singleton的Bean才可初始化
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                ...
                //FactoryBean的处理
            }
            else {
                //普通Bean的处理
                getBean(beanName); //代码切入
            }
        }
    }

    // Bean如果实现了SmartInitializingSingleton接口，可在这回调。
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            ...
        }
    }
}

进入到getBean方法，跳转到AbstractBeanFactory类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

//已经初始化过了就从容器中直接返回，否则就先初始化再返回
protected <T> T doGetBean(
        String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
        throws BeansException {

    String beanName = transformedBeanName(name);
    //返回值
    Object bean;

    // 检查是否创建过了
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        ...
        //如果是普通Bean直接返回sharedInstance，如果是FactoryBean则返回他创建的实例对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 当前线程已经创建过了此 beanName 的 prototype 类型的 bean，那么抛异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        // 检查这个 BeanDefinition 在容器中是否存在
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 没找到 -> 检查父容器
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
                // 返回父容器的查询结果
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
                // No args -> delegate to standard getBean method.
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }

        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }

        try {
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 先初始化依赖的所有 Bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // 检查是不是有循环依赖
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }
                    // 注册一下依赖关系
                    registerDependentBean(dep, beanName);
                    try {
                        // 先初始化被依赖项
                        getBean(dep);
                    }
                    catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                    }
                }
            }

            // 创建 singleton 的实例
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args); //执行创建 Bean，代码切入
                    }
                    catch (BeansException ex) {
                        // Explicitly remove instance from singleton cache: It might have been put there
                        // eagerly by the creation process, to allow for circular reference resolution.
                        // Also remove any beans that received a temporary reference to the bean.
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            // 创建 prototype 的实例
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args); //执行创建 Bean，代码切入
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            // 如果不是 singleton 和 prototype 的话，需要委托给相应的实现类来处理
            else {
                String scopeName = mbd.getScope();
                if (!StringUtils.hasLength(scopeName)) {
                    throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                }
                Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }
                        finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }
                catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            "Scope '" + scopeName + "' is not active for the current thread; consider " +
                            "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                            ex);
                }
            }
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // 最后，检查一下类型对不对，不对的话就抛异常，对的话就返回了
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }
        catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Failed to convert bean '" + name + "' to required type '" +
                        ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    return (T) bean;
}

// createBean是个抽象类，方法实现在AbstractAutowireCapableBeanFactory
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException;

AbstractAutowireCapableBeanFactory类有createBean的实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {
    RootBeanDefinition mbdToUse = mbd;

    // 确保 BeanDefinition 中的 Class 被加载
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // 准备方法覆写，MethodOverrides，来自于 bean 定义中的 <lookup-method> 和 <replaced-method>节点
    try {
        mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, "Validation of method overrides failed", ex);
    }

    try {
        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }

    try {
        Object beanInstance = doCreateBean(beanName, mbdToUse, args); //切入代码，创建Bean
        return beanInstance;
    }
    ...
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
        throws BeanCreationException {

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        //不是 FactoryBean，这里实例化 Bean。重要。切入代码
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    ...

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        //属性装配，因为前面的实例只是实例化了，并没有设值，这里就是设值。重要。切入代码
        populateBean(beanName, mbd, instanceWrapper);
        // 处理 bean 初始化完成后的各种回调，InitializingBean、BeanPostProcessor等接口
        exposedObject = initializeBean(beanName, exposedObject, mbd); //切入代码
    }
    ...
    // Register bean as disposable.
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }

    return exposedObject;
}

创建 Bean 实例的createBeanInstance方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // Make sure bean class is actually resolved at this point.
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    //访问权限
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }

    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    if (mbd.getFactoryMethodName() != null) {
        // 采用工厂方法实例化
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // Shortcut when re-creating the same bean...
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            // 构造函数依赖注入
            return autowireConstructor(beanName, mbd, null, null);
        }
        else {
            // 无参构造函数
            return instantiateBean(beanName, mbd);
        }
    }

    // 判断是否采用有参构造函数
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        // 构造函数依赖注入
        return autowireConstructor(beanName, mbd, ctors, args);
    }

    // Preferred constructors for default construction?
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }

    // No special handling: 调用无参构造函数
    return instantiateBean(beanName, mbd); //切入代码
}

//无参构造函数
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        if (System.getSecurityManager() != null) {
            beanInstance = AccessController.doPrivileged(
                    (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
                    getAccessControlContext());
        }
        else {
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this); //实例化，切入代码
        }
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
}

// 跳转到SimpleInstantiationStrategy
@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    // 如果不存在方法覆写，那就使用 java 反射进行实例化，否则使用 CGLIB
    if (!bd.hasMethodOverrides()) {
        Constructor<?> constructorToUse;
        synchronized (bd.constructorArgumentLock) {
            constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse == null) {
                final Class<?> clazz = bd.getBeanClass();
                if (clazz.isInterface()) {
                    throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }
                try {
                    if (System.getSecurityManager() != null) {
                        constructorToUse = AccessController.doPrivileged(
                                (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
                    }
                    else {
                        constructorToUse = clazz.getDeclaredConstructor();
                    }
                    bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                }
                catch (Throwable ex) {
                    throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                }
            }
        }
        //利用构造方法进行实例化
        return BeanUtils.instantiateClass(constructorToUse);
    }
    else {
        // 存在方法覆写，利用 CGLIB 来完成实例化
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
}

Bean属性注入的populateBean方法，仍然在AbstractAutowireCapableBeanFactory类中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    ...
    // bean 实例的所有属性
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        // 通过名字找到所有属性值，如果是 bean 依赖，先初始化依赖的 bean。记录依赖关系
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        // 通过类型装配
        if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }

    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

    PropertyDescriptor[] filteredPds = null;
    if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    if (filteredPds == null) {
                        filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                    }
                    // 有个非常有用的 BeanPostProcessor 进到这里: AutowiredAnnotationBeanPostProcessor
                    // 对采用 @Autowired、@Value 注解的依赖进行设值
                    pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        return;
                    }
                }
                pvs = pvsToUse;
            }
        }
    }
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }
    // 设置 bean 实例的属性值
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

处理Bean各种回调的initializeBean方法，仍然在AbstractAutowireCapableBeanFactory类中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        // 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // BeanPostProcessor 的 postProcessBeforeInitialization 回调
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 处理 bean 中定义的 init-method，或者如果 bean 实现了 InitializingBean 接口，调用 afterPropertiesSet() 方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        // BeanPostProcessor 的 postProcessAfterInitialization 回调
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

五、Spring Bean生命周期

Spring Bean的完整生命周期是个很重要的概念，从创建Spring容器开始，直到最终Spring容器销毁Bean。

Bean的完整生命周期经历了各种方法调用，可用来实现Spring的拓展机制。这些方法可以划分为以下几类：

  • Bean自身的方法，这个包括了Bean本身调用的方法和通过bean配置文件中init-method和destroy-method指定的方法
  • Bean级生命周期接口方法，这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
  • 容器级生命周期接口方法，这个包括了InstantiationAwareBeanPostProcessor、BeanPostProcessor和FactoryPostProcessor等接口
  • 工厂后处理器接口方法，这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等非常有用的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

BeanFactoryPostProcessor和BeanPostProcessor自定义

基础数据：

1
2
3
4
5
6
7
8
9
10
11
public class ProcessorDao {
    private int i=0;

    public void print(){
        System.out.println("processor");
    }

    public void init(){
        i=100;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
    <!--相比xml配置，注解配置在上方需要添加context相关schema-->
    <!-- 开启注解扫描，到包里面扫描类、方法和属性是否有注解 -->
    <context:component-scan base-package="com.herr.processor"/>
    <context:property-placeholder location="classpath:application.properties"/>

    <!-- xml中添加bean的init-method方法 -->
<!--    <bean id="processorDao" class="com.herr.processor.ProcessorDao" init-method="init"/>-->

</beans>

配置类：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Configuration
public class ProcessorConfig {

    //Spring默认有个PropertyPlaceholderConfigurer，作为BeanFactoryPostProcessor，在BeanFactory初始化后，用来处理占位符${a.port}
    @Value("${a.port}")
    private String port;

    //init方法，在MyBeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization之间调用
    @Bean(initMethod = "init")
    public ProcessorDao processorDao(){
        return new ProcessorDao();
    }
}

自定义BeanFactoryPostProcessor，实现BeanFactory初始化后的扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor, PriorityOrdered {
    //BeanFactory初始化后回调
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor test");
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

自定义BeanPostProcessor，实现Bean初始化前后的扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Component
public class MyBeanPostProcessor implements BeanPostProcessor, PriorityOrdered {
    //初始化前回调
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor-->postProcessBeforeInitialization");
        if (bean instanceof ProcessorDao) {
            System.out.println(beanName);
        }
        return bean;
    }
    //初始化后回调，中间会调用bean的init-method
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor-->postProcessAfterInitialization");
        return bean;

    }

    @Override
    public int getOrder() {
        return 0;
    }
}

六、本节代码

『源码传送门』

https://zhuanlan.zhihu.com/p/78104880 给你一份Spring Boot核心知识清单

https://zhuanlan.zhihu.com/p/368769721 面试题系列：Spring 夺命连环10问

https://www.zhihu.com/question/30212464/answer/1786967139 Spring 拦截器和过滤器的区别？

https://zhuanlan.zhihu.com/p/33296468 如何零基础搭建一套微服务框架（Spring Boot + Dubbo + Docker + Jenkins）

https://mp.weixin.qq.com/s/NfQ01aS6kDHczbRUJD1Y0w SpringBoot分片上传、断点续传、大文件极速秒传功能，这篇都帮你搞定！（典藏版）

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true