spring底层原理初探

一，spring原理初探

1，bean的创建生命周期

userService.class --> 推断构造方法 --> 实例化对象 --> 依赖注入(属性填充) --> 初始化前(@PostConstruct) --> 初始化 (Initializingbean) --> 初始化后(AOP，bean的后置处理器) --> 代理对象 --> 存入到这个单例池Map里面 -->bean

1.1，获取上下文的方式

//通过注解的方式获取这个上下文,在这个类上面需要添加一个@ComponentScan("")
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);
//通过xml的方式获取这个上下文
ClassPathXMlConfigApplicationContext xc = new ClassPathXMlConfigApplicationContext(spring.xml);
1
2
3
4

从spring容器里面获取对象。

//单例对象需要存放在单例池里面，多例的话不需要
 //一级缓存里面获取，以及缓存Map<"userService",UserService>
UserService us = (UserService)ac.getBean("userService");
UserService newUs = new UserService();
UserService us1 = (UserService)ac.getBean("userService");
UserService us2 = (UserService)ac.getBean("userService");
1
2
3
4
5
6

从容器中获取对象和这个new 对象的区别如下：

从容器中获取的对象结果了依赖注入，里面的属性有值，这个new的对象没有

1.2，推断构造方法：

1，如果类里面只有一个构造方法，那么只用那一个

2，如果有多个构造方法，那么就会用默认的无参构造方法

3，如果需要指定用哪一个构造方法，可以在指定的方法上面加一个@Autowared注解。

1.3，实例化Bean

1，通过type类型寻找，遍历以及缓存里面的全部value，判断是不是UserService这个对象实例

2，通过name名字寻找，一级缓存里面寻找，key/value

1.4，属性填充

给里面的属性上面加了注解的变量进行一个属性填充，如@Autowared。就是判断方法里面有没有哪个属性上面有这个注解，如果有，就进行一个属性填充。

1.5，初始化前

会去判断一下这个方法里面，有没有属性加了一个@PostConstruct这个注解。这个方法可以在spring容器初始化的时候就可以进行加载，主要是适用于加载一些需要依赖注入的对象。其调用顺序如下 Constructor ----> @Autowired ----> @PostConstruct

1.6，初始化

会判断对象是否实现这个InitializingBean类

1.7，初始化后

可以通过这个bean的后置处理器，实现这个aop操作。

二，AOP

主要用来加日志，监控，权限等等

2.1，aop的实现原理

spring的aop主要是在bean初始化之后，调用bean的后置处理器来实现。aop主要是通过这个cglib的动态代理实现，就是会通过一个子类去继承这个目标类，然后重写目标类里面的需要代理的方法，最后通过一个target对象，来获取这个之前的目标对象，最后通过这个就行了依赖注入的对象，去调用需要代理的方法

2.2，aop的加载流程

aop依赖与ioc，在生产bean并进行实例化之前，先通过bean的第一个后置处理器找到所有在类上面加@AspectJ这个注解的所有类，并在这个类的里面找到所有的befeore，after等注解的方法，每一个before，after等都会生成一个对应的advisor，每个advisor包括advise和pointcut，advise主要是用来作为一个增强器的使用，pointcut是为了进行匹配，匹配成功才进行最终的动态代理的生成。最后获取到所有的advisors，由于可能有大量的advisor，因此在bean的最后一个后置处理器才对这些所有的advisor进行处理，即在bean进行初始化之后才进行处理。最后会去循环遍历这些advisors，通过advisors里面封装的pointcut和生成的advisor进行比较，如果匹配成功，则说明bean需要创建动态代理。主要是通过责任链的方式实现。

三，spring事务

3.1，事务使用

1，开启事务

//开启事务
@EnableTransactionManagement
//开启动态代理暴露，将动态代理暴露在当前线程
@EnableAspectJAutoProxy//(exposeProxy = true) 
@ComponentScan(basePackages = {"com.zhenghuisheng"}) 
1
2
3
4
5

2，配置数据库连接，指定的具体的dataSource，这里可以指定一个jdbcTemplate

@Bean 
public JdbcTemplate jdbcTemplate(DataSource dataSource) { 
   	return new JdbcTemplate(dataSource); 
}
1
2
3
4

3，接下来模拟一个扣减库存的实例

@Autowired
private AccountInfoDao accountInfoDao;
@Autowired
private ProductInfoDao productInfoDao;

public void pay(String accountId, double money) {
	//查询余额
	double blance = accountInfoDao.qryBlanceByUserId(accountId);
	//余额不足正常逻辑
	if(new BigDecimal(blance).compareTo(new BigDecimal(money))<0) {
		throw new RuntimeException("余额不足");
	}
	//更新余额
	int retVal = accountInfoDao.updateAccountBlance(accountId,money);
	//库存-1
	//updateProductStore(1);
	((PayService)AopContext.currentProxy()).updateProductStore(1);
        	System.out.println(1/0);
}

@Transactional(propagation = Propagation.NESTED)
public void updateProductStore(Integer productId) {
	try{
		productInfoDao.updateProductInfo(productId);
 	}catch (Exception e) {
      	throw new RuntimeException("内部异常");
    }
}
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

4，采用动态代理的方式实现
通过AutoProxyRegistrar来注册一个bean的后置处理器，来解析切面等信息。

5，aop和事务都需要开启，都会通过bean的后置处理器注册成一个bean定义，最后会判断aop的后置处理器的优先级的大小，最后谁优先级高则会进行覆盖。处理aop的优先级会比事务的优先级高，因此事务会被覆盖

3.2，事务的加载流程

1，@EnableTransactionManagement 注解里面，有一个 @Import(TransactionManagementConfigurationSelector.class)，基于importSelector的bean定义

2，import里面会导入完整的类名数组，分别是AutoProxyRegistar.class.getName()和ProxyTransactionManagementConfiguration.class.getName()两个

3，AutoProxyRegistar是基于一个注册bean的import的一个组件，由于处理aop的优先级会比处理事务的优先级高，所以最终处理aop的会将处理事务的覆盖，因此这个也是用于处理事务的一个aop的一个bean的后置处理器

4，ProxyTransactionManagementConfiguration是一个配置类，里面配置了advisor，直接通过配置类直接注册成一个内置的advisor，advisor里面包含一个通知advise和一个切入点pointcut，advise就是用来增强代码的，比如说处理事务，开启事务，回滚事务，提交事务，都在这个advise里面，pointcut负责匹配是否符合创建动态代理，判断方法上面是否有@Transactional，如果有则创建动态代理

5，调用createBean进行实例化，再调用doCreateBean进行属性赋值，再初始化。

6，获取所有的advisors，通过BeanFactoryTransactionAttributeSourceAdvisor来解析事务，根据当前bean的所有方法，找类里面的方法上找有没有Transaction的这个注解，没有的话会往父类或者接口找。如果是接口的话，会调用jdk动态代理，也可以强制加注解使用CGLIB代理

7，对advisors进行匹配，通过调用 ClassFilter 方法进行筛选，进行初筛。

8，精筛，会调用事务的属性源来进行判断，主要判断方法上面有没有 @Transaction 注解

9，可能也会根据接口或者父类来判断是否存在 @Transaction

dvisors进行匹配，通过调用 ClassFilter 方法进行筛选，进行初筛。

8，精筛，会调用事务的属性源来进行判断，主要判断方法上面有没有 @Transaction 注解

9，可能也会根据接口或者父类来判断是否存在 @Transaction