【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<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(); 初始化后（AOP）
通过最后一步，我们可以发现，当Spring根据UserService类来创建一个Bean时：
- 如果不用进行AOP，那么Bean就是UserService类的构造方法所得到的对象。
- 如果需要进行AOP，那么Bean就是UserService的代理类所实例化得到的对象，而不是UserService本身所得到的对象。
单例Bean与原型Bean（创建完成后）
- 如果当前Bean是单例Bean，那么会把该Bean对象存入一个Map<String, Object>，Map的key为beanName，value为Bean对象。这样下次getBean时就可以直接从Map中拿到对应的Bean对象了。（实际上，在Spring源码中，这个Map就是单例池）
- 如果当前Bean是原型Bean，那么后续没有其他动作，不会存入一个Map，下次getBean时会再次执行上述创建过程，得到一个新的Bean对象。
四、推断构造方法
Spring在基于某个类生成Bean的过程中，需要利用该类的构造方法来实例化得到一个对象，但是如果一个类存在多个构造方法，Spring会使用哪个呢？
Spring的判断逻辑
（1）如果一个类只存在一个构造方法，不管该构造方法是无参构造方法，还是有参构造方法，Spring都会用这个构造方法。
（2）如果一个类存在多个构造方法
- 这些构造方法中，存在一个无参的构造方法，那么Spring就会用这个无参的构造方法
- 这些构造方法中，不存在一个无参的构造方法，那么Spring就会报错
Spring的设计思想
- 如果一个类只有一个构造方法，那么没得选择，只能用这个构造方法
- 如果一个类存在多个构造方法，Spring不知道如何选择，就会看是否有无参的构造方法，因为无参构造方法本身表示了一种默认的意义
- 不过如果某个构造方法上加了@Autowired注解，那就表示程序员告诉Spring就用这个加了注解的方法，那Spring就会用这个加了@Autowired注解构造方法了
需要重视的是，如果Spring选择了一个有参的构造方法，Spring在调用这个有参构造方法时，需要传入参数，那这个参数是怎么来的呢？
Spring会根据入参的类型和入参的名字去Spring中找Bean对象（以单例Bean为例，Spring会从单例池那个Map中去找）：
- 先根据入参类型找，如果只找到一个，那就直接用来作为入参
- 如果根据类型找到多个，则再根据入参名字来确定唯一一个
- 最终如果没有找到，则会报错，无法创建当前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()
调用顺序
当我们从Spring容器得到UserService的Bean对象时（有AOP），拿到的就是UserServiceProxy所生成的对象，也就是代理对象。
UserService代理对象.test()--->执行切面逻辑--->target.test()，注意target对象不是代理对象，而是被代理对象。
六、Spring事务
简要概述
当我们在某个方法上加了@Transactional注解后，就表示该方法在调用时会开启Spring事务，而这个方法所在的类所对应的Bean对象会是该类的代理对象。
Spring事务的代理对象执行某个方法时的步骤：
- 判断当前执行的方法是否存在@Transactional注解
- 如果存在，则利用事务管理器（TransactionMananger）新建一个数据库连接
- 修改数据库连接的autocommit为false
- 执行target.test()，执行程序员所写的业务逻辑代码，也就是执行sql
- 执行完了之后如果没有出现异常，则提交，否则回滚
Spring事务是否会失效的判断标准：某个加了@Transactional注解的方法被调用时，要判断到底是不是直接被代理对象调用的，如果是则事务会生效，如果不是则失效。
七、图灵课堂源码视频获取
视频地址
链接：https://pan.baidu.com/s/13Tt4Qia5gmJIwruN-oQJRA?pwd=bokp
提取码：bokp
完整内容联系：lxvvv86（有偿）
