失效的原因
Spring声明式事务是基于AOP生成的代理类来实现的，而AOP无法拦截内部调用，导致事务失效。
解决方案
- 将事务方法放到另一个类中，甚至可以创建一个“事务层”
- 获取代理对象，通过代理对象调用事务方法
- @Autowired 注入自身，通过注入的bean调用
总之都要修改原来的代码，那么能不能不改代码，答案是可以的。
简单分析一下 Spring AOP 源码
什么时候创建代理？
在AbstractAutoProxyCreator中的postProcessAfterInitialization中，这点很重要，我们需要在postProcessAfterInitialization之前，也就是初始化Bean之前修改内部调用方式
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
Object cacheKey = getCacheKey(beanClass, beanName);
// Create proxy here if we have a custom TargetSource.
// Suppresses unnecessary default instantiation of the target bean:
// The TargetSource will handle target instances in a custom fashion.
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
return null;
}
创建代理
Srpring通过动态代理工厂DefaultAopProxyFactory创建代理， 有JDK和CGLIB两种实现方式。
public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
//如果目标类是接口, 使用JDK动态代理来生成代理类及代理类实例对象
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
//使用Cglib生成代理类及代理类实例对象
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
}
我的解决方案
CGLIB的mathodproxy.invokesuper(proxy, args) 方法可以拦截内部调用，借助CGLIB，我们可以在Spring创建代理之前，对原本的代码进行增强。
TransactionalBeanProcessor
@Configuration
public class TransactionalBeanProcessor implements BeanPostProcessor, ApplicationContextAware {
private ApplicationContext context;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
context = applicationContext;
}
/**
* @param bean 源对象，此时还没有代理对象
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
Method[] methods = bean.getClass().getMethods();
for (Method method : methods) {
// 对Transactional注解的方法进行增强
if (method.isAnnotationPresent(Transactional.class) && !(bean instanceof TransactionalComponent)) {
Enhancer enhancer = new Enhancer();
//CGLIB增强基于继承，Superclass就是被代理的类
enhancer.setSuperclass(bean.getClass());
//代理逻辑放在Callback中
enhancer.setCallback(new TransactionalMethodInterceptor(context));
Object proxy = enhancer.create();
//复制属性
copyAction(proxy, bean);
return proxy;
}
}
return bean;
}
/**
* @param bean 代理对象 AopProxy
* @param beanName
* @return
* @throws BeansException
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
public void copyAction(Object target, Object origin) {
Field[] targetFields = target.getClass().getSuperclass().getDeclaredFields();
Class originClass = origin.getClass();
Map<String, Field> originMap = convertObjectToMap(originClass);
try {
for (Field targetField : targetFields) {
if (!Modifier.isFinal(targetField.getModifiers()) && originMap.containsKey(targetField.getName())) {
targetField.setAccessible(true);
Field originField = originMap.get(targetField.getName());
originField.setAccessible(true);
targetField.set(target, originField.get(origin));
targetField.setAccessible(false);
originField.setAccessible(false);
}
}
} catch (Exception e) {
return;
}
}
public Map<String, Field> convertObjectToMap(Class originClass) {
Map<String, Field> res = new HashMap<String, Field>();
Field[] fields = originClass.getDeclaredFields();
for (Field field : fields) {
res.put(field.getName(), field);
}
return res;
}
}
TransactionalMethodInterceptor
public class TransactionalMethodInterceptor implements MethodInterceptor {
private ApplicationContext context;
public TransactionalMethodInterceptor(ApplicationContext context) {
this.context = context;
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
if (method.isAnnotationPresent(Transactional.class)) {
final Object[] res = {null};
//内部调用改为外部调用
TransactionalUtils.required(context, () -> {
res[0] = methodProxy.invokeSuper(o, objects);
});
return res[0];
}
return methodProxy.invokeSuper(o, objects);
}
}
TransactionalComponent
@Component
public class TransactionalComponent {
public interface Cell {
void run() throws Throwable;
}
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
public void required(Cell cell) throws Throwable {
cell.run();
}
}
TransactionalUtils
public class TransactionalUtils {
private static volatile TransactionalComponent transactionalComponent;
private static synchronized TransactionalComponent getTransactionalComponent(ApplicationContext context) {
if (transactionalComponent == null) {
// 从容器中获取 transactionalComponent
transactionalComponent = context.getBean(TransactionalComponent.class);
}
return transactionalComponent;
}
public static void required(ApplicationContext context, TransactionalComponent.Cell cell) throws Throwable {
getTransactionalComponent(context).required(cell);
}
}
打完收工！！！
本文参考了以下博文，特此感谢：
https://blog.csdn.net/qq_28033719/article/details/108339751
https://baijiahao.baidu.com/s?id=1682843530518078672&wfr=spider&for=pc
