自动支持事务的类
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;
}
}