任何Bean通过实现ProxyableBeanAccessor接口即可获得动态灵活的获取代理对 ...

如果一个BEAN类上加了@Transactional，则默认的该类及其子类的公开方法均会开启事务，但有时某些业务场景下某些公开的方法可能并不需要事务，那这种情况该如何做呢？
常规的做法：
针对不同的场景及事务传播特性，定义不同的公开方法【哪怕是同一种业务】，并在方法上添加@Transactional且指明不同的传播特性，示例代码如下：

1. @Service
2. @Transactional
3. public class DemoSerivce {
5.    //SUPPORTED 若无事务传播则默认不会有事务,若有事务传播则会开启事务
6.    @Transactional(propagation = Propagation.SUPPORTED)
7.    public int getValue(){
8.       return 0;
9.    }
12.    //默认开启事务（由类上的@Transactional决定的）
13.    public int getValueWithTx(){
14.       return 0;
15.    }
17.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
18.    public int getValueWithoutTx(){
19.       return 0;
20.    }
22. }

复制代码

上述这样的弊端就是：若是同一个逻辑但如果要精细控制事务，则需要定义3个方法来支持，getValue、getValueWithTx、getValueWithoutTx 3个方法，分别对应3种事务场景，这种代码就显得冗余过多，那有没有简单一点的方案呢？其实是有的。
声明式事务的本质是通过AOP切面，在代理执行原始方法【即：被标注了@Transactional的公开方法】前开启DB事务，在执行后提交DB事务（若抛错则执行回滚），如果要想事务不生效，则让AOP失效即可，即：调原生的service Bean公开方法而不是代理类的公开方法，那如何获得原生的BEAN类呢，答案是：在原生BEAN方法内部通过this获取即可，如果没理解，下面写一个手写代理示例，大家就明白了：

1. public class DemoService{
3.     public int getValue(){
4.         return 666;
5.     }
7.     public DemoService getReal(){
8.         //这里的this指向的就是当前的自己，并非代理对象
9.         return this;
10.     }
11. }
13. public class DemoServiceProxy{
14.     private DemoService target;
16.     public DemoServiceProxy(DemoService target){
17.         this.target=target;
18.     }
20.     public int getValue(){
21.         //增强：开启事务
22.         return  target.getValue()+222;
23.         //增强：提交事务
24.     }
26.     public DemoService getReal(){
27.         //这里就会间接的把原生的对象传递返回
28.         return target.getReal();
29.     }
30. }
32.     public static void main(String[] args) {
33.         DemoServiceProxy proxy=new DemoServiceProxy(new DemoService());
34.         System.out.println("proxy class:" +proxy.getClass().getName());
35.         System.out.println("real class:" +proxy.getReal().getClass().getName());
37.         System.out.println("proxy getValue result:" + proxy.getValue() );
38.         System.out.println("real getValue result:" + proxy.getReal().getValue() );
40.     }

复制代码

最终的输出结果为：
proxy class:...DemoServiceProxy
real class:...DemoService  →原始的对象
proxy getValue result:888
real getValue result:666
通过DEMO证实了通过避开代理的方案是正确的，而且非常简单，那么有了这个基础，再应用到实际的代码中则很简单，想控制有事务则取代理对象，想控制不要事务则取原生对象即可，就是这么简单。

下面贴出核心也是全部的ProxyableBeanAccessor代码：（注意必需扩展自RawTargetAccess，否则即使返回this也会被强制返回代理）

1. /**
2. * @author zuowenjun
3. * @date 2022/12/5 22:03
4. * @description 可代理BEAN访问者接口（支持获取代理的真实对象、获取代理对象）
5. */
6. public interface ProxyableBeanAccessor<T extends ProxyableBeanAccessor> extends RawTargetAccess {
8.     String CONTEXT_KEY_REAL_GET = "proxyable_bean_accessor_real_get";
10.     /**
11.      * 获取代理的真实对象（即：未被代理的对象）
12.      * 注：若调用未被代理的bean的公开方法，则均不会再走AOP切面
13.      *
14.      * @return 未被代理的对象Bean
15.      */
16.     @SuppressWarnings("unchecked")
17.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
18.     default T getReal() {
19.         return (T) this;
20.     }
22.     /**
23.      * 获取当前类的代理对象（即：已被代理的对象）
24.      * 注：若调用已被代理的对象Bean的公开方法，则相关AOP切面均可正常拦截与执行
25.      *
26.      * @return 已被代理的对象Bean
27.      */
28.     @SuppressWarnings("unchecked")
29.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
30.     default T getProxy() {
31.         return (T) SpringUtils.getBean(this.getClass());
32.     }
34.     /**
35.      * 将当前BEAN转换为代理对象或真实对象
36.      *
37.      * @param realGet 是否转换获取真实对象
38.      * @return 未被代理的对象Bean OR 已被代理的对象Bean
39.      */
40.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
41.     default T selfAs(Supplier<Boolean> realGet) {
42.         Boolean needGetReal = false;
43.         if (realGet == null) {
44.             if (ContextUtils.get() != null) {
45.                 needGetReal = (Boolean) ContextUtils.get().getGlobalVariableMap().getOrDefault(CONTEXT_KEY_REAL_GET, false);
46.             }
47.         } else {
48.             needGetReal = realGet.get();
49.         }
51.         return Boolean.TRUE.equals(needGetReal) ? getReal() : getProxy();
52.     }
53. }

复制代码

其中，SpringUtils是一个获取BEAN的工具类，代码如下：

1. public SpringUtils implements ApplicationContextAware{
3. private static ApplicationContext context;
5.     @Override
6.     public void setApplicationContext(ApplicationContext applicationContext)
7.             throws BeansException {
8.         context=applicationContext;
9.     }
11.   public static <T> getBean(Class<T> clazz){
12.      return context.getBean(clazz);
13.    }
14. }

复制代码

ContextUtils只是一个内部定义了一个ThreadLocal的静态map字段，用于存放线程上下文要传递的对象。
使用方法：只需将原来Service的子类或其它可能被切面代理的类 加上实现自ProxyableBeanAccessor即可，然后在这个类里面或外部调用均可通过getReal获得原生对象、getProxy获得代理对象、selfAs动态根据条件来判断是否需要代理或原生对象，使用示例如下：

1. //serive BEAN定义
2. @Service
3. @Transactional
4. public class DemoService implements ProxyableBeanAccessor<DemoService> {
6.    ... ...
8.     public Demo selectByMergerParam(Demo demo){
9.        return getMapper().selectByMergerParam(demo);
10.     }
12.     @Transactional(propagation = Propagation.NOT_SUPPORTED)
13.     public Demo selectByMergerParam2(Demo demo){
14.         //通过getProxy获取当前类的代理BEAN，以便可以执行事务切面
15.         return getProxy().doSelectByMergerParam(demo);
16.     }
18.     public Demo doSelectByMergerParam(Demo demo){
19.         return getMapper().selectByMergerParam(demo);
20.     }
23. }
26. //具体使用:
29.     @Autowired
30.     private DemoService demoService;
33.             Demo query = new Demo ();
34.             query.setWaybillNumber("123455667");
36.             //示例一：获取原生对象查询，由于没有代理，则无事务
37.             demoService.getReal().selectByMergerParam(query);
39.             //示例二：根据LAMBDA表达式的布尔值来决定是否获取原生或代理（这里演示：如果是TIDB，则获取原生对象，即：不开事务）
40.             demoService.selfAs(()-> TidbDataSourceSwitcher.isUsingTidbDataSource()).selectByMergerParam(query);
42.             //示例三：根据线程上下文设置的布尔值来决定是否获取原生或代理（这里演示：如果是TIDB，则获取原生对象，即：不开事务），这种方式主要是为了简化大批量的动态逻辑判断的场景，
43.             // 一次设置同线程的所有ProxyableBeanAccessor的子类的selfAs(null)均可自动判断
44.             ContextUtils.get().addGlobalVariable(ProxyableBeanAccessor.CONTEXT_KEY_REAL_GET,TidbDataSourceSwitcher.isUsingTidbDataSource());
45.             demoService.selfAs(null).selectByMergerParam(query);
47.             //示例四：获取代理对象，一般用于BEAN内部方法之间调用，外部调用其实本身就是代理无意义
48.             demoService.getProxy().selectByMergerParam(query);

复制代码

通过上述示例代码可以看到，借助于ProxyableBeanAccessor接口默认实现的getReal、getProxy、selfAs方法，可以很灵活的实现按需获取代理或非代理对象。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！