Spring底层源码分析

spring依赖注入底层原理解析

spring之bean对象生命周期步骤详情

流程：

UserService.class —>推断构造方法—>普通对象----依赖注入------>初始化（afterPropertiesSet方法）------>初始化后（AOP）------>代理对象----->放入Map<baenName,Bean对象>

推断构造方法

@Component
public class UserService implements InitializingBean {
	@Autowired
	private OrderService orderService;
	
	//无参构造方法
	public UserService() {
	System.out.println(8);
	}
	//有参构造方法
	public UserService(OrderService orderService) {
	this.orderService = orderService;
	System.out.println(1);
	}
	//有参构造方法
	public UserService(OrderService orderService, OrderService orderServicel) {
	this.orderService = orderService;
	System.out.println(2);
	}
}

以上如何选择呢？
spring会默认使用无参构造方法，如果没有无参的有多个有参的构造方法spring就会报错

如果有多个就可以明确给spring指定哪一个构造方法-------在构造方法上加@Autowired 注解

依赖注入

判断普通对象中是否有Autowired注解再进行依赖注入
源码大体逻辑：

依赖注入的话如何判断注入对象就是想要的依赖对象呢？

先byType---->再byName 在 Map<beaName,Bean对象> 中寻找

spring中使用 对象类型 和 对象名字进行识别唯一的

类型可以一样 名字必须不一样

在Bean中的地址不一样生成的Bean不同

初始化

初始化必须实现spring提供的指定方法

import org.springframewolk.beans.factory.InitializingBean;//实现一个接口
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UserService implements InitializingBean {
	@Autowired
	private OrderService orderService;
	
	//初始化执行自己定义
	@Override
	public void afterPropertiesSet() throws Exception {
	System.out.println(orderService);
	}
	
	public void test() {
	System.out.println(orderService);
	}
}

源码中判断UserService是否实现了InitializingBean接口，如果实现了就调用afterPropertiesSet自己定义初始化方法

AOP

UserServiceProxy对象===UserService代理对象----->UserService代理对象.target

UserService代理对象.test()
class UserServiceProxy extends UserService {
	UserService target;
	
	public void test(){
	// 切面逻辑
	// target.test()  //UserService普通对象.test()
}

放入Map<baenName,Bean对象>

放入Bean对象到Map<String,Object>的API（自己调用方法），一般是再UserService.class方法上面加Component注解，加入到Map<String,Object>的

//放入Bean对象到Map<String,Object>的API
Object o = new Object();|I
applicationContext.getBeanFactory().registerSingleton( beanName: "xxx",o);

放入Map<String,Object>的源码

spring事务

流程：

Spring事务切面逻辑----->@Transactional开启Spring事务----->利用事务管理器新建一个数据库连接conn ThreadLocal------>conn.autocommit=false------>target.test() //UserService普通对象.test() jdbcTemplate 执行sql1.sql2 ----->conn.rollback()conn.commit()

1、@Transactional
2、开启Spring事务
3、利用事务管理器新建一个数据库连接conn ThreadLocal
4、conn.autocommit=false
5、target.test() // UserService普通对象.test() jdbcTemplate执行sql1.sql2
6、conn.rollback()conn.commit()

准备Bean对象

配置事务创建链接数据库的对象Bean相当于mybatis对象

@ComponentScan("com.zhouyu")
@EnableTransactionManagement  //用于启用基于注解的事务管理
@Configuration //通过配置类可以定义和组装Spring Bean。  返回的是同一个dataSource对象 AppConfig代理对象
public class AppConfig {

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

//利用事务管理器创建数据库链接
@Bean
public PlatformTransactionManager transactionManager() {
	DataSourceTransactionManager transactionManager = newDataSourceTransactionManager();
	transactionManager.setDataSource(dataSource());
	return transactionManager:
}


@Bean
public DataSource dataSource() {
	DriverManagerDataSource dataSource = new DriverManagerDataSource();
	dataSource.seturl("jdbc :mysql://127.0.0.1:3306/tuling");
	dataSource.setUsername("root");
	dataSource.setPassword("Zhouyu123456***");
	returm dataSource;
}

@EnableTransactionManagement 是Spring框架提供的一个注解，用于启用基于注解的事务管理。通过使用这个注解，你可以开启Spring对事务的自动管理功能，使得你可以在方法上使用 @Transactional 注解来声明事务。

@EnableTransactionManagement 主要有以下两个属性：

• mode（默认为 AdviceMode.PROXY）：指定事务代理的模式。可以选择的值有 AdviceMode.PROXY 和
  AdviceMode.ASPECTJ。默认是 AdviceMode.PROXY，表示使用基于代理的方式实现事务管理。如果选择
  AdviceMode.ASPECTJ，表示使用基于AspectJ的方式实现事务管理。
• proxyTargetClass（默认为 false）：用于确定代理是否应该使用目标类的类代理，而不是目标类实现的接口。如果设置为
  true，代理将使用目标类的类代理（CGLIB代理），如果设置为 false，代理将使用目标类实现的接口代理（JDK动态代理）。

当你在配置类上使用 @EnableTransactionManagement 注解时，Spring框架会自动扫描带有 @Transactional 注解的方法，并在这些方法周围织入事务管理的逻辑。如果一个带有 @Transactional 注解的方法执行过程中出现了异常，Spring会自动回滚事务。这个注解的作用是简化事务管理的配置和使用，提高开发效率。

测试事务

class UserService{

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Transactional
	public void test() {
		jdbcTemplate.execute( sql: "insert into t1 values(1,1,1,1,'1')");
		//抛空指针异常，触发事务回滚
		throw new NullPointerException();

	}	
}

主程序逻辑

检查数据库中数据是否插入成功

事务失效

1、原因：

一个对象调用了另一个对象
代理对象和普通对象是两个对象

class UserService{

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Transactional
	public void test() {
		jdbcTemplate.execute( sql: "insert into t1 values(1,1,1,1,'1')");
		throw new NullPointerException();
		a();
	}
	
	//多个事务报错propagation = Propagation.NEVER
	@Transactional(propagation = Propagation.NEVER)
	public void a(){
		jdbcTemplate.execute( sql: "insert into t1 values(2,2,2,2, '2' )");
	}
}

以上原因一个对象调用了另一个对象的a（）
使用this.a()不能解决,因为this是普通对象

解决方法：

1、新建一个Base类，把需要调用的功能拿到另一个Bean对象中

新建类UserServiceBase，把UserService的a方法删掉，不要有相同的方法

2、自己注入自己

1、原因：

@ComponentScan("com.zhouyu")
@EnableTransactionManagement  //用于启用基于注解的事务管理
@Configuration //AppConfig代理对象来掉用
public class AppConfig {
	@Bean
	public JdbcTemplate jdbcTemplate() {
		return new JdbcTemplate(dataSource());
	}
	
	//利用事务管理器创建数据库链接
	@Bean
	public PlatformTransactionManager transactionManager() {
		DataSourceTransactionManager transactionManager = newDataSourceTransactionManager();
		transactionManager.setDataSource(dataSource());
		return transactionManager:
	}
	
	//创造dataSource对象
	@Bean
	public DataSource dataSource() {
		DriverManagerDataSource dataSource = new DriverManagerDataSource();
		dataSource.seturl("jdbc :mysql://127.0.0.1:3306/tuling");
		dataSource.setUsername("root");
		dataSource.setPassword("Zhouyu123456***");
		returm dataSource;
	}
}

@Configuration 中使用的是super.方法

AOP中使用的是target.方法