Spring编程事务和声明式事务

1.声明式事务: 例如在XML文件里配置的事务

<aop:config>  
    <aop:pointcut id="testService" expression="execution (* com.nnngu.service.MyBatisService.*(..))"/>  
    <aop:advisor advice-ref="advice" pointcut-ref="testService"/>  
</aop:config>  

或者使用注解： @Transaction

 

2.TransactionTemplate编程式事务

优点:事务粒度控制的比较好, 比如调用第三方不能加入事务，那么事务只用包住业务代码就好，

使用TransactionTemplate过程中，发现如果能再封装一层就更好了

 

 封装事务模板接口：

package transaction.template;

import transaction.callback.ServiceCallBack;

//为了封装事务模板
public interface TransactionService<T> {

    T excuteNotInTransaction(Object o, ServiceCallBack serviceCallBack);


    T excuteWithInTransactionWithResult(Object o, ServiceCallBack serviceCallBack);

}

 

package transaction.template;

import transaction.callback.ServiceCallBack;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

import javax.annotation.Resource;

@Service
public class TransactionServiceImpl<T> implements TransactionService {

    //事务模板的execute方法： 开启事务--执行业务--提交事务
    @Resource
    private TransactionTemplate transactionTemplate;


    @Override
    public T excuteNotInTransaction(Object o, ServiceCallBack serviceCallBack) {
        return (T) serviceCallBack.doBusinessCallBack(o);
    }


    @Override
    public T excuteWithInTransactionWithResult(Object object, ServiceCallBack serviceCallBack) {

        return transactionTemplate.execute(status -> {
            System.out.println("执行方法---带事务--开始");
            //可以自定义异常，是否回滚
            Object result = serviceCallBack.doBusinessCallBack(object);
            System.out.println("执行方法---带事务--E结束");
            return (T) result;
        });

    }

}

 

CallBack接口

package transaction.callback;

public interface ServiceCallBack<T> {
    T doBusinessCallBack(Object o);
}

抽象类接口，规范子类调用

package transaction.callback;

public abstract class AbstractServiceCallBack<T> implements ServiceCallBack{

    @Override
    public T doBusinessCallBack(Object o) {
        checkAndLockBeforeBusiness(o);
        return doBusiness(o);
    }

    public abstract void checkAndLockBeforeBusiness(Object o);

    public abstract T doBusiness(Object o);

    public abstract void afterBusiness(Object o);
}

 

具体业务类

package transaction.business;

import transaction.entity.PayOrder;


public interface RepaymentBusinessService{

    void repay(PayOrder payOrder);

}

package transaction.business;

import transaction.callback.AbstractServiceCallBack;
import transaction.entity.PayOrder;
import transaction.template.TransactionService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;


@Service
public class RepaymentBusinessServiceImpl<T> extends AbstractServiceCallBack implements RepaymentBusinessService {

    @Resource
    private TransactionService transactionService;


    @Override
    public void repay(PayOrder payOrder) {
        Object result = transactionService.excuteWithInTransactionWithResult(payOrder, this);
        //调用第三方

        //调用第三方之后的操作
        this.afterBusiness(result);
    }


    @Override
    public void checkAndLockBeforeBusiness(Object object) {
        PayOrder order = (PayOrder) object;
        System.out.printf("checkAndLockBeforeBusiness withInTransaction: %s", order);
    }

    @Override
    public T doBusiness(Object object) {
        PayOrder order = (PayOrder) object;
        System.out.printf("doBusiness withInTransaction: %s", order);
        //业务操作--start
        //比如增删改查
        //业务操作--end
        order.setDesc("doBusiness withInTransaction");
        return (T) order;
    }

    @Override
    public void afterBusiness(Object result) {
        System.out.println("afterBusiness not InTransaction");
    }

}