概述:
该篇文章讲解spring通过TX命名空间对事务进行委托管理。
原理:
1. spring如何实现事务管理功能:
看下tx命名空间的定义:
http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler
http\://www.springframework.org/schema/tx/spring-tx.xsd=org/springframework/transaction/config/spring-tx-4.2.xsd
看下TxNamespaceHandler类:
public class TxNamespaceHandler extends NamespaceHandlerSupport {
static final String TRANSACTION_MANAGER_ATTRIBUTE = "transaction-manager";
static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";
static String getTransactionManagerName(Element element) {
return (element.hasAttribute(TRANSACTION_MANAGER_ATTRIBUTE) ?
element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE) : DEFAULT_TRANSACTION_MANAGER_BEAN_NAME);
}
@Override
public void init() {
registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
}
}
里面有两个很重要的属性“advice”、“annotation-driven”,两个属性支持了两种不同的事务管理方式。
首先看下“annotation-driven”方式:该种方式支持通过注解方式注入事务管理。
看下xml的配置:
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager" p:dataSource-ref="dataSource" />
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" mode="proxy" />
service类中采用@Transactional即可完成事务的注入。
@Transactional(isolation = Isolation.READ_COMMITTED, propagation = Propagation.REQUIRED)
看下“advice”方式:该种方式支持结合AOP命名空间进行事务注入。
看下xml的配置:
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<!-- 读操作 -->
<tx:method name="select*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="search*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="query*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="find*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="load*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="get*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="list*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<tx:method name="count*" propagation="REQUIRED" isolation="READ_COMMITTED" read-only="true" />
<!-- 其它操作 -->
<tx:method name="*" propagation="REQUIRED" isolation="READ_COMMITTED" rollback-for="Exception" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="txPointcut" expression="execution(* com.company.*.service.impl.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
</aop:config>
也可以采用自定义注解方式进行事务注入,只需把表达式变为:expression="com.company.tx.pointcut.TxPointcuts.txMarkPointcut()"。
package com.company.tx.pointcut;
import org.aspectj.lang.annotation.Pointcut;
public class TxPointcuts {
public TxPointcuts() {
}
@Pointcut("@within(com.company.tx.annotation.TransactionalMark)")
public void txMarkPointcut() {
}
}
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TransactionalMark {
String value() default "";
}
2.分析采用注解方式的源码:
通过 TxNamespaceHandler类可以发现"annotation-driven"标签的解析类为AnnotationDrivenBeanDefinitionParser
看下该类的parse方法:
/**
* Parses the {@code <tx:annotation-driven/>} tag. Will
* {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
* with the container as necessary.
*/
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
registerTransactionalEventListenerFactory(parserContext);
String mode = element.getAttribute("mode");
if ("aspectj".equals(mode)) {
// mode="aspectj"
registerTransactionAspect(element, parserContext);
}
else {
// mode="proxy"
AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
}
return null;
}
解析方式依赖于mode,有两种模式一种"aspectj"另一种”proxy“。
首先看下”proxy“处理方式:
/**
* Inner class to just introduce an AOP framework dependency when actually in proxy mode.
*/
private static class AopAutoProxyConfigurer {
public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
Object eleSource = parserContext.extractSource(element);
// Create the TransactionAttributeSource definition.
RootBeanDefinition sourceDef = new RootBeanDefinition(
"org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
sourceDef.setSource(eleSource);
sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
// Create the TransactionInterceptor definition.
RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
interceptorDef.setSource(eleSource);
interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registerTransactionManager(element, interceptorDef);
interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
// Create the TransactionAttributeSourceAdvisor definition.
RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
advisorDef.setSource(eleSource);
advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
if (element.hasAttribute("order")) {
advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
}
parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
parserContext.registerComponent(compositeDef);
}
}
}
内部类实现了创建一个advisor进行事务拦截处理,该advisor为BeanFactoryTransactionAttributeSourceAdvisor,该类什么时候起作用呢?
AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}
向spring容器注册InfrastructureAdvisorAutoProxyCreator对象,该对象和AnnotationAwareAspectJAutoProxyCreator作用基本相同请查看
《spring的启动过程02.1-aop命名空间解读》、
《spring的启动过程04.2-AnnotationAwareAspectJAutoProxyCreator处理器》。
看下”aspectj“处理方式:
private void registerTransactionAspect(Element element, ParserContext parserContext) {
String txAspectBeanName = TransactionManagementConfigUtils.TRANSACTION_ASPECT_BEAN_NAME;
String txAspectClassName = TransactionManagementConfigUtils.TRANSACTION_ASPECT_CLASS_NAME;
if (!parserContext.getRegistry().containsBeanDefinition(txAspectBeanName)) {
RootBeanDefinition def = new RootBeanDefinition();
def.setBeanClassName(txAspectClassName);
def.setFactoryMethodName("aspectOf");
registerTransactionManager(element, def);
parserContext.registerBeanComponent(new BeanComponentDefinition(def, txAspectBeanName));
}
}
该种方式通过aspectj注解方式实现动态代理,AbstractTransactionAspect切面。
以上两种方式都是依赖AOP方式对bean进行动态代理,一种是实现Advisor接口、一种是依赖AspectJ采用@Aspect注解。
总结:
spring容器通过tx标签实现事务的动态注入,使用方式有两种:1.采用@Transactional方式、2.结合aop功能实现动态代理模式。
下面会单独讲解BeanFactoryTransactionAttributeSourceAdvisor,看看事务是如何动态注入的。