spring基本使用(15)-springtx的使用以及原理1 基于xml声明式事务原理解析

1、事务的基本知识点：

      1.1、事务的特性：

                 A(原子性 Automic)

                C(一致性 Consistency)

                 I(隔离性 Isolation)

                 D(持久性 Duration)

       1.2、数据并发问题

               1、脏读：A事务读取B事务尚未提交的更改数据。

               2、不可重复读：同一个事务中，多次查询，可能查询到的值是不一样的。

               3、幻读：A事务读取到了B事务新增的数据。

               4、第一类数据丢失：A事务撤销的时候，把已提交事务的B事务的更新数据覆盖。

               5、第二类更新丢失：A事务覆盖B事务已经提交的数据。

       1.3、事务隔离级别

隔离级别	脏读	幻读	不可重复读	第一类丢失更新	第二类丢失更新
READ_UNCOMMITED	会	会	会	不会	会
READ_COMMITED	不会	会	会	不会	会
REPEATABLE READ	不会	不会	会	不会	不会
SERIALIZABLE	不会	不会	不会	不会	不会

 

2、Spring中事务的传播机制

            

 

3、Spring中基于xml声明事务

 

4、基于xml这种方式声明事务的原理分析

      我们使用了

      4.1、tx 命名空间的解析TxNameSpaceHandler其源码如下：

public class TxNamespaceHandler extends NamespaceHandlerSupport {
    标签中用于指定事务管理器的参数名称用法
    static final String TRANSACTION_MANAGER_ATTRIBUTE = "transaction-manager";

    默认的事务管理器名称
    static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";

    public TxNamespaceHandler() {
    }

    获取事务管理器的名称方法
    static String getTransactionManagerName(Element element) {
        return element.hasAttribute("transaction-manager") ? element.getAttribute("transaction-manager") : "transactionManager";
    }

    TxNamespaceHandler 的初始化方法，执行时机在解析xml期间，会先实例化TxNamespaceHandler实例，然后后使用实例来调用init()方法。
    public void init() {

        注册解析

       4.2、我们目前是使用了，我们带着问题过去，既然

          我们先来看TxAdviceBeanDefinitionParser的类图：

                         

           我们要找的parse()方法在AbstractBeanDefinitionParser类中，其源码如下：

	@Override
	public final BeanDefinition parse(Element element, ParserContext parserContext) {
                解析元素element从而得到一个BeanDefinition实例，此方法是抽象方法在子类
                AbstractSingleBeanDefinitionParser中有实现，我们待会需要查看 
                AbstractSingleBeanDefinitionParser的parseInternal方法实现。
		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));
					}
				}

                                使用上面解析到的BeanDefinition实例来构建一个BeanDefinitionHolder并注册到IOC容器中。
				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;
	}

                  AbstractSingleBeanDefinitionParser的parseInternal方法实现如下：

@Override
	protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        创建一个空的GenericBeanDefinition以及BeanDefinitionBuilder
		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition();
		String parentName = getParentName(element);
		if (parentName != null) {
			builder.getRawBeanDefinition().setParentName(parentName);
		}
                获取一个beanClass类型，这个在TxAdviceBeanDefinitionParser中实现了，且返回是一个TransactionInterceptor.class
		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);
		}
                做解析在TransactionInterceptor中实现了doParse方法。
		doParse(element, parserContext, builder);
		return builder.getBeanDefinition();
	}

                   从AbstractSingleBeanDefinitionParser的parseInternal方法中我们知道是构建一个类型为TransactionInterceptor的BeanDefinition实例注册到IOC容器中。这个TransactionInterceptor其实就是Advice类型的增强，也就是提供事务的功能的增强。TransactionInterceptor的类图如下：

              

             从类图中我们可以看出TransactionInterceptor继承了抽象类TransactionAspectSupport，TransactionAspectSupport里面提供了事务功能，比如TransactionAspectSupport的invokeWithinTransaction使用事务包围执行某方法，还有比如管理事务管理器的方法determineTransactionManager，提交事务的方法commitTransactionAfterReturning、事务回滚的方法completeTransactionAfterThrowing等。。。

             TransactionAspectSupport的主要的成员属性有：

       使用ThreadLocal绑定当前线程中的事务信息类TransactionInfo，我们可以显示的使用其获取事务信息
       private static final ThreadLocal transactionInfoHolder = new NamedThreadLocal("Current aspect-driven transaction");

       事务管理器的名称
       private String transactionManagerBeanName;

       事务管理器的实例
       private PlatformTransactionManager transactionManager;

       事务资源类 也就是我们配置的 标签数据，在创建事务到时候需要获取书屋的一下属性都是通过这个transactionAttributeSource来获取，比如获取事务的隔离级别、是否只读、事务的传播机制等。
       private TransactionAttributeSource transactionAttributeSource;

       beanFactory 比如应用的上下文
       private BeanFactory beanFactory;

       事务管理器缓存
       private final ConcurrentMap transactionManagerCache = new ConcurrentReferenceHashMap(4);

             既然知道的TransactionAspectSupport组要这些属性那么是在什么时候进行设置的呢？也就是说transactionManager、transactionAttributeSource属性是在什么时候进行设置的呢？我们查看TxAdviceBeanDefinitionParser的

    doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder)方法会有答案，其源码如下：

    protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
        此处传过来的builder中的BeanDefinition的beanClass是TransactionInterceptor.class

        第一步给transactionManager属性添加一个引用，这个引用就是指定事务管理器，其实现就是让
        transactionManager是一个RuntimeBeanReference(beanName)，在TransactionInterceptor类 
        做依赖注入的时候会先实例化+初始化beanName=transactionManager的bean然后赋值给 
        transactionManager这个属性。
        builder.addPropertyReference("transactionManager", TxNamespaceHandler.getTransactionManagerName(element));
        List txAttributes = DomUtils.getChildElementsByTagName(element, "attributes");
        if (txAttributes.size() > 1) {
            parserContext.getReaderContext().error("Element  is allowed at most once inside element ", element);
        } else if (txAttributes.size() == 1) {
            我们只配置了一个 不能配置多个，这里有体现
            Element attributeSourceElement = (Element)txAttributes.get(0);
           
            解析标签生成一个类型为TransactionAttributeSource的
            NameMatchTransactionAttributeSource BeanDefinition实例并且将其注册到IOC容器中。
            RootBeanDefinition attributeSourceDefinition = this.parseAttributeSource(attributeSourceElement, parserContext);

            将transactionAttributeSource赋值为通过解析而得到的
            TransactionAttributeSource 的BeanDefinition实例，在TransactionInterceptor的 
            bean依赖注入的时候会先实例化——初始化类型为TransactionAttributeSource的实例，然后 
            赋值给TransactionInterceptor的transactionAttributeSource属性。
            builder.addPropertyValue("transactionAttributeSource", attributeSourceDefinition);
        } else {
            builder.addPropertyValue("transactionAttributeSource", new RootBeanDefinition("org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"));
        }

    }

 

        4.3、总结    

              TxAdviceBeanDefinitionParser做的事情就是构建一个beanClass=TransactionInterceptor.class的BeanDefinition实例注册到IOC容器中。在构建的过程会设置TransactionInterceptor的transactionManager属性的引用（RuntimeBeanReference），其次还会解析属性生成一个类型是TransactionAttributeSource.class的BeanDefintion实例注册到IOC容器中，并且将其赋值给TransactionInterceptor的transactionAttributeSource属性。因此当IOC容在装载TransactionInterceptor的bean完成后,那么TransactionInterceptor类的bean的transactionManager、transactionAttributeSource属性就会完成依赖注入了。

 

5、装配好的TransactionInterceptor实例如何提供事务
      TransactionInterceptor既然实现了AOP联盟的MethodInterceptor接口，那就一定实现了invoke方法，因此我们的主要重点就是TransactionInterceptor类的public Object invoke(final MethodInvocation invocation) throws Throwable方法，其源码如下：

   public Object invoke(final MethodInvocation invocation) throws Throwable {
        Class targetClass = invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null;

        调用父类TransactionAspectSupport的使用事务执行目标方法。
        return this.invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
            public Object proceedWithInvocation() throws Throwable {
                return invocation.proceed();
            }
        });
    }

        TransactionAspectSupport的invokeWithinTransaction方法实现源码解析

protected Object invokeWithinTransaction(Method method, Class targetClass, final TransactionAspectSupport.InvocationCallback invocation) throws Throwable {
        使用之前构建的TransactionAttributeSource获取事务属性资源
        final TransactionAttribute txAttr = this.getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
        获取事务管理器
        final PlatformTransactionManager tm = this.determineTransactionManager(txAttr);
        final String joinpointIdentification = this.methodIdentification(method, targetClass, txAttr);
        Object result;
        以我们比较熟悉的DataSourceTranscationManager举例，肯定是走else,请移步else
        if (txAttr != null && tm instanceof CallbackPreferringPlatformTransactionManager) {
            final TransactionAspectSupport.ThrowableHolder throwableHolder = new TransactionAspectSupport.ThrowableHolder();

            try {
                result = ((CallbackPreferringPlatformTransactionManager)tm).execute(txAttr, new TransactionCallback