27. 代码实例-spring声明式事务

（1）spring配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="   
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd   
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd   
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd    
http://www.springframework.org/schema/util classpath:/org/springframework/beans/factory/xml/spring-util-3.0.xsd
 "
    default-autowire="byName">
    <bean id="paymentSqlSqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
        <property name="configLocation" value="classpath:sqlmap/sqlserver/sqlserver-consume.xml" />
        <property name="dataSource" ref="paymentSqlDataSource" />
    </bean>

    <!-- ============================ payment ======================================= -->
    <bean id="paymentSqlDataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${sqlserver.jdbc.driver}" />
        <property name="url" value="${payment.sqlserver.jdbc.url}" />
        <property name="username" value="${payment.sqlserver.jdbc.username}" />
        <property name="password" value="${payment.sqlserver.jdbc.password}" />
        <property name="maxActive" value="30" />
        <property name="initialSize" value="2" />
        <property name="maxWait" value="60000" />
        <property name="maxIdle" value="30" />
        <property name="minIdle" value="1" />
        <property name="testOnBorrow" value="false"></property>
        <property name="testWhileIdle" value="true"></property>
        <property name="validationQuery" value="select 1 "></property>
        <property name="timeBetweenEvictionRunsMillis">
            <value>300000</value>
        </property>
        <property name="numTestsPerEvictionRun">
            <value>10</value>
        </property>
        <property name="minEvictableIdleTimeMillis" value="300000"></property>
    </bean>
     <bean id="consumeTemplate"  class="org.springframework.orm.ibatis.SqlMapClientTemplate" >  
        <property name="sqlMapClient" ref="paymentSqlSqlMapClient" />  
    </bean> 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="paymentSqlDataSource" />
    </bean>
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
</beans>

 （2）事务相关代码

package com.jd.consume.service.consume.impl;

import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.jd.consume.dao.ConsumeDao;
import com.jd.consume.dao.OrderTaskDao;
import com.jd.consume.domain.ConsumeDetail;
import com.jd.consume.domain.OrderTask;
import com.jd.consume.service.consume.ConsumeChange;

/**
 * 消费额度变更服务
 * @author guanpanpan
 *
 */
@Service(value = "consumeChange")
@Transactional(value = "transactionManager", readOnly = true)
public class ConsumeChangeImpl implements ConsumeChange {
    protected final static Logger log = LoggerFactory.getLogger(ConsumeChangeImpl.class);
    @Resource
    private OrderTaskDao orderTaskDao;
    @Resource
    private ConsumeDao consumeDao;
    public static boolean throwRuntimeExceptionInTransation = false;

    @Transactional(value = "transactionManager", readOnly = false, rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void addConsumeWithSingleTask(OrderTask orderTask) {
        ConsumeDetail consumeDetail = orderTask.genAddConsumeDetail();
        //防止重复执行,如果存在uuid置状态为11
        List<ConsumeDetail> consumeDetails = consumeDao.findConsumeDetailsByUuid(consumeDetail.getUuId());
        if (CollectionUtils.isNotEmpty(consumeDetails)) {
            orderTaskDao.updateStatus(orderTask.getId(), OrderTask.SYN_REPEAT, OrderTask.SYN_LOCK);
            return;
        }
        consumeDao.addConsumeDetail(consumeDetail);
        consumeDao.insertOrUpdateJdConsume(consumeDetail);
        //设置状态为已处理，如果失败会在回滚中置好状态
        orderTaskDao.updateStatus(orderTask.getId(), OrderTask.SYN_COMPLETE, OrderTask.SYN_LOCK);
        if (throwRuntimeExceptionInTransation) {
            throw new RuntimeException("rollBack in Test");
        }
    }

    @Override
    @Transactional(value = "transactionManager", readOnly = false, rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void reduceConsumeWithSingleTask(OrderTask orderTask) {
        ConsumeDetail consumeDetail = orderTask.genPastConsumeDetail();
        //防止重复执行,如果存在uuid置状态为12
        List<ConsumeDetail> consumeDetails = consumeDao.findConsumeDetailsByUuid(consumeDetail.getUuId());
        if (CollectionUtils.isNotEmpty(consumeDetails)) {
            orderTaskDao.updatePastStatus(orderTask.getId(), OrderTask.PAST_REPEAT, OrderTask.PAST_LOCK);
            return;
        }
        //设置状态为已处理，如果失败会在回滚中置好状态
        orderTaskDao.updatePastStatus(orderTask.getId(), OrderTask.PAST_DUE_YET, OrderTask.PAST_LOCK);
        consumeDao.addConsumeDetail(consumeDetail);
        consumeDao.insertOrUpdateJdConsume(consumeDetail);
        if (throwRuntimeExceptionInTransation) {
            throw new RuntimeException("rollBack in Test");
        }

    }

}

 

（3）编码式事务

有时不能使用声明时事务，比如分库分表。声明式的库是固定的。

package com.jd.consume.service.consume.impl;

import java.util.HashSet;
import java.util.Set;

import javax.annotation.Resource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.util.CollectionUtils;

import com.jd.consume.dao.moredb.DbManager;
import com.jd.consume.dao.mysql.ConsumeDaoMysql;
import com.jd.consume.dao.mysql.ConsumeDetailDaoMysql;
import com.jd.consume.dao.mysql.OrderTaskDaoMysql;
import com.jd.consume.domain.ConsumeDetail;
import com.jd.consume.domain.JdConsume;
import com.jd.consume.domain.OrderTask;
import com.jd.consume.service.consume.CalJdconsume;
import com.jd.consume.service.consume.ConsumeChange;
import com.jd.consume.util.LogUtil;
import com.jd.consume.util.PropertyUtil;

/**
 * 消费额度变更服务
 * @author guanpanpan
 *
 */
@Service(value = "consumeChange")
//@Transactional(value = "transactionManager", readOnly = true)
public class ConsumeChangeImpl implements ConsumeChange {
    protected final static Logger log = LoggerFactory.getLogger(ConsumeChangeImpl.class);
    @Resource
    private OrderTaskDaoMysql orderTaskDaoMysql;
    @Resource
    private ConsumeDaoMysql consumeDaoMysql;
    @Resource
    private ConsumeDetailDaoMysql consumeDetailDaoMysql;
    @Resource
    private DbManager dbManager;
    @Resource(name = "calJdconsumeFind")
    private CalJdconsume calJdconsumeFind;
    @Resource(name = "calJdconsumeCal")
    private CalJdconsume calJdconsumeCal;
    private boolean calJdconsumeByFind = PropertyUtil.getBooleanParameter("calJdconsumeByFind");//默认用数据库计算，减少传输
    public static boolean throwRuntimeExceptionInTransation = false;
    public static ThreadLocal<Set<String>> reDianPin = new ThreadLocal<Set<String>>();//热点数据
    public static ThreadLocal<Long> reDianLastTime = new ThreadLocal<Long>();//热点数据
    public static boolean isReDianFlag = true;
    public static int reDianExePerTime = 5;//分钟，每几分钟执行一下热点
    public static int reDianMomeryMax = 100;//最多缓存热点数据
    public static boolean isUpGrade = false;//是否需要升级，新版本升级程序上线后就不需要再升级了

    //@Transactional(value = "transactionManager", readOnly = false, rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void addConsumeWithSingleTask(int dbNo, OrderTask orderTask) {
        //因为分库所以不能用注解
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setReadOnly(false);
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        DataSourceTransactionManager transactionManager = dbManager.getTransactionManager(dbNo);
        TransactionStatus status = transactionManager.getTransaction(def);
        try {
            ConsumeDetail consumeDetail = orderTask.genAddConsumeDetail();
            //防止重复执行,如果存在uuid置状态为11
            ConsumeDetail consumeDetailDb = consumeDetailDaoMysql
                    .findConsumeDetailsByUuid(orderTask.getPin(), consumeDetail.getUuId());
            if (null != consumeDetailDb) {
                orderTaskDaoMysql.updateStatus(dbNo, orderTask.getId(), OrderTask.SYN_REPEAT, OrderTask.SYN_LOCK);
                transactionManager.commit(status);
                return;
            }
            consumeDetailDaoMysql.addConsumeDetail(consumeDetail);
            if (isReDianFlag) {
                JdConsume jdConsume = consumeDaoMysql.getJdConsumeByPin(orderTask.getPin());
                if (null == jdConsume || !jdConsume.isReDian()) {
                    calAndSaveJdConsumeAmounts(orderTask.getPin());//计算消费额度
                    //设置状态为已处理，如果失败会在回滚中置好状态
                    updateAddStatus(dbNo, orderTask);
                } else {
                    //加入热点集合去重
                    Set<String> reDianSet = reDianPin.get();
                    if (reDianSet == null) {
                        reDianSet = new HashSet<String>();
                    }
                    reDianSet.add(orderTask.getPin());
                    reDianPin.set(reDianSet);
                    //设置时间
                    if (reDianLastTime.get() == null) {
                        reDianLastTime.set(System.currentTimeMillis());
                    }
                    //设置状态为已处理，如果失败会在回滚中置好状态
                    orderTaskDaoMysql.updateStatus(dbNo, orderTask.getId(), OrderTask.SYN_REDIAN_ADD, OrderTask.SYN_LOCK);

                }
            } else {
                calAndSaveJdConsumeAmounts(orderTask.getPin());//计算消费额度
                updateAddStatus(dbNo, orderTask);
            }

            if (throwRuntimeExceptionInTransation) {
                throw new RuntimeException("rollBack in Test");
            }
        } catch (Exception e) {
            transactionManager.rollback(status);
            throw new RuntimeException(e);
        }
        transactionManager.commit(status);
    }

    private void updateAddStatus(int dbNo, OrderTask orderTask) {
        if (isUpGrade) {
            orderTaskDaoMysql.updateStatus(dbNo, orderTask.getId(), OrderTask.SYN_COMPLETE, OrderTask.SYN_LOCK);
        } else {
            orderTaskDaoMysql.updateStatusNoGrade(dbNo, orderTask.getId(), OrderTask.SYN_COMPLETE, OrderTask.SYN_LOCK);
        }

    }

    private void updateAddStatusRedian(int dbNo, String pin) {
        if (isUpGrade) {
            orderTaskDaoMysql.updateStatus(dbNo, pin, OrderTask.SYN_COMPLETE, OrderTask.SYN_REDIAN_ADD);
        } else {
            orderTaskDaoMysql.updateStatusNoGrade(dbNo, pin, OrderTask.SYN_COMPLETE, OrderTask.SYN_REDIAN_ADD);
        }

    }

    @Override
    public void dealRedianDatas(int dbNo, int threadId) {
        Set<String> reDianSet = reDianPin.get();
        if (CollectionUtils.isEmpty(reDianSet)) {
            return;
        }

        //5分钟执行一次
        boolean isTime = (System.currentTimeMillis() - reDianLastTime.get()) > 1000 * 60 * reDianExePerTime;
        if (isTime || reDianSet.size() > reDianMomeryMax) {
            for (String pin : reDianSet) {
                calAndSaveJdConsumeAmounts(pin);//计算消费额度
                updateAddStatusRedian(dbNo, pin);
            }
            //重置时间
            reDianLastTime.set(System.currentTimeMillis());
            //重置集合
            reDianPin.set(new HashSet<String>());
            LogUtil.error(LogUtil.ADDCONSUME, "reDian:" + isTime + reDianSet);
            LogUtil.error(LogUtil.DT, "reDian:" + isTime + "-" + dbNo + "-" + threadId + reDianSet);
        }
    }

    @Override
    public void calAndSaveJdConsumeAmounts(String pin) {
        JdConsume jdConsume = calJdconsume(pin);
        consumeDaoMysql.insertOrUpdateJdConsume(jdConsume);
    }

    @Override
    public JdConsume calJdconsume(String pin) {
        if (calJdconsumeByFind) {
            return calJdconsumeFind.calJdconsume(pin);
        } else {
            return calJdconsumeCal.calJdconsume(pin);
        }

    }

}

注：1,2代码来源于consume-grade-sql，3来源于consume-grade-final(mysql版本)