TransactionTemplate编程式事务管理方式的进阶使用---自定义拓展模板类

1, 前面一篇的文章介绍了TransactionTemplate的基本使用方法.

　同事在其基础上又做了一层封装,这样更贴合本公司的业务与规范.

2, 首先定义了两个接口:

　　

ServiceTemplate ---->   对TransactionTemplate进行了封装

 public interface ServiceTemplate {

     /**
      * <pre> 无事务模板执行业务处理
      * 1. 异常捕获，及分类处理
      * 2. 业务日志记录
      * </pre>
      *
      * @param <T>
      * @param clazz  返回对象
      * @param action 业务操作回调的接口
      * @return       服务返回对象
      */
     <T> T executeWithoutTransaction(Class<? extends Result> clazz, ServiceCallback action);

     /**
      * <pre> 支持本地事务模板执行业务处理
      * 1. 本地事务封装
      * 2. 异常捕获，及分类处理
      * 3. 业务日志记录
      * </pre>
      *
      * @param <T>
      * @param clazz  返回对象
      * @param action 业务操作回调的接口
      * @return       服务返回对象
      */
     <T> T execute(Class<? extends Result> clazz, ServiceCallback action);

 }

ServiceCallback  ---->  对TransactionCallBack进行了封装

 public interface ServiceCallback {
     /**
      * <pre> 校验
      * 对于校验不通过，异常驱动返回
      * </pre>
      */
     void doLock();

     /**
      * <pre> 校验
      * 对于校验不通过，异常驱动返回
      * </pre>
      */
     void check();

     /**
      * <pre> 执行业务逻辑
      * </pre>
      * @return
      */
     Result executeService();
 }

ServiceTemplate的具体实现如下:
　

 public class ServiceTemplateImpl implements ServiceTemplate {

     /** 事务模板 */
     @Autowired
     private TransactionTemplate transactionTemplate;

     @Override
     public <T> T executeWithoutTransaction(Class<? extends Result> clazz,
                                            ServiceCallback action) {
         Result result = null;
         try {
             // 执行校验
             action.check();
             //锁操作
             action.doLock();

             // 执行处理逻辑
             result = action.executeService();
             //可以对结果进行初步校验TODO

         } catch (自定义异常 e) {
             //打日志TODO
             return (T) result;

         } catch (Throwable e2) {
           //打日志TODO
             return (T) result;
         }

         return (T) result;
     }

     @Override
     @SuppressWarnings("unchecked")
     public <T> T execute(final Class<? extends Result> clazz, final ServiceCallback action) {
         T acResult = (T) transactionTemplate.execute(new TransactionCallback() {
             /**
              * @see org.springframework.transaction.support.TransactionCallback#doInTransaction(org.springframework.transaction.TransactionStatus)
              */
             public Object doInTransaction(TransactionStatus status) {

                 Result result = null;

                 try {

                     result = clazz.newInstance();
                     // 执行校验逻辑
                     action.check();

                     //锁操作
                     action.doLock();

                     // 执行处理逻辑
                     result = action.executeService();
                     // 返回值异常处理
                     if (result == null || !(result instanceof BaseResult)) {
                         throw new 自定义异常;
                     }

                 } catch (自定义异常 e) {
                     // 业务异常捕获, 回滚, 打日志TODO

                     status.setRollbackOnly();

                     return result;
                 } catch (Throwable e2) {
                     // 系统异常捕获, 回滚, 打日志TODO
                     status.setRollbackOnly();
                     return result;
                 }
                 return result;
             }
         });
         return acResult;
     }

 }

3, 在业务方法中使用ServiceTemplate, 通过构建ServiceCallBack匿名内部类的方式, 传递具体的业务代码:

  public Result update(final BaseOrder baseOrder) {
         return serviceTemplate.execute(BooleanResult.class, new ServiceCallback() {
             @Override
             public void doLock() {
                 //进行锁操作
             }

             @Override
             public void check() {
               //进行校验
             }

             @Override
             public Result executeService() {
                 Result result = new Result();
                 //具体的业务代码
                 return result;
             }
         });
     }

注意: 如果是不需要加事务的方法, 如查询 ,那么调用serviceTemplate的executeWithoutTransaction即可