【Spring源码】Spring核心原理解析

一、前言

今天是2023.4.6，记录一下，从现在开始，就两件事情，Spring源码的学习，还有软考中级~
争取两个月内搞定！！！

关于Spring相信大家都很熟悉，有SSM、SpringBoot、SpringCloud…但是这里谈的Spring指的是最底层的Spring Framework。
我们可以先来看一段代码：

public class Test {
    
    
	public static void main(String[] args) {
    
    
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
		UserService userService = (UserService) ac.getBean("userService");
		System.out.println(userService);
    }
}

这三行代码应该，大家应该都比较熟悉，这是学习Spring的 "hello world程序"。

简单来说就是：

先根据我们配置的 spring.xml 文件，创建一个Spring容器，然后通过 getBean() 方法获取userService对象，再调用其方法。

但是，用 ClassPathXmlApplicationContext 其实已经**“过时”**了，在新版的 SpringMVC 和 SpringBoot 的底层主要用的都是 AnnotationConfigApplicationContext

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

两种ApplicationContext 的区别

两者的用法其实都差不多，只不过需要传入的是一个class，而不是一个xml文件，但是实际上两者的 本质 是一样的。

在实际开发中，我们现在基本不会使用这种方式来用Spring了，而是使用SpringMVC，或者Spring Boot；但是它们的本质都是基于上面这种方式的，都需要在内部去创建一个ApplicationContext的，只不过：

（1）SpringMVC创建的是XmlWebApplicationContext，和ClassPathXmlApplicationContext类似，都是基于XML配置的。
（2）SpringBoot创建的是AnnotationConfigApplicationContext。

Spring创建一个Bean的流程（重点）

（1）UserService.class
（2）无参构造方法（推断构造方法）
（3）普通对象 （4）依赖注入（属性赋值）
（5）初始化前(@PostConstruct)
（6）初始化(InitializingBean)
（7）初始化后(AOP)
（8）代理对象（如果有AOP）
（9）Bean

二、Spring中是如何创建一个对象？

其实不管是 AnnotationConfigApplicationContext 还是 ClassPathXmlApplicationContext，目前，我们都可以简单的将它们理解为就是 用来创建Java对象 ，比如调用 getBean() 就会去创建对象。

在Java语言中，肯定是根据某个类来创建一个对象的。

示例代码：

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();

@ComponentScan("com.XXX")
public class AppConfig {
    
    
	@Bean
	public OrderService orderService(){
    
    
		return new OrderService();
	}
}

问：getBean(“userService”)做了哪些事情？

当我们调用 context.getBean(“userService”) 时，就会去创建一个对象，但是getBean() 方法内部怎么知道 “userService” 对应的是UserService类呢？

在调用AnnotationConfigApplicationContext的构造方法时，也就是第一行代码，会去做一些事情：

1. 解析AppConfig.class，得到扫描路径
2. 遍历扫描路径下的所有Java类，如果发现某个类上存在@Component、@Service等注解，那么Spring就把这个类记录下来，存在一个Map中（也就是源码中的BeanDefinitionMap）
3. Spring会根据某个规则生成当前类对应的beanName，作为key存入Map，当前类作为value**（名字为key，类为值）**

getBean() 会先根据 类型 去找，如果该类型只有一个，那么就“直接拿来用”；如果有多个，才会按照 名字 去找。

这样子，我们可以根据key值（“userService”） 找到对应的 UserService类，从而就可以去创建对象了！

三、Bean的创建过程（生命周期）

简要概述

那么Spring到底是如何来创建一个Bean的呢，这个就是Bean创建的生命周期，大致过程如下：

（1）利用该类的构造方法来实例化得到一个对象（但是如何一个类中有多个构造方法，Spring则会进行选择，这个叫做（推断构造方法）

（2）得到一个对象后，Spring会判断该对象中是否存在被@Autowired注解了的属性，把这些属性找出来并由Spring进行赋值（依赖注入）

（3）依赖注入后，Spring会判断该对象是否实现了BeanNameAware接口、BeanClassLoaderAware接口、BeanFactoryAware接口，如果实现了，就表示当前对象必须实现该接口中所定义的setBeanName()、setBeanClassLoader()、setBeanFactory()方法，那Spring就会调用这些方法并传入相应的参数（Aware回调）

（4）Aware回调后，Spring会判断该对象中是否存在某个方法被@PostConstruct注解了，如果存在，Spring会调用当前对象的此方法（初始化前）

（5）紧接着，Spring会判断该对象是否实现了InitializingBean接口，如果实现了，就表示当前对象必须实现该接口中的 afterPropertiesSet()方法，那Spring就会调用当前对象中的 afterPropertiesSet()方法（初始化）

（6）最后，Spring会判断当前对象需不需要进行AOP，如果不需要那么Bean就创建完了，如果需要进行AOP，则会进行动态代理并生成一个代理对象做为Bean（初始化后）

详细分析

1.依赖注入

Spring会默认使用无参构造方法得到一个“普通”对象，再给这个对象进行“依赖注入”，也就是Spring会给加了@Autowired注解的属性进行赋值
那么这一步如何实现？？？

for(Field field : userService.getClass().getDeclaredFields()) {
    
    
    // 判断是否带有 @Autowired注解
	if (field.isAnnotationPresent(Autowired.class)) {
    
    
		field.set(userService);
	}
}

2.初始化前

早期的Spring只有一个初始化的状态，发展至今，有了 初始化前、初始化、初始化后 这三种状态。

如果有方法被 @PostConstruct注解 了，在Spring的初始化前会调用这个方法，
那么Spring是如何知道哪一个方法被 @PostConstruct 注解了呢？？？

for (Method method : userService.getClass().getDeclaredMethods()) {
    
    
	if (method.isAnnotationPresent(PostConstruct.class)) {
    
    
		method.invoke(userService, null);
	}
}

3.初始化

InitializingBean接口 中只有一个afterPropertiesSet() 方法

public interface InitializingBean {
    
    
	void afterPropertiesSet() throws Exception;
}

在初始化时， Spring会判断该对象是否实现了InitializingBean接口，这个逻辑如何实现？？？

// 判断一个对象是否使用了某一个接口
if (userService instanceof InitializingBean) {
    
    
	try {
    
    
		((InitializingBean)userService1).afterPropertiesSet();
	} catch (Exception e) {
    
    
		e.printStackTrace();
	}
}

4.初始化-源码解析

Spring是如何进行初始化的？？？
是如何判断该对象实现InitializingBean接口？？？
怎么调用 afterPropertiesSet() 方法？？？

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    
    
    ......
    try {
    
    
	    // 属性填充
		populateBean(beanName, mbd, instanceWrapper);

		// 初始化
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
    
    
		......
	}
    ......
}

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    
    
    ......
	// 初始化
	try {
    
    
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
    
    
        ......
	}
    ......
	return wrappedBean;
}

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
    
    
	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
    
    
		// 日志
		if (logger.isTraceEnabled()) {
    
    
			logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		// 判断是否打开安全管理器
		if (System.getSecurityManager() != null) {
    
    
			try {
    
    
				// 打开安全管理器
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
    
    
					((InitializingBean) bean).afterPropertiesSet();
					return null;
				}, getAccessControlContext());
			}
			catch (PrivilegedActionException pae) {
    
    
				throw pae.getException();
			}
		}
		else {
    
    
			// 未打开安全管理器
			((InitializingBean) bean).afterPropertiesSet();
		}
	}
    ......
}

核心的代码实际上就是这两行：

boolean isInitializingBean = (bean instanceof InitializingBean);
((InitializingBean) bean).afterPropertiesSet(); 

5.初始化后（AOP）

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

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

单例Bean与原型Bean（创建完成后）

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

四、推断构造方法

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

Spring的判断逻辑

（1）如果一个类只存在一个构造方法，不管该构造方法是无参构造方法，还是有参构造方法，Spring都会用这个构造方法。
（2）如果一个类存在多个构造方法

• 这些构造方法中，存在一个无参的构造方法，那么Spring就会用这个无参的构造方法
• 这些构造方法中，不存在一个无参的构造方法，那么Spring就会报错

Spring的设计思想

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

需要重视的是，如果Spring选择了一个有参的构造方法，Spring在调用这个有参构造方法时，需要传入参数，那这个 参数是怎么来的呢？

Spring会根据入参的类型和入参的名字去Spring中找Bean对象（以单例Bean为例，Spring会从单例池那个Map中去找）：

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

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

五、AOP大致流程

简要概述

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

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

（1）找出所有的切面Bean

（2）遍历切面中的每个方法，看是否写了 @Before、@After 等注解

（3）如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配

（4）如果匹配，则表示当前Bean对象有匹配的的Pointcut，表示需要进行AOP！！！

利用cglib进行AOP的大致流程

（1）生成 代理类UserServiceProxy ，代理类继承UserService

（2）代理类中重写了父类的方法，比如 UserService 中的 test() 方法

（3）代理类中还会有一个 target属性，该属性的值为 被代理对象（也就是通过UserService类推断构造方法实例化出来的对象，进行了依赖注入、初始化等步骤的对象）

（4）代理类中的test()方法被执行时的逻辑如下：

• 执行切面逻辑（@Before）
• 调用 target.test()

结合代码分析

AOP的流程，大致是如上述所述。
我们现在再结合代码进行debug来深入理解一下这个过程。

Test

public class Test {
    
    
	public static void main(String[] args) {
    
    
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
		UserService userService = (UserService) context.getBean("userService");
		userService.test();

AppConfig

@ComponentScan("com.zhouyu")
@EnableAspectJAutoProxy
public class AppConfig {
    
    
}

UserService

@Component
public class UserService {
    
    
	@Autowired
	private OrderService orderService;
	public void test(){
    
    
		System.out.println(orderService);
	}
}

ZhouyuAspect

@Aspect
@Component
public class ZhouyuAspect {
    
    
	@Before("execution(public void com.zhouyu.service.UserService.test())")
	public void zhouyuBefore(JoinPoint joinPoint) {
    
    
		System.out.println("zhouyuBefore");
	}
}

此时 orderService 还没有被赋值！

但是，可以发现一旦进入到 test() 方法中的时候，orderService就有值了！！！

调用顺序

当我们从Spring容器得到 UserService 的Bean对象时（有AOP），拿到的就是 UserServiceProxy 所生成的对象，也就是 代理对象 。

// 伪代码
class UserServiceProxy extends UserService{
    
    
	private UserService target;
	public void() {
    
    
		// 执行 @Before
		...
		target.test();
	}
}

生成了代理对象后，会先给 target属性 赋值，赋值的内容就是UserService（普通对象），最后去调用 target.test()。不过，需要注意的是，target对象不是代理对象，而是 被代理对象 。

六、Spring事务

简要概述

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

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

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

什么情况下Spring事务是否会失效？？？

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

七、图灵课堂源码视频

视频地址

链接：https://pan.baidu.com/s/13Tt4Qia5gmJIwruN-oQJRA?pwd=bokp
提取码：bokp
完整内容联系：lxvvv86（有偿）