自动支持事务的类 博客分类： 原创 BeanJDBCAOP

自动支持事务的类

package aaa;

import java.util.Properties;

import org.springframework.aop.framework.ProxyFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import org.springframework.util.Assert;

/**
 * <p>解析JDBC事务配置</p> 
 *<meta key="tx" value="save*:PROPAGATION_REQUIRED; "/>
 *<table border="1" width="788">
  <tbody>
    <tr>
      <td width="274" align="center">隔离等级</td>
      <td width="399" align="center">描述</td>
    </tr>
    <tr>
      <td>ISOLATION_DEFAULT</td>
      <td align="center">默认隔离等级<br />
      </td>
    </tr>
    <tr>
      <td>ISOLATION_READ_UNCOMMITTED<br />
      </td>
      <td>最低隔离等级，仅仅保证了读取过程中不会读取到非法数据</td>
    </tr>
    <tr>
      <td>ISOLATION_READ_COMMITTED<br />
      </td>
      <td>某些数据库的默认隔离等级；保证了一个事务不会读到另外一个并行事务已修改但未提交的数据</td>
    </tr>
    <tr>
      <td>ISOLATION_REPEATABLE_READ<br />
      </td>
      <td>比上一个更加严格的隔离等级。保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据</td>
    </tr>
    <tr>
      <td>ISOLATION_SERIALIZABLE</td>
      <td>性能代价最为昂贵，最可靠的隔离等级。所有事务都严格隔离，可视为各事务顺序执行</td>
    </tr>
  </tbody>
</table>
<p> </p>
<p align="left">传播途径(Propagation Behavior)</p>
<p> </p>
<table border="1" width="791">
  <tbody>
    <tr>
      <td width="253" align="center">Propagation Behavior<br />
      </td>
      <td width="522" align="center">描述<br />
      </td>
    </tr>
    <tr>
      <td>PROPAGATION_REQUIRED </td>
      <td>支持现有事务。如果没有则创建一个事务</td>
    </tr>
    <tr>
      <td> PROPAGATION_SUPPORTS </td>
      <td>支持现有事务。如果没有则以非事务状态运行。</td>
    </tr>
    <tr>
      <td> PROPAGATION_MANDATORY </td>
      <td>支持现有事务。如果没有则抛出异常。</td>
    </tr>
    <tr>
      <td> PROPAGATION_REQUIRES_NEW </td>
      <td>总是发起一个新事务。如果当前已存在一个事务，则将其挂起。</td>
    </tr>
    <tr>
      <td>PROPAGATION_NOT_SUPPORTED </td>
      <td>不支持事务，总是以非事务状态运行，如果当前存在一个事务，则将其挂起。</td>
    </tr>
    <tr>
      <td> PROPAGATION_NEVER </td>
      <td> 不支持事务，总是以非事务状态运行，如果当前存在一个事务，则抛出异常。</td>
    </tr>
    <tr>
      <td> PROPAGATION_NESTED </td>
      <td>如果当前已经存在一个事务，则以嵌套事务的方式运行，如果当前没有事务，则以默认方式(第一个)执行</td>
    </tr>
  </tbody>
</table>
 *
 */
public class TransactionManager implements BeanPostProcessor,
		BeanFactoryPostProcessor {

	private ConfigurableListableBeanFactory beanFactory;
	private DataSourceTransactionManager transactionManager;
	private static final String META_TRANSACTION_METHODS_NAME = "tx";

	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		if (beanFactory.containsBean(beanName)) {
			BeanDefinition beanDefinition = beanFactory
					.getBeanDefinition(beanName);

			String transactionAttributeValue = beanDefinition
					.getAttribute(META_TRANSACTION_METHODS_NAME) != null ? beanDefinition
					.getAttribute(META_TRANSACTION_METHODS_NAME).toString()
					: null;
			if (transactionAttributeValue == null) {
				return bean;
			}
			Assert.hasText(transactionAttributeValue,
					"if 'tx' meta is setted , 'tx' meta can't be empty! [ bean id:"
							+ beanName + "]");

			TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
			transactionInterceptor.setTransactionManager(transactionManager);

			Properties transactionAttributes = new Properties();
			
			parseAttributes(transactionAttributes,transactionAttributeValue);

			transactionInterceptor
					.setTransactionAttributes(transactionAttributes);

			TransactionAttributeSourceAdvisor advisor = new TransactionAttributeSourceAdvisor(
					transactionInterceptor);

			ProxyFactory proxyFactory = new ProxyFactory();
			proxyFactory.addAdvisor(advisor);
			proxyFactory.setTarget(beanFactory.getBean(beanName));

			return proxyFactory.getProxy();
		}
		return bean;
	}

	private void parseAttributes(Properties transactionAttributes, String transactionAttributeValue) {
		String[] split = transactionAttributeValue.split(";");
		
		for (int i = 0; i < split.length; i++) {
			String[] splitcolon = split[i].split(":");

			if (splitcolon.length < 2) {
				break;
			}
			
			Assert.hasText(splitcolon[0]," can't  filled with empty string ");
			Assert.hasText(splitcolon[1]," can't  filled with empty string ");

			transactionAttributes.setProperty(splitcolon[0], splitcolon[1]);
		}
	}

	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		return bean;
	}

	public void postProcessBeanFactory(
			ConfigurableListableBeanFactory beanFactory) throws BeansException {
		this.beanFactory = beanFactory;
	}

	public void setTransactionManager(
			DataSourceTransactionManager transactionManager) {
		this.transactionManager = transactionManager;
	}

}