查找公司注册信息的网站,wordpress 无法更换会员注册页面,wordpress hook 数据库,做网站按什么收费多少钱文章目录 什么是事务Spring事务管理Spring事务实现原理事务管理器事务定义事务的开启事务核心方法业务代码使用事务TransactionInterceptor 什么是事务
一般所指的事务是数据库事务#xff0c;是指一批不可分割的数据库操作序列#xff0c;也是数据库并发控制的基本单位。其… 文章目录 什么是事务Spring事务管理Spring事务实现原理事务管理器事务定义事务的开启事务核心方法业务代码使用事务TransactionInterceptor 什么是事务
一般所指的事务是数据库事务是指一批不可分割的数据库操作序列也是数据库并发控制的基本单位。其执行的结果必须使数据库从一种一致性状态到另一种一致性状态。事务必须满足4个基本特性即ACID原子性、一致性、隔离性、持久性。
Spring事务管理
Spring并不直接支持事务只有当数据库支持事务时Spring才支持。他只是通过AOP简化了开发人员使用事务的步骤。
Spring可通过xml和注解配置和一些关键类确保bean中涉及数据库操作的方法执行符合事务的基本特性。
例如一个业务调用了2个Service他们分别操作了不同的数据表必须确保这些数据一起成功或者一起失败。
Spring事务实现原理
首先介绍Spring中和事务实现密切相关的重要类。
事务管理器
事务管理器的顶层接口是TransactionManager。以下是他的类图。 PlatformTransactionManager平台事务管理器
ReactiveTransactionManager响应式编程的事务管理器
Spring中事务关注的重点是PlatformTransactionManager以及有他的实现类
JtaTransactionManager支持分布式事务单个服务中的多数据源默认只有weblogic和websphere2个实现
DataSourceTransactionManager单数据源事务管理器。平时用的最多的就是这个是分析的重点。
public interface PlatformTransactionManager extends TransactionManager {/*** 获取事务*/TransactionStatus getTransaction(Nullable TransactionDefinition definition)throws TransactionException;/*** 提交数据*/void commit(TransactionStatus status) throws TransactionException;/*** 回滚数据*/void rollback(TransactionStatus status) throws TransactionException;}事务定义
事务定义类为TransactionDefinition在事务管理器获取事务时作为参数传入。它定义了事务的 传播属性隔离级别超时时间是否只读等属性。
public interface TransactionDefinition {/*** 支持当前事务若当前没有事务就创建一个事务*/int PROPAGATION_REQUIRED 0;/*** 如果当前存在事务则加入该事务如果当前没有事务则以非事务的方式运行 */int PROPAGATION_SUPPORTS 1;/*** 如果当前存在事务则加入该事务如果当前没有事务则抛出异常*/int PROPAGATION_MANDATORY 2;/*** 创建一个新的事务如果当前存在事务则把当前事务挂起*/int PROPAGATION_REQUIRES_NEW 3;/*** 以非事务方式运行如果当前存在事务则把当前事务挂起*/int PROPAGATION_NOT_SUPPORTED 4;/*** 以非事务方式运行如果当前存在事务则抛出异常*/int PROPAGATION_NEVER 5;/*** 如果外层存在事务就以嵌套事务运行被嵌套的事务可以独立于外层事务进行提交或者回滚(保存点)* 如果外层不存在事务,行为跟PROPAGATION_REQUIRES_NEW*/int PROPAGATION_NESTED 6;/*** 使用数据库默认的隔离级别*/int ISOLATION_DEFAULT -1;/*** 读未提交*/int ISOLATION_READ_UNCOMMITTED 1; // same as java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;/*** 读已提交*/int ISOLATION_READ_COMMITTED 2; // same as java.sql.Connection.TRANSACTION_READ_COMMITTED;/*** 可重复读*/int ISOLATION_REPEATABLE_READ 4; // same as java.sql.Connection.TRANSACTION_REPEATABLE_READ;/*** 可串行化*/int ISOLATION_SERIALIZABLE 8; // same as java.sql.Connection.TRANSACTION_SERIALIZABLE;/*** 使用默认的超时时间*/int TIMEOUT_DEFAULT -1;/*** 获取事务的传播行为*/default int getPropagationBehavior() {return PROPAGATION_REQUIRED;}/*** 获取事务的隔离级别*/default int getIsolationLevel() {return ISOLATION_DEFAULT;}/*** 获取事务的超时时间*/default int getTimeout() {return TIMEOUT_DEFAULT;}/*** 是否为只读事务*/default boolean isReadOnly() {return false;}/*** 获取当前事务的名称*/Nullabledefault String getName() {return null;}static TransactionDefinition withDefaults() {return StaticTransactionDefinition.INSTANCE;}}TransactionDefinition的体系结构 DefaultTransactionDefinition是事务定义的默认实现
DefaultTransactionAttribute扩展了TransactionAttribute中的属性的实现
Transactional:该组件会被解析加载为对应的 TransactionDefinition对象。
事务的开启
在PlatformTransactionManager中获取事务的时候返回的是TransactionStatus对象。我们来看看这个对象。 子类中扩展了 事务核心方法
事务核心方法 AbstractPlatformTransactionManager.getTransaction() /*** This implementation handles propagation behavior. Delegates to* {code doGetTransaction}, {code isExistingTransaction}* and {code doBegin}.* see #doGetTransaction* see #isExistingTransaction* see #doBegin*/Overridepublic final TransactionStatus getTransaction(Nullable TransactionDefinition definition)throws TransactionException {// Use defaults if no transaction definition given.// 如果没有事务定义信息则使用默认的事务管理器定义信息TransactionDefinition def (definition ! null ? definition : TransactionDefinition.withDefaults());// 获取事务Object transaction doGetTransaction();boolean debugEnabled logger.isDebugEnabled();// 判断当前线程是否存在事务判断依据为当前线程记录的连接不为空且连接中的transactionActive属性不为空if (isExistingTransaction(transaction)) {// Existing transaction found - check propagation behavior to find out how to behave.// 当前线程已经存在事务return handleExistingTransaction(def, transaction, debugEnabled);}// Check definition settings for new transaction.// 事务超时设置验证if (def.getTimeout() TransactionDefinition.TIMEOUT_DEFAULT) {throw new InvalidTimeoutException(Invalid transaction timeout, def.getTimeout());}// No existing transaction found - check propagation behavior to find out how to proceed.// 如果当前线程不存在事务但是PropagationBehavior却被声明为PROPAGATION_MANDATORY抛出异常if (def.getPropagationBehavior() TransactionDefinition.PROPAGATION_MANDATORY) {throw new IllegalTransactionStateException(No existing transaction found for transaction marked with propagation mandatory);}// PROPAGATION_REQUIREDPROPAGATION_REQUIRES_NEWPROPAGATION_NESTED都需要新建事务else if (def.getPropagationBehavior() TransactionDefinition.PROPAGATION_REQUIRED ||def.getPropagationBehavior() TransactionDefinition.PROPAGATION_REQUIRES_NEW ||def.getPropagationBehavior() TransactionDefinition.PROPAGATION_NESTED) {//没有当前事务的话REQUIREDREQUIRES_NEWNESTED挂起的是空事务然后创建一个新事务SuspendedResourcesHolder suspendedResources suspend(null);if (debugEnabled) {logger.debug(Creating new transaction with name [ def.getName() ]: def);}try {return startTransaction(def, transaction, debugEnabled, suspendedResources);}catch (RuntimeException | Error ex) {// 恢复挂起的事务resume(null, suspendedResources);throw ex;}}else {// Create empty transaction: no actual transaction, but potentially synchronization.// 创建一个空的事务if (def.getIsolationLevel() ! TransactionDefinition.ISOLATION_DEFAULT logger.isWarnEnabled()) {logger.warn(Custom isolation level specified but no actual transaction initiated; isolation level will effectively be ignored: def);}boolean newSynchronization (getTransactionSynchronization() SYNCHRONIZATION_ALWAYS);return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);}}其中关键的方法doGetTransaction()方法有很多不同的实现类。我们来看下DataSourceTransactionManager的 /*** 创建一个DataSourceTransactionObject当作事务设置是否允许保存点然后获取连接持有器ConnectionHolder* 里面会存放JDBC的连接设置给DataSourceTransactionObject,当然第一次是空的** return*/Overrideprotected Object doGetTransaction() {// 创建一个数据源事务对象DataSourceTransactionObject txObject new DataSourceTransactionObject();// 是否允许当前事务设置保持点txObject.setSavepointAllowed(isNestedTransactionAllowed());/*** TransactionSynchronizationManager 事务同步管理器对象(该类中都是局部线程变量)* 用来保存当前事务的信息,我们第一次从这里去线程变量中获取 事务连接持有器对象 通过数据源为key去获取* 由于第一次进来开始事务 我们的事务同步管理器中没有被存放.所以此时获取出来的conHolder为null*/ConnectionHolder conHolder (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());// 非新创建连接则写falsetxObject.setConnectionHolder(conHolder, false);// 返回事务对象return txObject;}然后事务管理的代码 /*** Create a TransactionStatus for an existing transaction.*/private TransactionStatus handleExistingTransaction(TransactionDefinition definition, Object transaction, boolean debugEnabled)throws TransactionException {/*** 判断当前的事务行为是不是PROPAGATION_NEVER的* 表示为不支持事务,但是当前又存在一个事务,所以抛出异常*/if (definition.getPropagationBehavior() TransactionDefinition.PROPAGATION_NEVER) {throw new IllegalTransactionStateException(Existing transaction found for transaction marked with propagation never);}/*** 判断当前的事务属性不支持事务,PROPAGATION_NOT_SUPPORTED,所以需要先挂起已经存在的事务*/if (definition.getPropagationBehavior() TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {if (debugEnabled) {logger.debug(Suspending current transaction);}// 挂起当前事务Object suspendedResources suspend(transaction);boolean newSynchronization (getTransactionSynchronization() SYNCHRONIZATION_ALWAYS);// 创建一个新的非事务状态(保存了上一个存在事务状态的属性)return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);}/*** 当前的事务属性状态是PROPAGATION_REQUIRES_NEW表示需要新开启一个事务状态*/if (definition.getPropagationBehavior() TransactionDefinition.PROPAGATION_REQUIRES_NEW) {if (debugEnabled) {logger.debug(Suspending current transaction, creating new transaction with name [ definition.getName() ]);}// 挂起当前事务并返回挂起的资源持有器SuspendedResourcesHolder suspendedResources suspend(transaction);try {// 创建一个新的非事务状态(保存了上一个存在事务状态的属性)return startTransaction(definition, transaction, debugEnabled, suspendedResources);}catch (RuntimeException | Error beginEx) {resumeAfterBeginException(transaction, suspendedResources, beginEx);throw beginEx;}}// 嵌套事务if (definition.getPropagationBehavior() TransactionDefinition.PROPAGATION_NESTED) {// 不允许就报异常if (!isNestedTransactionAllowed()) {throw new NestedTransactionNotSupportedException(Transaction manager does not allow nested transactions by default - specify nestedTransactionAllowed property with value true);}if (debugEnabled) {logger.debug(Creating nested transaction with name [ definition.getName() ]);}// 嵌套事务的处理if (useSavepointForNestedTransaction()) {// Create savepoint within existing Spring-managed transaction,// through the SavepointManager API implemented by TransactionStatus.// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.// 如果没有可以使用保存点的方式控制事务回滚那么在嵌入式事务的建立初始简历保存点DefaultTransactionStatus status prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);// 为事务设置一个回退点status.createAndHoldSavepoint();return status;}else {// Nested transaction through nested begin and commit/rollback calls.// Usually only for JTA: Spring synchronization might get activated here// in case of a pre-existing JTA transaction.// 有些情况是不能使用保存点操作return startTransaction(definition, transaction, debugEnabled, null);}}// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.if (debugEnabled) {logger.debug(Participating in existing transaction);}if (isValidateExistingTransaction()) {if (definition.getIsolationLevel() ! TransactionDefinition.ISOLATION_DEFAULT) {Integer currentIsolationLevel TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();if (currentIsolationLevel null || currentIsolationLevel ! definition.getIsolationLevel()) {Constants isoConstants DefaultTransactionDefinition.constants;throw new IllegalTransactionStateException(Participating transaction with definition [ definition ] specifies isolation level which is incompatible with existing transaction: (currentIsolationLevel ! null ?isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :(unknown)));}}if (!definition.isReadOnly()) {if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {throw new IllegalTransactionStateException(Participating transaction with definition [ definition ] is not marked as read-only but existing transaction is);}}}boolean newSynchronization (getTransactionSynchronization() ! SYNCHRONIZATION_NEVER);return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);}最后来看看 startTransaction() 方法 /*** Start a new transaction.*/private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,boolean debugEnabled, Nullable SuspendedResourcesHolder suspendedResources) {// 是否需要新同步boolean newSynchronization (getTransactionSynchronization() ! SYNCHRONIZATION_NEVER);// 创建新的事务DefaultTransactionStatus status newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);// 开启事务和连接doBegin(transaction, definition);// 新同步事务的设置针对于当前线程的设置prepareSynchronization(status, definition);return status;}doBegin方法开启和连接事务 Overrideprotected void doBegin(Object transaction, TransactionDefinition definition) {// 强制转化事务对象DataSourceTransactionObject txObject (DataSourceTransactionObject) transaction;Connection con null;try {// 判断事务对象没有数据库连接持有器if (!txObject.hasConnectionHolder() ||txObject.getConnectionHolder().isSynchronizedWithTransaction()) {// 通过数据源获取一个数据库连接对象Connection newCon obtainDataSource().getConnection();if (logger.isDebugEnabled()) {logger.debug(Acquired Connection [ newCon ] for JDBC transaction);}// 把我们的数据库连接包装成一个ConnectionHolder对象 然后设置到我们的txObject对象中去txObject.setConnectionHolder(new ConnectionHolder(newCon), true);}// 标记当前的连接是一个同步事务txObject.getConnectionHolder().setSynchronizedWithTransaction(true);con txObject.getConnectionHolder().getConnection();// 为当前的事务设置隔离级别Integer previousIsolationLevel DataSourceUtils.prepareConnectionForTransaction(con, definition);// 设置先前隔离级别txObject.setPreviousIsolationLevel(previousIsolationLevel);// 设置是否只读txObject.setReadOnly(definition.isReadOnly());// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,// so we dont want to do it unnecessarily (for example if weve explicitly// configured the connection pool to set it already).// 关闭自动提交if (con.getAutoCommit()) {//设置需要恢复自动提交txObject.setMustRestoreAutoCommit(true);if (logger.isDebugEnabled()) {logger.debug(Switching JDBC Connection [ con ] to manual commit);}// 关闭自动提交con.setAutoCommit(false);}// 判断事务是否需要设置为只读事务prepareTransactionalConnection(con, definition);// 标记激活事务txObject.getConnectionHolder().setTransactionActive(true);// 设置事务超时时间int timeout determineTimeout(definition);if (timeout ! TransactionDefinition.TIMEOUT_DEFAULT) {txObject.getConnectionHolder().setTimeoutInSeconds(timeout);}// Bind the connection holder to the thread.// 绑定我们的数据源和连接到我们的同步管理器上把数据源作为key,数据库连接作为value 设置到线程变量中if (txObject.isNewConnectionHolder()) {// 将当前获取到的连接绑定到当前线程TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());}}catch (Throwable ex) {if (txObject.isNewConnectionHolder()) {// 释放数据库连接DataSourceUtils.releaseConnection(con, obtainDataSource());txObject.setConnectionHolder(null, false);}throw new CannotCreateTransactionException(Could not open JDBC Connection for transaction, ex);}}注意在上述doBegin方法源码中的第42行关闭了自动提交同时第60行把连接绑定到本地线程中bindResource方法
业务代码使用事务
业务代码使用事务的方式有如下2种一种是编程式事务另一种是AOP事务。
编程式事务
编程式事务要求开发人员手动使用事务管理器创建事务开始事务和结束事务。Spring只需要提前配置并实例化好事务管理器Bean然后注入到Service中即可。参考如下案例代码insertUser()方法为主要业务方法其中调用了2个方法分别负责插入用户和插入业务日志。 Autowiredprivate UserDao userDao;Autowiredprivate PlatformTransactionManager txManager;Autowiredprivate LogService logService;Transactionalpublic void insertUser(User u) {// 1、创建事务定义DefaultTransactionDefinition definition new DefaultTransactionDefinition();// 2、根据定义开启事务TransactionStatus status txManager.getTransaction(definition);try {this.userDao.insert(u);Log log new Log(System.currentTimeMillis() , System.currentTimeMillis() - u.getUserName());// this.doAddUser(u);this.logService.insertLog(log);// 3、提交事务txManager.commit(status);} catch (Exception e) {// 4、异常了回滚事务txManager.rollback(status);throw e;}}AOP事务
接下来是AOP事务给事务方法加上Transactional注解之后。来看看在Spring中这块是如何处理的。 通过Debug的方式可以看到在调用Transactional标记的方法之前Spring自动创建了Cglib代理对象调用的是代理对象的insertUser方法处理的关键流程 org.springframework.transaction.interceptor.TransactionInterceptor 就是事务处理的Advisor。下面是的他的invoke方法。
OverrideNullablepublic Object invoke(MethodInvocation invocation) throws Throwable {// Work out the target class: may be {code null}.// The TransactionAttributeSource should be passed the target class// as well as the method, which may be from an interface.Class? targetClass (invocation.getThis() ! null ? AopUtils.getTargetClass(invocation.getThis()) : null);// Adapt to TransactionAspectSupports invokeWithinTransaction...return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);}进入到TransactionAspectSupport.invokeWithinTransaction()方法中其中第46行会调用具体的业务方法完成事务操作。 Nullableprotected Object invokeWithinTransaction(Method method, Nullable Class? targetClass,final InvocationCallback invocation) throws Throwable {// If the transaction attribute is null, the method is non-transactional.// 获取我们的事务属性源对象TransactionAttributeSource tas getTransactionAttributeSource();// 通过事务属性源对象获取到当前方法的事务属性信息final TransactionAttribute txAttr (tas ! null ? tas.getTransactionAttribute(method, targetClass) : null);// 获取我们配置的事务管理器对象final TransactionManager tm determineTransactionManager(txAttr);if (this.reactiveAdapterRegistry ! null tm instanceof ReactiveTransactionManager) {ReactiveTransactionSupport txSupport this.transactionSupportCache.computeIfAbsent(method, key - {if (KotlinDetector.isKotlinType(method.getDeclaringClass()) KotlinDelegate.isSuspend(method)) {throw new TransactionUsageException(Unsupported annotated transaction on suspending function detected: method . Use TransactionalOperator.transactional extensions instead.);}ReactiveAdapter adapter this.reactiveAdapterRegistry.getAdapter(method.getReturnType());if (adapter null) {throw new IllegalStateException(Cannot apply reactive transaction to non-reactive return type: method.getReturnType());}return new ReactiveTransactionSupport(adapter);});return txSupport.invokeWithinTransaction(method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);}PlatformTransactionManager ptm asPlatformTransactionManager(tm);// 获取连接点的唯一标识 类名方法名final String joinpointIdentification methodIdentification(method, targetClass, txAttr);// 声明式事务处理if (txAttr null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {// Standard transaction demarcation with getTransaction and commit/rollback calls.// 创建TransactionInfoTransactionInfo txInfo createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);Object retVal;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);}if (retVal ! null vavrPresent VavrDelegate.isVavrTry(retVal)) {// Set rollback-only in case of Vavr failure matching our rollback rules...TransactionStatus status txInfo.getTransactionStatus();if (status ! null txAttr ! null) {retVal VavrDelegate.evaluateTryFailure(retVal, txAttr, status);}}//成功后提交会进行资源储量连接释放恢复挂起事务等操作commitTransactionAfterReturning(txInfo);return retVal;}else {// 编程式事务处理Object result;final ThrowableHolder throwableHolder new ThrowableHolder();// Its a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.try {result ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status - {TransactionInfo txInfo prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);try {Object retVal invocation.proceedWithInvocation();if (retVal ! null vavrPresent VavrDelegate.isVavrTry(retVal)) {// Set rollback-only in case of Vavr failure matching our rollback rules...retVal VavrDelegate.evaluateTryFailure(retVal, txAttr, status);}return retVal;}catch (Throwable ex) {if (txAttr.rollbackOn(ex)) {// A RuntimeException: will lead to a rollback.if (ex instanceof RuntimeException) {throw (RuntimeException) ex;}else {throw new ThrowableHolderException(ex);}}else {// A normal return value: will lead to a commit.throwableHolder.throwable ex;return null;}}finally {cleanupTransactionInfo(txInfo);}});}catch (ThrowableHolderException ex) {throw ex.getCause();}catch (TransactionSystemException ex2) {if (throwableHolder.throwable ! null) {logger.error(Application exception overridden by commit exception, throwableHolder.throwable);ex2.initApplicationException(throwableHolder.throwable);}throw ex2;}catch (Throwable ex2) {if (throwableHolder.throwable ! null) {logger.error(Application exception overridden by commit exception, throwableHolder.throwable);}throw ex2;}// Check result state: It might indicate a Throwable to rethrow.if (throwableHolder.throwable ! null) {throw throwableHolder.throwable;}return result;}}然后进入到createTransactionIfNecessary方法中 protected TransactionInfo createTransactionIfNecessary(Nullable PlatformTransactionManager tm,Nullable TransactionAttribute txAttr, final String joinpointIdentification) {// If no name specified, apply method identification as transaction name.// 如果没有名称指定则使用方法唯一标识并使用DelegatingTransactionAttribute封装txAttrif (txAttr ! null txAttr.getName() null) {txAttr new DelegatingTransactionAttribute(txAttr) {Overridepublic String getName() {return joinpointIdentification;}};}TransactionStatus status null;if (txAttr ! null) {if (tm ! null) {// 获取TransactionStatus事务状态信息status tm.getTransaction(txAttr);}else {if (logger.isDebugEnabled()) {logger.debug(Skipping transactional joinpoint [ joinpointIdentification ] because no transaction manager has been configured);}}}// 根据指定的属性与status准备一个TransactionInforeturn prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);}其中第19行进入 getTransaction()这个方法开始事务。 核心的是doBegin方法。完成 自动提交的关闭和 本地线程 对象的存储 TransactionInterceptor
既然事务是通过TransactionInterceptor来创建的。那TransactionInterceptor是如何注入到容器中的
首先来看看事务的开启注解EnableTransactionManagement 可以看到这个注解导入了一个TransactionManagementConfigurationSelector类。 这个TransactionManagementConfigurationSelector的selectImports方法内部引入了一个重要类ProxyTransactionManagementConfiguration Overrideprotected String[] selectImports(AdviceMode adviceMode) {switch (adviceMode) {case PROXY:return new String[] {AutoProxyRegistrar.class.getName(),ProxyTransactionManagementConfiguration.class.getName()};case ASPECTJ:return new String[] {determineTransactionAspectClass()};default:return null;}}这个类是一个配置类注册了事务的一些相关类上文提到的TransactionInterceptor是其中之一。
/*** 代理事务配置注册事务需要用的一些类而且RoleROLE_INFRASTRUCTURE都是属于内部级别的*/
Configuration(proxyBeanMethods false)
Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {/*** 配置事务属性通知器存放事务注解的方法相关的属性* return*/Bean(name TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)Role(BeanDefinition.ROLE_INFRASTRUCTURE)public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {BeanFactoryTransactionAttributeSourceAdvisor advisor new BeanFactoryTransactionAttributeSourceAdvisor();advisor.setTransactionAttributeSource(transactionAttributeSource);advisor.setAdvice(transactionInterceptor);if (this.enableTx ! null) {advisor.setOrder(this.enableTx.IntegergetNumber(order));}return advisor;}BeanRole(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionAttributeSource transactionAttributeSource() {return new AnnotationTransactionAttributeSource();}/*** 配置事务拦截器实现了方法拦截器*/BeanRole(BeanDefinition.ROLE_INFRASTRUCTURE)public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {TransactionInterceptor interceptor new TransactionInterceptor();interceptor.setTransactionAttributeSource(transactionAttributeSource);if (this.txManager ! null) {interceptor.setTransactionManager(this.txManager);}return interceptor;}
}到这分析结束。
