spring tx标签配置事务的解析过程

昨天遇到个问题，同一事务内，前一步插入成功的记录，后面的查询不到这条记录，折腾了我好久，最后发现自己把工具类放错包了 。

刚好也顺便看了下tx标签配置方式下 事务的解析过程，参考地址：

http://michael-softtech.iteye.com/blog/monthblog/2010-11

首先关于spring事务的配置方式，相信大家都知道是有5种，但我们经常使用的应该就是基于注解和tx标签配置拦截器两种方式了，而我接触过项目一直以来都是tx方法

虽说知道怎么去配置，但一直以来没有深究具体过程，正好借这个机会学习下。

<!-- 通知 --><tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="add*" propagation="REQUIRED"/> <tx:method name="save*" propagation="REQUIRED"/> <tx:method name="insert*" propagation="REQUIRED"/> <tx:method name="update*" propagation="REQUIRED"/> <tx:method name="find*" propagation="NOT_SUPPORTED" read-only="true"/> <tx:method name="select*" propagation="NOT_SUPPORTED" read-only="true"/> <tx:method name="get*" propagation="NOT_SUPPORTED" read-only="true"/> <tx:method name="load*" propagation="NOT_SUPPORTED" read-only="true" /> <tx:method name="search*" propagation="NOT_SUPPORTED" read-only="true" /> </tx:attributes> </tx:advice> <!-- aop事务代理 --> <aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.com.wp.**.serviceImpl.*.*(..))"/> </aop:config>

可以看到 事务的控制是基于事务管理器 transactionManager ,关于标签的含义这里不作说明

spring xml标签解析一般需要 BeanDefinitionParser ,NamespaceHandler  tx对应的类为  TxNamespaceHandler ，TxAdviceBeanDefinitionParser

查看TxNamespaceHandler 源码

@Overridepublic void init() {registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());}

可以看到在init初始化方法中  通过registerBeanDefinitionParser注册了对 advice属性的解析类  TxAdviceBeanDefinitionParser

虽说是这样，但对于何时调用这个方法还是一头雾水，而spring解析xml是通过DefaultNamespaceHandlerResolver入口 

查看DefaultNamespaceHandlerResolver类 有个resolve方法，单词意思很明确-> 解析

代码如下：

@Overridepublic NamespaceHandler resolve(String namespaceUri) {Map<String, Object> handlerMappings = getHandlerMappings();Object handlerOrClassName = handlerMappings.get(namespaceUri);if (handlerOrClassName == null) {return null;}else if (handlerOrClassName instanceof NamespaceHandler) {return (NamespaceHandler) handlerOrClassName;}else {String className = (String) handlerOrClassName;try {Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +"] does not implement the [" + NamespaceHandler.class.getName() + "] interface");}NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);namespaceHandler.init();handlerMappings.put(namespaceUri, namespaceHandler);return namespaceHandler;}catch (ClassNotFoundException ex) {throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +namespaceUri + "] not found", ex);}catch (LinkageError err) {throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +namespaceUri + "]: problem with handler class file or dependent class", err);}}}

此方法就是根据namespaceUri解析出对应的namespaceHandler  得到handler以后调用对应的init方法

上面是之前画的xmlWebApplicationContext加载bean的过程

可以看出resolve 以及parse的调用位置

查看 NamespaceHandler的实现类 NamespaceHandlerSupport 的parse方法

@Overridepublic BeanDefinition parse(Element element, ParserContext parserContext) {return findParserForElement(element, parserContext).parse(element, parserContext);}

findParserForElement方法

private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {String localName = parserContext.getDelegate().getLocalName(element);BeanDefinitionParser parser = this.parsers.get(localName);if (parser == null) {parserContext.getReaderContext().fatal("Cannot locate BeanDefinitionParser for element [" + localName + "]", element);}return parser;}

该方法通过elment解析出对应的BeanDefinitionParser 这里element为 advice元素 因此得到的即为之前注册过的TxAdviceBeanDefinitionParser

查看对应的parse方法，在其祖父类 AbstractBeanDefinitionParser中

@Overridepublic final BeanDefinition parse(Element element, ParserContext parserContext) {AbstractBeanDefinition definition = parseInternal(element, parserContext);if (definition != null && !parserContext.isNested()) {try {String id = resolveId(element, definition, parserContext);if (!StringUtils.hasText(id)) {parserContext.getReaderContext().error("Id is required for element '" + parserContext.getDelegate().getLocalName(element)+ "' when used as a top-level tag", element);}String[] aliases = null;if (shouldParseNameAsAliases()) {String name = element.getAttribute(NAME_ATTRIBUTE);if (StringUtils.hasLength(name)) {aliases = StringUtils.trimArrayElements(StringUtils.commaDelimitedListToStringArray(name));}}BeanDefinitionHolder holder = new BeanDefinitionHolder(definition, id, aliases);registerBeanDefinition(holder, parserContext.getRegistry());if (shouldFireEvents()) {BeanComponentDefinition componentDefinition = new BeanComponentDefinition(holder);postProcessComponentDefinition(componentDefinition);parserContext.registerComponent(componentDefinition);}}catch (BeanDefinitionStoreException ex) {parserContext.getReaderContext().error(ex.getMessage(), element);return null;}}return definition;}

其中调用了 parseInternal方法  跟踪是在其子类AbstractSingleBeanDefinitionParser实现了该方法 也就是TxAdviceBeanDefinitionParser的父类实现的

查看对应代码

@Overrideprotected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();String parentName = getParentName(element);if (parentName != null) {builder.getRawBeanDefinition().setParentName(parentName);}<span style="white-space:pre"></span>//获取bean的类型Class<?> beanClass = getBeanClass(element);if (beanClass != null) {builder.getRawBeanDefinition().setBeanClass(beanClass);}else {String beanClassName = getBeanClassName(element);if (beanClassName != null) {builder.getRawBeanDefinition().setBeanClassName(beanClassName);}}builder.getRawBeanDefinition().setSource(parserContext.extractSource(element));if (parserContext.isNested()) {// Inner bean definition must receive same scope as containing bean.builder.setScope(parserContext.getContainingBeanDefinition().getScope());}if (parserContext.isDefaultLazyInit()) {// Default-lazy-init applies to custom bean definitions as well.builder.setLazyInit(true);}doParse(element, parserContext, builder);return builder.getBeanDefinition();}

其中有注释地方 可以看到是通过调用 getBeanClass来获取bean的类型，而此方法在TxAdviceBeanDefinitionParser实现

@Overrideprotected Class<?> getBeanClass(Element element) {return TransactionInterceptor.class;}

  到这里tx:advice标签解析流程已经很清晰，最后得到了一个classname为TransactionInterceptor的BeanDefinition并注册

   TransactionInterceptor 类的定义

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {

其中实现了MethodInterceptor接口 spring AOP接口

查看invoke方法

@Overridepublic Object invoke(final 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 TransactionAspectSupport's invokeWithinTransaction...return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {@Overridepublic Object proceedWithInvocation() throws Throwable {return invocation.proceed();}});}

其中调用了invokeWithinTransaction 

代码如下：

protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)throws Throwable {// If the transaction attribute is null, the method is non-transactional.final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);final PlatformTransactionManager tm = determineTransactionManager(txAttr);final String joinpointIdentification = methodIdentification(method, targetClass);if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {// Standard transaction demarcation with getTransaction and commit/rollback calls.TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);Object retVal = null;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 exceptioncompleteTransactionAfterThrowing(txInfo, ex);throw ex;}finally {cleanupTransactionInfo(txInfo);}commitTransactionAfterReturning(txInfo);return retVal;}else {// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.try {Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,new TransactionCallback<Object>() {@Overridepublic Object doInTransaction(TransactionStatus status) {TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);try {return invocation.proceedWithInvocation();}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.return new ThrowableHolder(ex);}}finally {cleanupTransactionInfo(txInfo);}}});// Check result: It might indicate a Throwable to rethrow.if (result instanceof ThrowableHolder) {throw ((ThrowableHolder) result).getThrowable();}else {return result;}}catch (ThrowableHolderException ex) {throw ex.getCause();}}}

  看到final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);这行代码

我自己理解就是查看当前执行方法是否满足tx:method中配置的方法

其中TransactionAtrributeSource的一个实现类NameMatchTransactionAttributeSource的getTransactionAttribute方法为

@Overridepublic TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {if (!ClassUtils.isUserLevelMethod(method)) {return null;}// Look for direct name match.String methodName = method.getName();TransactionAttribute attr = this.nameMap.get(methodName);if (attr == null) {// Look for most specific name match.String bestNameMatch = null;for (String mappedName : this.nameMap.keySet()) {if (isMatch(methodName, mappedName) &&(bestNameMatch == null || bestNameMatch.length() <= mappedName.length())) {attr = this.nameMap.get(mappedName);bestNameMatch = mappedName;}}}return attr;}

  而isMatch方法是判断当前执行方法名与配置的名字是否匹配

protected boolean isMatch(String methodName, String mappedName) {return PatternMatchUtils.simpleMatch(mappedName, methodName);}

  继续看simpleMatch源码

public static boolean simpleMatch(String pattern, String str)  {    if ((pattern == null) || (str == null)) {      return false;    }    int firstIndex = pattern.indexOf('*');    if (firstIndex == -1) {      return pattern.equals(str);    }    if (firstIndex == 0) {      if (pattern.length() == 1) {        return true;      }      int nextIndex = pattern.indexOf('*', firstIndex + 1);      if (nextIndex == -1) {        return str.endsWith(pattern.substring(1));      }      String part = pattern.substring(1, nextIndex);      if ("".equals(part)) {        return simpleMatch(pattern.substring(nextIndex), str);      }      int partIndex = str.indexOf(part);      while (partIndex != -1) {        if (simpleMatch(pattern.substring(nextIndex), str.substring(partIndex + part.length()))) {          return true;        }        partIndex = str.indexOf(part, partIndex + 1);      }      return false;    }

到这里相信大家明白了，tx:method标签配置的作用了 

spring AOP的是基于method的 所以这里决定了method是否需要开启事务

整个过程就是这样，解析出advice对应的bean  TransactionInterceptor 然后通过配置AOP   pointcut 来指定切面位置