【spring源码】一、从spring的hello world开始重头嚼

前言

孤独是你长久的朋友，爱只会偶尔来敲门。掌好夜深的每一盏灯，爱来时窃窃听闻。

写此文章是为了复习，回顾自己掌握的知识，也希望自己的笔记能够帮助有需要的朋友，如有不正确的地方，还请不吝赐教，本系列文章会重新把Spring中的核心知识梳理一遍例如：

1. Bean的生命周期底层原理
2. 依赖注入底层原理
3. 初始化底层原理
4. 推断构造方法底层原理
5. AOP底层原理
6. Spring事物底层原理

本篇文章先从一个个简单Demo拉开序幕，简单了解一下上述知识点

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
//        ClassPathXmlApplicationContext context1 = new ClassPathXmlApplicationContext("spring.xml");
        final UserService userService = (UserService)context.getBean("userService");
        userService.test();
    }

对于上面几行代码，我们应该在熟悉不过了，在学习java的时候我们通常会从打印第一个hello world开始，同样这也是spring的hello world。可是这几行代码做了什么？

1. 第一行代码，会构造一个AnnotationConfigApplicationContext对象，那么AnnotationConfigApplicationContext如何理解，调用该构造方法会实例化得到一个对象，还会做哪些事情？
2. 第二行代码，调用getBean方法，会得到一个UserSerivce对象，getBean又是如何实现的？返回的UserService对象和我们自己new UserService()对象有区别吗？
3. 第三行代码，就是调用userService的test方法。

其实光看这几行代码，我们并不能看出来Spring的强大指出，也不能理解为什么需要AnnotationConfigApplicationContext和getBean()方法，这个会在后续文章中逐渐说明，在此处我们只需要知道，如果你想使用spring，你就得这么去写，就比如你要用mybatis，你就得写各种mapper接口。
其实与AnnotationConfigApplicationContext作用类似的还存在ClassPathXmlApplicationContext他们的作用其实非常类似，只不过后者是通过一个xml文件。但是在Spring3开始支持注解扫描因此ClassPathXmlApplicationContext也过时了，包括后续的spring boot也都是使用前者去进行的。

spring是如何创建一个对象？

其实不管是AnnotationConfigApplicationContext还是ClassPathXmlApplicationContext，我们暂且都可以将他们理解为创建java对象的，比如调用getBean()就会去创建对象 (getBean可能也不会去创建对象，后面会提到)

我们再来看一下代码

@ComponentScan(basePackages = "com.hy.spring")
public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
        final UserService userService = (UserService)context.getBean("userService");
        userService.test();
    }
}

当我们调用context.getBean(“userService”)时，就会去创建一个对象，但是getBean方法内部怎么知道userService对应的是UserService这个类呢？
这里我们看到第一行代码，在调用AnnotationConfigApplicationContext的构造方式时，会做一些事情：

1. 扫描Test类发现存在ComponentScan并且指定了包名，得到扫描路径。
2. 扫描路径下所有的Java类，如果发现了某个类上存在@Component、@Service等注解，那么Spring就把这个类记录下来，存在一个Map中 （实际上，Spring中确实存在一个类似的Map，叫做BeanDefinitionMap,后面会提到）
3. Spring会根据某些规则生成当前类的beanName，作为Map的key，当前类作为value。

这样我们在调用getBean(“userService”)，就可以得到对应的UserServcie，从而去创建对象了。

那么通过getBean得到的对象和我们new出来的对象有什么区别呢？我们来看一个简单例子。
创建一个类AbService

@Component
public class AbService {
}

在UserService中使用Autowired注入

@Component
public class UserService {

    @Autowired
    public AbService abService;

    public void test(){
        System.out.println("hello spring !");
    }
    public void test1(){
        System.out.println(abService == null);
    }
}

测试

public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
        final UserService userService = (UserService)context.getBean("userService");
        userService.test1(); //false
        final UserService userService1 = new UserService();
        userService1.test1(); // true
    }

可以看到打印结果一定是 false和true。

Bean的创建过程

其实不管Spring他有多么强大，只要想创建对象，他也一定要使用UserService.class的构造方法,大致过程如下:

1. 利用该类的构造方法实例化得到一个对象 (但是如果一个类中有多个构造方法，Spring会进行选择，这个叫做推断构造方法。)
2. 得到一个对象之后，Spring会判断该对象是否存在@Autowired注解的属性，把这些属性找出来进行赋值 (依赖注入)
3. 依赖注入后，spring会判断该类是否实现了BeanNameAware接口、BeanClassLoaderAware接口、BeanFactory接口、如果实现了，就表示当前对象必须实现该接口中所定义的setbeanName()、setBeanClassLoader()、setBeanFactory()方法，那Spring会调用这些方法并传入对应的参数 (Aware回调)
4. Aware回调后，Spring会判断该对象是否存在某个方法被@PostConstruct注解了，如果存在，Spring调用当前对象的此方法 (初始化前)
5. 然后，Spring会判断该对象是否实现了InitializingBean接口，如果实现了，就表示当前对象必须实现该接口中的afterPropertiesSet()方法，那Spring就会调用当前对象中的afterPropertiesSet()方法 (初始化)
6. 最后，Spring会判断当前对象需不需要进行AOP，如果不需要那么Bean就创建完成了，如果需要进行AOP，则会进行动态代理并生成一个代理对象作为Bean (初始化后)

通过最后一步，我们可以发现，当Spring根据UserService来创建一个Bean时：

• 如果不用进行AOP，那么Bean就是UserService类构造方法所得到的对象。
• 如果需要进行AOP，那么Bean就是UserService的代理类所实例化得到的对象，而不是UserService本身所得到的对象。

Bean对象创建出来后，

1. 如果当前Bean是单例Bean，那么会把该Bean对象存入一个Map，Map的key作为beanName，value为Bean对象。这样下次getBean时就可以直接从Map中拿到对应的Bean对象了。（实际上，在Spring中，这个Map就是单例池）
2. 如果当前Bean是原型Bean，那么后续没有其他动作，不会存入Map，下次getBean会再次执行上述创建过程，得到一个新的Bean对象。

@Component
public class UserService implements InitializingBean {

    @Autowired
    public AbService abService;

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("aaaaaaaaaaaa");
    }

    @PostConstruct
    public void init(){
        System.out.println("bbbbbbbbbbbbbb");
    }
}

@ComponentScan(basePackages = "com.hy.spring")
public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
        final UserService userService = (UserService)context.getBean("userService");
    }
}

//console
bbbbbbbbbbbbbb
aaaaaaaaaaaa

这里提一嘴，Spring是如何知道某个类是否有@PostConstruct注解或者实现了InitializingBean接口呢？

        //是否实现InitializingBean接口
        System.out.println( userService instanceof InitializingBean);

        //是否有某个注解
        for (Method method : userService.getClass().getMethods()) {
            if(method.isAnnotationPresent(PostConstruct.class)){
                System.out.println(true);
            }
        }

• 通过instanceof来判断是否实现了某个接口
• 通过类对象来判断方法是否存在某个注解。

通过上述描述，bean创建周期的大致过程如下：
UserService.class ----> 无参构造方法 ----> 对象 ----> 依赖注入(属性赋值) ---->初始化前(@PostConstruct) ----> 初始化(InitializingBean) ----> 初始化后(AOP) ----> Bean

当然过程远远不止这些，后面会在源码中一一说明。

推断构造方法

Spring在基于某个类生成Bean的过程中，需要利用该类的构造方法来实例化得到一个对象，但是如果一个类存在多个构造方法，Spring如何去选择呢？

@Component
public class UserService {

    public AbService abService;

    public UserService(){
        System.out.println("1");
    }

    public UserService(AbService abService){
        System.out.println("2");
    }

}

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
    }
//console
1

可以看到会使用无参构造。
在如下：

@Component
public class UserService {

    public AbService abService;

//    public UserService(){
//        System.out.println("1");
//    }

    public UserService(AbService abService){
        System.out.println("2");
    }
    public UserService(AbService abService,AbService abService1){
        System.out.println("3");
    }
}
//console
 No default constructor found; nested exception is java.lang.NoSuchMethodException: com.hy.spring.service.UserService.<init>()

可以看到报错，大致意思为没有默认的，Spring不知道去使用哪个构造方法，这里是Spring无法使用这两个构造方法嘛，并不是在看如下：

@Component
public class UserService {

    public AbService abService;

//    public UserService(){
//        System.out.println("1");
//    }
//
//    public UserService(AbService abService){
//        System.out.println("2");
//    }
    public UserService(AbService abService,AbService abService1){
        System.out.println("3");
    }
}
//console
3

可以使用。

大致判断逻辑如下：

1. 如果一个类中只存在一个构造方法，不管该构造方法是无参构造还是有参构造，Spring都用这个构造方法
2. 如果一个类中存在多个构造方法
   1. 这些构造方法中，存在一个无参的构造方法，那么Spring就会用这个无参的构造方法。
   2. 这些构造方法中，不存在一个无参的构造方法，那么Spring就会报错。

Spring设计思想是这样的：

1. 如果一个类中只有一个构造方法，那么没得选择，只能用这个构造方法。
2. 入宫一个类存在多个构造方法，Spring不知道如何选择，就会看是否有无参构造方法，因为无参构造本身就表示了一种默认的意义。
3. 不过某个构造方法上加了@Autowired注解，那表示告诉Spring使用这个加了注解的构造方法。

看如下测试：

@Component
public class UserService {

    public AbService abService;

//    public UserService(){
//        System.out.println("1");
//    }
//
    @Autowired
    public UserService(AbService abService){
        System.out.println("2");
        System.out.println(abService == null);
    }
    public UserService(AbService abService,AbService abService1){
        System.out.println("2");
    }
}
//console
2
false

发现并不会报错了。
需要注意的是，我们会发现abService不是null，是有值的，可以推断出Spring在调用这个有参构造时候，需要传入这个参数，那么这个参数是怎么来的呢？
其实Spring会根据入参的类型和入参的名字去Spring中Bean对象（以单例Bean为例，Spring会从单例池中的Map去找）：

1. 先根据入参类型找，如果只找到一个，那就直接用来入参。
2. 如果根据类型找到多个，则在根据入参名字来确定唯一一个。
3. 最终如果没有找到，则会报错，无法创建当前Bean对象。

看如下测试：
创建一个config

@Configuration
public class BeanConfig {


    @Bean
    public AbService abService1(){
        return new AbService();
    }

    @Bean
    public AbService abService2(){
        return new AbService();
    }
}

@Component
public class UserService {

    public AbService abService;

    public UserService(AbService abService){
        System.out.println("=======>"+abService);
    }
}

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
        System.out.println(context.getBean("abService"));
        System.out.println(context.getBean("abService1"));
        System.out.println(context.getBean("abService2"));
    }
//console
=======>com.hy.spring.service.AbService@54a7079e
com.hy.spring.service.AbService@54a7079e
com.hy.spring.service.AbService@2eae8e6e
com.hy.spring.service.AbService@8f2ef19

可以看到存在三个示例在spring容器中，此时userService的构造方法打印,并且userService中的对象为beanName为abService，我们修改一下UserService的参数名。

@Component
public class UserService {

    public AbService abService;

    public UserService(AbService abService1){
        System.out.println("=======>"+abService1);
    }
}
//可以发现此处打印的对象地址与System.out.println(context.getBean("abService1"));一致

如果我们再将方法中的参数名abService1改为abService123，则就会报错，因为Spring中不存在beanName为abService123。则无法创建Bean。

确定用哪个构造方法，确定入参的Bean对象，这个过程就叫做推断构造方法。

AOP大致流程

AOP就是进行动态代理，在创建一个Bean的过程中，Spring在最后一步回去判断当前正在创建的Bean是不是需要进行AOP，如果需要则进行动态代理。

如何判断当前Bean对象需不需要进行AOP：

1. 找出所有的切面Bean
2. 遍历切面中的每个方法，看看是否写了@Before、@After等注解
3. 如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配。
4. 如果匹配则表示当前Bean对象有匹配的Pointcut，表示需要进行AOP

先看例子：

@ComponentScan(basePackages = "com.hy.spring")
@EnableAspectJAutoProxy
public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Test.class);
        UserService userService = (UserService) context.getBean("userService");
        userService.test();
    }
}

@Component
public class UserService {

    @Autowired
    public AbService abService;

    public void test(){
        System.out.println(abService);
    }
}

@Aspect
@Component
public class AspectTest {

    @Before("execution(public void com.hy.spring.service.UserService.test())")
    public void test(JoinPoint joinPoint){
        System.out.println("sssd");
    }
}

可以发现此时得到的UserService是一个代理对象，并且abService属性是没有值的，其实可以先简单根据上面的Bean创建流程大致理解为在AOP之后并没有执行依赖注入操作，直接创建了Bean，那么UserService中的@Autowired注解就没有用了嘛，其实不然，他还是生效了的，继续执行上述断点进入方法：

可以发现在方法路面abService还是有值的，那为什么在前面没有值，在方法内部就存在值了呢？
这里说下cglib进行AOP的大致流程。

1. 生产UserServiceProxy，代理类集成UserService。
2. 代理类中重写了父类方法，比如UserService中的test方法。
3. 代理类中还会有一个target属性，该属性的值为被代理对象（也就是通过UserService类推断构造方法实例化出来的对象，进行了依赖注入，初始化等步骤的对象）
4. 代理类中的test方法被执行逻辑如下：
   1. 执行切面逻辑（@Before）
   2. 调用tartget.test()方法。

当从Spring容器中得到UserService的Bean对象时，拿到的就是UserServiceProxy所生成的对象，也就是代理对象。
UserServiceProxy.test() ----> 执行切面逻辑 ----> targe.test() 注意target对象不是代理对象，而是被代理对象

---

Spring事务

当我门在某个方法上加了@Transactional注解后，就表示该方法在调用会开启Spring事务，而这个方法所在的类对应的Bean对象回收该类代理对象。

Spring事务的代理对象执行某个方法的步骤：

1. 判断当前执行的方法是否存在@Transactional
2. 如果存在，则利用事务管理器（TransactionMananger）新建一个数据库连接
3. 修改数据库连接的autocommit为false
4. 执行target.test()，执行所写的实际代码逻辑，也就是执行sql
5. 执行完了如果没有出现异常，则提交，否则回滚。

Spring事务是否会失效的判断标准：某个类加了@Transactional注解的方法被调用时，要判断到底是不是直接被代理对象调用的，如果是则事务会生效，如果不是则失效。

---

本文大致通过一个个例子来简单的描述了一些核心知识点，后续会依次深入源码去了解Spring实际的执行过程，有兴趣的朋友可以留意一下，如果不正确的地方还请不吝赐教。