一、环境准备
基本步骤
1)引入mysql驱动,Druid连接池,jdbc依赖
2)配置类TxConfig, 注册JdbcTemplate, DruidDataSource
3)编写业务类,使用原生jdbc操作数据库
4)加入事务管理
@EnableTransactionManagement
@Transactional
注册事务管理器TransactionManager
5)调试实现回滚,int tem = 10 / 0;
当数据回滚时候,数据库自增主键会继续增长,即回滚时数据库主键也会自增
1、引入依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.18</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
</dependencies>
2、配置类TxConfig
@EnableTransactionManagement
@ComponentScan(basePackages = {"com.whf.spring.tx"})
@Configuration
public class TxConfig {
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/demo");
dataSource.setUsername("root");
dataSource.setPassword("admin");
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate() {
return new JdbcTemplate(dataSource());
}
@Bean
public TransactionManager transactionManager() {
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource());
return transactionManager;
}
}
3、编写业务调试
service类
@Service
public class UserService{
@Autowired
private UserDao userDao;
@Transactional
@Override
public int save(User user) {
int count = userDao.save(user);
if (count > 0) {
System.out.println("成功插入数据库。。。。");
} else {
System.out.println("插入失败。。。。");
}
int tem = 10 / 0;
return count;
}
}
dao类
@Repository
public class UserDao {
@Autowired
private JdbcTemplate jdbcTemplate;
public int save(User user) {
String sql = "insert into `user`(name, age) values(?, ?)";
int count = jdbcTemplate.update(sql, user.getName(), user.getAge());
return count;
}
}
调试类(执行结果报错,并且数据没有插入新数据则代表事务成功回滚)
public class TxDemo {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
UserService userService = (UserService) context.getBean(UserService.class);
int ret = userService.save(new User(UUID.randomUUID().toString().substring(0, 5), 18));
System.out.println(ret);
}
}
// 报错,并且数据库没有新增则证明事务起作用了
Exception in thread "main" java.lang.ArithmeticException: / by zero
二、源码解析
1、从@EnableTransactionManagement开始分析
1、@EnableTransactionManagement
// 引入TransactionManagementConfigurationSelector
1)@Import({TransactionManagementConfigurationSelector.class})
2)TransactionManagementConfigurationSelector实现了ImportSelector.selectImports(AdviceMode adviceMode)
通过ImportSelector注册了两个类AutoProxyRegistrar和ProxyTransactionManagementConfiguration
return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
2、AutoProxyRegistrar和ProxyTransactionManagementConfiguration类结构分析
1)AutoProxyRegistrar implements ImportBeanDefinitionRegistrar
在实现方法registerBeanDefinitions中注册了一个bean
internalAutoProxyCreator => InfrastructureAdvisorAutoProxyCreator
后续再详细说InfrastructureAdvisorAutoProxyCreator,跟AOP代理基本是一样的原理
2)ProxyTransactionManagementConfiguration
AbstractTransactionManagementConfiguration
ImportAware
Aware
在beam初始化之前由beanPostProcessor设置一些元信息
((ImportAware) bean).setImportMetadata(importingClass);
// 后续着重分析InfrastructureAdvisorAutoProxyCreator
2、分析InfrastructureAdvisorAutoProxyCreator
1、分析类结构
InfrastructureAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
AbstractAutoProxyCreator extends ProxyProcessorSupport (实现Ordered接口)
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
2、分析SmartInstantiationAwareBeanPostProcessor和BeanFactoryAware
1)SmartInstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
BeanPostProcessor
可见InfrastructureAdvisorAutoProxyCreator是一个BeanPostProcessor,具体实现是在
父类的AbstractAutoProxyCreator
2)BeanFactoryAware
Aware
在refresh方法中的初始化其余非懒加载单实例bean方法中给bean注入BeaFactory,调用栈如下
doCreateBean(beanName, mbdToUse, args);
initializeBean(beanName, exposedObject, mbd);
invokeAwareMethods(beanName, bean);
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
3、AbstractAutoProxyCreator
从上面可以看出InfrastructureAdvisorAutoProxyCreator 是一个BeanPostProcessor。那么可以从其父类AbstractAutoProxyCreator实现的BeanPostProcessor切入分析
1、再次看下该类结构
AbstractAutoProxyCreator
SmartInstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
BeanPostProcessor
可以发现核心逻辑在下面两个BeanPostProcessor的方法中,
接下来就可以根据AbstractAutoProxyCreator的这个方法的具体实现进行分析
InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
BeanPostProcessor.postProcessAfterInitialization()
4、分析AbstractAutoProxyCreator方法
上面分析的两个方法打上断点debug,postProcessBeforeInstantiation和postProcessAfterInitialization方法
1、先进入postProcessBeforeInstantiation方法
1)在创建bean实例之前先调用下面方法,给BeanPostProcessor一个机会返回一个代理对象,
也就是通过InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
resolveBeforeInstantiation(beanName, mbdToUse);
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bp instanceof InstantiationAwareBeanPostProcessor) // 类型判断
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
2)分析AbstractAutoProxyCreator.postProcessBeforeInstantiation()
// 判断是否已经进行增强处理
this.advisedBeans.containsKey(cacheKey)
// 是否基本类型(Advice、Pointcut、Advisor、AopInfrastructureBean)
isInfrastructureClass(beanClass)
// 判断是否跳过此增强逻辑
shouldSkip(Class<?> beanClass, String beanName)
// 确定给定的bean名称是否表示“原始实例”
AutoProxyUtils.isOriginalInstance(beanName, beanClass);
// 如果我们有一个自定义的TargetSource,在这里创建代理。
// 禁止对目标bean进行不必要的默认实例化:TargetSource将以自定义方式处理目标实例
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
上面返回的是 targetSource = null,这个方法到这里就直接返回null结束了。
2、进入postProcessAfterInitialization方法
// 此时bean已经实例化并且已经完成了初始化,判断是否需要包装成代理bean
wrapIfNecessary(bean, beanName, cacheKey);
1) 获取增强拦截器
getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// 查找可用增强器
findEligibleAdvisors(beanClass, beanName);
// 查找所有候选增强器
findCandidateAdvisors();
// 查找能用到当前bean的增强器
findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
最终找到的是BeanFactoryTransactionAttributeSourceAdvisor,
父类有个Advice属性:private transient volatile Advice advice;
BeanFactoryTransactionAttributeSourceAdvisor中的advice为TransactionInterceptor类型
TransactionInterceptor implements MethodInterceptor(方法拦截器)
2)创建代理对象
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
// 从beanFactory获取该bean定义,标记为
if (this.beanFactory instanceof ConfigurableListableBeanFactory)
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
// ORIGINAL_TARGET_CLASS_ATTRIBUTE : org.springframework.aop.framework.autoproxy.AutoProxyUtils.originalTargetClass
beanFactory.getMergedBeanDefinition(beanName).setAttribute(ORIGINAL_TARGET_CLASS_ATTRIBUTE, targetClass);
// 创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();
// 获取增强器BeanFactoryTransactionAttributeSourceAdvisor
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
// 配置增强器到代理工厂
proxyFactory.addAdvisors(advisors);
// 获取代理对象
proxyFactory.getProxy(getProxyClassLoader());
createAopProxy().getProxy(classLoader);
// 根据是否实现接口创建JDK动态代理或Cglib动态代理
createAopProxy() => new JdkDynamicAopProxy(config);
// 通过JDK动态代理创建代理对象
JdkDynamicAopProxy.getProxy(classLoader) => Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
JdkDynamicAopProxy实现了InvocationHandler方法,在代理类执行时,最终会会执行JdkDynamicAopProxy.invoke(Object proxy, Method method, Object[] args)
5、调用代理方法
上面流程已经完成了UserService代理对象的创建,从容器中取出bean代理对象,调用标记了
@Transactional的save(User user),在调用处打上断点
1、调用代理方法(InvocationHandler.invoke())
JdkDynamicAopProxy.invoke(Object proxy, Method method, Object[] args)
1) 判断是否equals方法或hashCode方法,是的话直接执行方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
2)判断Mehod的Class对象是否接口或者Advised类型
else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
3)获取代理增强拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass);
也就是之前分析的BeanFactoryTransactionAttributeSourceAdvisor
// 封装成MehtodInvocation对象并执行proceed方法
MethodInvocation invocation =
new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
retVal = invocation.proceed();
4)proceed方法
// 迭代拦截器链获取拦截器知道,直到结果为-1代表全部都已找出,从最后一个开始往前执行拦截器
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 获取拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 调用方法拦截器的invoke方法
((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this)
// 执行TransactionInterceptor拦截器(实现了MethodInterceptor接口),事务调用方法
invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
// 获取事务属性和事务管理器
TransactionAttributeSource tas = getTransactionAttributeSource();
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
final TransactionManager tm = determineTransactionManager(txAttr);
// 创建事务
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
// 创建事务信息对象
TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
// 将事务信息绑定到当前线程中ThreadLocal
txInfo.bindToThread();
// 执行代理事务方法,如果抛异常则回滚,正常则清除事务信息,最后在方法返回时提交事务
try {
// This is an around advice: Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
commitTransactionAfterReturning(txInfo);
6、事务回滚分析
completeTransactionAfterThrowing(txInfo, ex);
// 判断事务该异常是否回滚
txInfo.transactionAttribute.rollbackOn(ex)
// 如果@Transactional注解没有配置异常回滚属性,则RuntimeException和Error类型异常都回滚
(ex instanceof RuntimeException || ex instanceof Error);
// 通过事务管理器进行回滚
txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
processRollback(defStatus, false);
doRollback(status);
// 事务管理器获取Connection对象调用rollback方法进行回滚
DataSourceTransactionManager.DataSourceTransactionObject txObject = (DataSourceTransactionManager.DataSourceTransactionObject)status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
con.rollback();