spring底层原理初探

蔚落 2024-04-05 07:25 87阅读 0赞

## 一，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);

从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");

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

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

#### 1.2，推断构造方法： ####

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

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

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

#### 1.3，实例化Bean ####

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

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

#### 1.4，属性填充 ####

给里面的属性上面加了注解的变量进行一个属性填充，如@Autowared。就是判断方法里面有没有哪个属性上面有这个注解，如果有，就进行一个属性填充。  
![在这里插入图片描述][f63a27a2ade641c2acacf39603ad0f41.png]

#### 1.5，初始化前 ####

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

#### 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"})

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

@Bean 
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
         
       	return new JdbcTemplate(dataSource); 
    }

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("内部异常");
        }
    }

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

[f63a27a2ade641c2acacf39603ad0f41.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/5a9db2d7784b4da29c9101a578d6f3ff.png
[4f165729173241f7839aa047e2f19f35.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/04/334853e051194ea5896d15d2f8a20b8e.png