spring 事务

spring的事务是从TransactionProxyFactoryBean开始的TransactionProxyFactoryBean也是一个FactoryBean

源码如下:
public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean
    implements BeanFactoryAware
{

    public TransactionProxyFactoryBean()
    {
    }

    public void setTransactionManager(PlatformTransactionManager transactionManager)
    {
        transactionInterceptor.setTransactionManager(transactionManager);
    }

    public void setTransactionAttributes(Properties transactionAttributes)
    {
        transactionInterceptor.setTransactionAttributes(transactionAttributes);
    }

    public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource)
    {
        transactionInterceptor.setTransactionAttributeSource(transactionAttributeSource);
    }

    public void setPointcut(Pointcut pointcut)
    {
        this.pointcut = pointcut;
    }

    public void setBeanFactory(BeanFactory beanFactory)
    {
        transactionInterceptor.setBeanFactory(beanFactory);
    }

    protected Object createMainInterceptor()
    {
        transactionInterceptor.afterPropertiesSet();
        if(pointcut != null)
            //设置默认的通知器
            return new DefaultPointcutAdvisor(pointcut, transactionInterceptor);
        else
            //使用事务属性通知器
            return new TransactionAttributeSourceAdvisor(transactionInterceptor);
    }

    private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
    private Pointcut pointcut;
}

那么transactionInterceptor这个拦截器是在什么时候启动的。
我们在AbstractSingletonProxyFactoryBean中可以看到产生事务代理对象是在该类中的afterPropertiesSet方法中,其源码如下:
public void afterPropertiesSet()
    {
        if(target == null)
            throw new IllegalArgumentException("Property 'target' is required");
        if(target instanceof String)
            throw new IllegalArgumentException("'target' needs to be a bean reference, not a bean name as value");
        if(proxyClassLoader == null)
            proxyClassLoader = ClassUtils.getDefaultClassLoader();
        ProxyFactory proxyFactory = new ProxyFactory();
        if(preInterceptors != null)
        {
            Object aobj[];
            int k = (aobj = preInterceptors).length;
            for(int i = 0; i < k; i++)
            {
                Object interceptor = aobj[i];
                proxyFactory.addAdvisor(advisorAdapterRegistry.wrap(interceptor));
            }

        }
        //配置通知器
        proxyFactory.addAdvisor(advisorAdapterRegistry.wrap(createMainInterceptor()));
        if(postInterceptors != null)
        {
            Object aobj1[];
            int l = (aobj1 = postInterceptors).length;
            for(int j = 0; j < l; j++)
            {
                Object interceptor = aobj1[j];
                proxyFactory.addAdvisor(advisorAdapterRegistry.wrap(interceptor));
            }

        }
        proxyFactory.copyFrom(this);
       
        if(proxyInterfaces != nullTargetSource targetSource = createTargetSource(target);
        //设置目标接口
        proxyFactory.setTargetSource(targetSource);)
            //设置代理接口
            proxyFactory.setInterfaces(proxyInterfaces);
        else
        if(!isProxyTargetClass())
            proxyFactory.setInterfaces(ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), proxyClassLoader));
        proxy = proxyFactory.getProxy(proxyClassLoader);
    }

Spring事务处理完成AOP配置的地方，这个afterPropertiesSet方法功能实现如下代码


下面我们分析下事务属性的读入
从TransactionProxyFactoryBean中我们可以看到TransactionAttributeSourceAdvisor，我们以这个类为入口从而了解事务属性是如何注入的
TransactionAttributeSourceAdvisor 是一个通知器包含了切面和通知

public TransactionAttributeSourceAdvisor()
    {
        pointcut = new TransactionAttributeSourcePointcut() {

            protected TransactionAttributeSource getTransactionAttributeSource()
            {
                return transactionInterceptor == null ? null : transactionInterceptor.getTransactionAttributeSource();
            }

            final TransactionAttributeSourceAdvisor this$0;

           
            {
                this$0 = TransactionAttributeSourceAdvisor.this;
                super();
            }
        }
;
    }

在声明式事务处理中，是通过对目标对象的方法调用拦截实现，这个拦截通过AOP发挥过作用。对于拦截器启动，首先需要对方法调用是否需要拦截器进行判断，而判断的依据是那些在TrasactionProxyFactoryBean中为目标对象设置的事务属性。也就是说需要判断当前的目标方法调用是不是一个配置好的，需要进行事务处理方法调用。具体说，这个匹配判断在TransactionAtrributeSourcePoincut中完成，它的实现如代码如下：
    public boolean matches(Method method, Class targetClass)
    {
        TransactionAttributeSource tas = getTransactionAttributeSource();
        return tas == null || tas.getTransactionAttribute(method, targetClass) != null;
    }

在pointcut的matches判断过程中，会用到transactionAttributeSource对象，这个对象是在对TranasactionInterceptor进行依赖注入时就配置好了的。它的设置是在基类TransactionAspectSupport完成的，配置了一个NameMatchTransactionAttributeSource代码如下：

public void setTransactionAttributes(Properties transactionAttributes)
    {
        NameMatchTransactionAttributeSource tas = new NameMatchTransactionAttributeSource();
        tas.setProperties(transactionAttributes);
        transactionAttributeSource = tas;
    }


在应用调用目标方法的时候，因为这个目标方法已经被TrasactionProxyFactoryBean代理，所以TrasactionProxyFactoryBean需要判断这个方法是否是事务方法。这个判断的实现，是通过NameMatchTransactionAttributeSource中，能否为这个调用方法事务属性来完成的.具体的实现过程是这样的： 首先，使用调用方法作为索引的namemap中去查找相应的事务处理性值，如果能够找到，那么就说明调用方法和事务方法直接对应，如果找不到，那么就会遍历整个nameMap，对保存在其中的每一个方法名，使用PatternMatchUtils进行命名模式上的匹配。这里使用PatternMatchUtils进行匹配，是因为在设置事务方法的时候，就像我们常见的那样，可以不需要为事务设置一个完整的方法名，而是可以通过设置方法名的命名模式来完成，比如可以通过像对通配符*的使用。

我们看下NameMatchTransactionAttributeSource中的setProperties方法
public void setProperties(Properties transactionAttributes)
    {
        TransactionAttributeEditor tae = new TransactionAttributeEditor();
        String methodName;
        TransactionAttribute attr;
        for(Enumeration propNames = transactionAttributes.propertyNames(); propNames.hasMoreElements(); addTransactionalMethod(methodName, attr))
        {
            methodName = (String)propNames.nextElement();
            String value = transactionAttributes.getProperty(methodName);
            tae.setAsText(value);
            attr = (TransactionAttribute)tae.getValue();
        }

    }
  public TransactionAttribute getTransactionAttribute(Method method, Class targetClass)
    {
         //判断当前目标调用的方法与配置事务方法，是否匹配
        String methodName = method.getName();
        TransactionAttribute attr = (TransactionAttribute)nameMap.get(methodName);
        if(attr == null)
        {
            String bestNameMatch = null;
            for(Iterator iterator = nameMap.keySet().iterator(); iterator.hasNext();)
            {
                String mappedName = (String)iterator.next();
                if(isMatch(methodName, mappedName) && (bestNameMatch == null || bestNameMatch.length() <= mappedName.length()))
                {
                    attr = (TransactionAttribute)nameMap.get(mappedName);
                    bestNameMatch = mappedName;
                }
            }

        }
        return attr;
    }


通过以上过程，可以得到与目标对象调用方法相关TransactionAttribute对象，在这个对象中，封装了事务处理的配置。


事务处理拦截器的实现

在完成以上准备工作后，经过TransactionProxyFactoryBean的AOP包装，此时如果对目标对象进行方法调用，其调用起作用对象实际是一个proxy代理对象，对目标对象方法的调用，不会直接作用在TransactionProxyFactoryBean设置的目标对象上，而会被设置的事务处理拦截器，而对于TransactionProxyFactoryBean的AOP实现中，获取Proxy对象的过程，这个过程并不复杂，TransactionProxyFactoryBean作为一个Factorybean，对这个bean对象的引用，是通过调用TransactionProxyFactoryBean的getObject方法来得到的，我们对这个方法已经很熟悉了

public Object getObject()
    {
        if(proxy == null)
            throw new FactoryBeanNotInitializedException();
        else
            return proxy;
    }

关于如何对AOP代理作用可以看下spring中AOP源码的分析，我们可以注意下TransactionInteceptor中的invoke方法其源码如下：

public Object invoke(final MethodInvocation invocation) throws Throwable {  
    //这里得到目标对象  
    Class targetClass = (invocation.getThis() != null ? invocation.getThis().getClass() : null);  
 
    //这里同样的通过判断是否能够得到TransactionAttribute来决定是否对当前方法进行事务处理，有可能该属性已经被缓存，  
    //具体可以参考上面对getTransactionAttribute的分析，同样是通过TransactionAttributeSource  
    final TransactionAttribute txAttr =  
            getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(), targetClass);  
    final String joinpointIdentification = methodIdentification(invocation.getMethod());  
 
    //这里判断我们使用了什么TransactionManager  
    if (txAttr == null || !(getTransactionManager() instanceof CallbackPreferringPlatformTransactionManager)) {  
        // 这里创建事务，同时把创建事务过程中得到的信息放到TransactionInfo中去  
        TransactionInfo txInfo = createTransactionIfNecessary(txAttr, joinpointIdentification);  
        Object retVal = null;  
        try {  
              retVal = invocation.proceed();  
        }  
        catch (Throwable ex) {  
            // target invocation exception  
            completeTransactionAfterThrowing(txInfo, ex);  
            throw ex;  
        }  
        finally {  
            cleanupTransactionInfo(txInfo);  
        }  
        commitTransactionAfterReturning(txInfo);  
        return retVal;  
    }  
 
    else {  
        // 使用的是Spring定义的PlatformTransactionManager同时实现了回调接口,我们通过其回调函数完成事务处理，就像我们使用编程式事务处理一样。  
        try {  
            Object result = ((CallbackPreferringPlatformTransactionManager) getTransactionManager()).execute(txAttr,  
                    new TransactionCallback() {  
                        public Object doInTransaction(TransactionStatus status) {  
                            //同样的需要一个TransactonInfo  
                            TransactionInfo txInfo = prepareTransactionInfo(txAttr, joinpointIdentification, status);  
                            try {  
                                return invocation.proceed();  
                            }    
                    });  
    }  
} 


在invoke方法中我们可以看到，首先先获得调用方法的事务处理配置，在得到事务处理配置以后，会取得PlatformTranasctionManager由这个事务处理器来实现事务的创建、提交、回滚操作。PlatformTranasctionManager是在IOC容器中配置的。我们比较熟悉有DataSourceTransactionManager和HiberanteTransactionManager等。