金鳞踏雨

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

一、前言

我们可以先来看一段代码

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的构造方法时，也就是第一行代码，会去做一些事情：

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

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

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

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

简要概述

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

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

详细分析

依赖注入

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

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

初始化前

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

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

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

初始化

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

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

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

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

初始化-源码解析

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