public interface StorageService {
    /**
     * 扣除存储数量
     */
    void deduct(String commodityCode, int count);
}

public interface OrderService {
    /**
     * 创建订单
     */
    Order create(String userId, String commodityCode, int orderCount);
}

public interface AccountService {
    /**
     * 从用户账户中借出
     */
    void debit(String userId, int money);
}

public class BusinessServiceImpl implements BusinessService {
    private StorageService storageService;
    private OrderService orderService;
    /**
     * 采购
     */
  	@GlobalTransactional
    public void purchase(String userId, String commodityCode, int
orderCount) {
        storageService.deduct(commodityCode, orderCount);
        orderService.create(userId, commodityCode, orderCount);
   }
}
public class OrderServiceImpl implements OrderService {
    private OrderDAO orderDAO;
    private AccountService accountService;
    public Order create(String userId, String commodityCode, int
orderCount) {
        int orderMoney = calculate(commodityCode, orderCount);
        accountService.debit(userId, orderMoney);
        Order order = new Order();
        order.userId = userId;
        order.commodityCode = commodityCode;
        order.count = orderCount;
        order.money = orderMoney;
        // INSERT INTO orders ...
        return orderDAO.insert(order);
   }
}

@GlobalTransactional
public void purchase(String userId, String commodityCode, int orderCount) 
{
   ......
}

AccountService {
    /**
     * The constant DB_KEY.
     */
    public static final String DB_KEY = "account";
    @Override
    public void reduce(String userId, int money) throws SQLException {
        String sql = "update account_tbl set money = money - " + money + " 
where user_id = '" + userId + "'";
        DataSourceUtil.executeUpdate(DB_KEY, sql);
   }
    @Override
    public int doNegativeCheck(String field, String id) throws SQLException
{
        String checkSql = "select " + field + " from account_tbl where 
user_id='" + id + "'";
        String result = DataSourceUtil.getSingleResult(DB_KEY, checkSql);
        return Integer.parseInt(result);
   }
  
  // 做恢复测试用的
    @Override
    public void reset(String key, String value) throws SQLException {
        String deleteSql = "delete from account_tbl where user_id = '" +
key + "'";
        String insertSql = "insert into account_tbl(user_id, money) values 
('" + key + "', " + value + ")";
        DataSourceUtil.executeUpdate(DB_KEY, deleteSql);
        DataSourceUtil.executeUpdate(DB_KEY, insertSql);
   }
}

public class OrderServiceImpl implements OrderService {
    /**
     * The constant DB_KEY.
     */
    public static final String DB_KEY = "order";
    private AccountService accountService;
    @Override
    public void setAccountService(AccountService accountService) {
        this.accountService = accountService;
   }
    @Override
    public void create(String userId, String commodityCode, Integer count) 
throws SQLException {
        int money = count * 200;
        String sql = "insert into order_tbl (user_id, commodity_code, 
count, money) values ('" + userId + "','"
            + commodityCode + "'," + count + "," + money + ")";
        //插入订单
        DataSourceUtil.executeUpdate(DB_KEY, sql);
        //减少账户资金
        accountService.reduce(userId, money);
   }
                        // 做恢复测试用的
    @Override
    public void reset(String key, String value) throws SQLException {
        String deleteSql = "delete from order_tbl";
        DataSourceUtil.executeUpdate(DB_KEY, deleteSql);
   }
}

public class StorageServiceImpl extends AbstractDataCheck implements
StorageService {
    /**
     * The constant DB_KEY.
     */
    public static final String DB_KEY = "storage";
     @Override
    public void deduct(String commodityCode, int count) throws SQLException
{
        String sql = "update storage_tbl set count = count - " + count + " 
where commodity_code = '" + commodityCode
            + "'";
        //更新库存
        DataSourceUtil.executeUpdate(DB_KEY, sql);
   }
    // 做恢复测试用的
    @Override
    public void reset(String key, String value) throws SQLException {
        String deleteSql = "delete from storage_tbl where commodity_code = 
'" + key + "'";
        String insertSql = "insert into storage_tbl(commodity_code, count) 
values ('" + key + "', " + value + ")";
        //删除库存商品
        DataSourceUtil.executeUpdate(DB_KEY, deleteSql);
        //重新插入库存商品
        DataSourceUtil.executeUpdate(DB_KEY, insertSql);
   }

    @Override
    public int doNegativeCheck(String field, String id) throws SQLException
{
        String checkSql = "select " + field + " from storage_tbl where 
commodity_code='" + id + "'";
        String result = DataSourceUtil.getSingleResult(DB_KEY, checkSql);
        return Integer.parseInt(result);
   }
}

public interface AccountService extends DataResetService {
    /**
     * Reduce.
     *
     * @param userId the user id
     * @param money the money
     * @throws SQLException the sql exception
     */
    void reduce(String userId, int money) throws SQLException; }

    /**
     * Reset.
     *
     * @param key   the key
     * @param value the value
     * @throws SQLException the sql exception
     */
    void reset(String key, String value) throws SQLException; }

public interface OrderService extends DataResetService {
    /**
     * Sets account service.
     *
     * @param accountService the account service
     */
    void setAccountService(AccountService accountService);
    /**
     * Create.
     *
     * @param userId       the user id
     * @param commodityCode the commodity code
     * @param count         the count
     * @throws SQLException the sql exception
     */
    void create(String userId, String commodityCode, Integer count) throws
SQLException; }

public interface StorageService extends DataResetService {
    /**
     * Deduct.
     *
     * @param commodityCode the commodity code
     * @param count         the count
     * @throws SQLException the sql exception
     */
    void deduct(String commodityCode, int count) throws SQLException; }

public class Bussiness {
    public static void main(String[] args) throws SQLException, 
TransactionException, InterruptedException {
 String userId = "U100001";
        String commodityCode = "C00321";
        int commodityCount = 100;
        int money = 999;
        AccountService accountService = new AccountServiceImpl();
        StorageService storageService = new StorageServiceImpl();
        OrderService orderService = new OrderServiceImpl();
        orderService.setAccountService(accountService);
        //重置数据库记录
        accountService.reset(userId, String.valueOf(money));
        storageService.reset(commodityCode, 
String.valueOf(commodityCount));
        orderService.reset(null, null);
        //init seata; only once
        String applicationId = "api";   //应用名编号
        String txServiceGroup = "my_test_tx_group"; //事务服务组，TC集群
        //初始化事务管理客户端
        TMClient.init(applicationId, txServiceGroup);
        //初始化资源管理客户端 RM 数据库有几个
        RMClient.init(applicationId, txServiceGroup);
        //trx 全局事务
        GlobalTransaction tx =
GlobalTransactionContext.getCurrentOrCreate();
        try {
            tx.begin(60000, "testBiz");
            System.out.println("begin trx, xid is " + tx.getXid());
            //biz operate 3 dataSources
            //set >=5 will be rollback(200*5>999) else will be commit
            int opCount = 5;
            storageService.deduct(commodityCode, opCount);
            orderService.create(userId, commodityCode, opCount);
            //check data if negative
            boolean needCommit =
((StorageServiceImpl)storageService).validNegativeCheck("count", 
commodityCode)
                &&
((AccountServiceImpl)accountService).validNegativeCheck("money", userId);
            //if data negative rollback else commit
            if (needCommit) {
                tx.commit();
           } else {
                System.out.println("rollback trx, cause: data negative, xid 
is " + tx.getXid());
                tx.rollback();
           }
       } catch (Exception exx) { // 框架层次判断，如果异常，全局事务回滚
            System.out.println("rollback trx, cause: " + exx.getMessage() +
" , xid is " + tx.getXid());
            tx.rollback();
            throw exx;
       }
        TimeUnit.SECONDS.sleep(10);
           }
}

public class DataSourceUtil {
    /**
     * The constant JDBC_PRO_PATH.
     */
    public static final String JDBC_PRO_PATH = "jdbc.properties";
    /**
     * The constant DATA_SOURCE_MAP.
     		JDBC标准，数据源映射表
     */
    public static final ConcurrentMap<String, DataSource> DATA_SOURCE_MAP
= new ConcurrentHashMap<>();
    /**
     * Gets data source.
     *
     * @param name the name
     * @return the data source
     */
    public static DataSource getDataSource(String name) {
        String driverKey = "jdbc." + name + ".driver";
        String urlKey = "jdbc." + name + ".url";
        String userNameKey = "jdbc." + name + ".username";
        String pwdKey = "jdbc." + name + ".password";
        DataSource dataSource = new DruidDataSource();
       // 设置
((DruidDataSource)dataSource).setDriverClassName(PropertiesUtil.getPropert
ieValue(JDBC_PRO_PATH, driverKey));
       
((DruidDataSource)dataSource).setUrl(PropertiesUtil.getPropertieValue(JDBC
_PRO_PATH, urlKey));
       
((DruidDataSource)dataSource).setUsername(PropertiesUtil.getPropertieValue
(JDBC_PRO_PATH, userNameKey));
       
((DruidDataSource)dataSource).setPassword(PropertiesUtil.getPropertieValue
(JDBC_PRO_PATH, pwdKey));
      // 拦路抢劫！设计模式：装饰者，代理模式
        return new DataSourceProxy(dataSource);
   }
    /**
     * Gets connection.
     *
     * @param name the name
     * @return the connection
     * @throws SQLException the sql exception
     */
    public static Connection getConnection(String name) throws
SQLException {
        DATA_SOURCE_MAP.putIfAbsent(name, getDataSource(name));
        return DATA_SOURCE_MAP.get(name).getConnection();
   }
    /**
     * Execute update int.
     *
     * @param name the name
     * @param sql the sql
     * @return the int
     * @throws SQLException the sql exception
     */
    public static int executeUpdate(String name, String sql) throws
SQLException {
        Connection connection = null;
        Statement statement = null;
        int result = 0;
        try {
            connection = getConnection(name);
            statement = connection.createStatement();
            result = statement.executeUpdate(sql);
       } catch (SQLException exx) {
            //todo
            throw exx;
       } finally {
            try {
                if (statement != null) {
                    statement.close();
               }
                if (connection != null) {
                    connection.close();
               }
           } catch (SQLException exx) {
           }
       }
        return result;
   }
    /**
     * Gets single result.
     *
     * @param name the name
     * @param sql the sql
     * @return the single result
     * @throws SQLException the sql exception
     */
    public static String getSingleResult(String name, String sql) throws
SQLException {
        Connection connection = null;
        Statement statement = null;
        String result = null;
        try {
            connection = getConnection(name);
            statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);
            resultSet.next();
            result = resultSet.getString(1);
       } catch (SQLException exx) {
            //todo
            throw exx;
       } finally {
       try {
                if (statement != null) {
                    statement.close();
               }
                if (connection != null) {
                    connection.close();
               }
           } catch (SQLException exx) {
           }
       }
        return result;
   }
}

@Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }


@Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

@LocalTCC
public interface TccActionOne {
    /**
     * Prepare boolean.
     * 框架调用，程序员实现
     * @param actionContext the action context
     * @param a             the a
     * @return the boolean
     */
    @TwoPhaseBusinessAction(name = "TccActionOne" , commitMethod =
"commit", rollbackMethod = "rollback")
    public boolean prepare(BusinessActionContext actionContext, int a);
    /**
     * Commit boolean.
     * 框架调用，程序员实现
     * @param actionContext the action context
     * @return the boolean
     */
    public boolean commit(BusinessActionContext actionContext);
    /**
     * Rollback boolean.
     * 框架调用，程序员实现
     * @param actionContext the action context
     * @return the boolean
     */
    public boolean rollback(BusinessActionContext actionContext);
}

@LocalTCC
public interface TccActionTwo {
    /**
     * Prepare boolean.
     *
     * @param actionContext the action context
     * @param b             the b
     * @return the boolean
     */
         @TwoPhaseBusinessAction(name = "TccActionTwo" , commitMethod =
"commit", rollbackMethod = "rollback")
    public boolean prepare(BusinessActionContext actionContext, String b);
    /**
     * Commit boolean.
     *
     * @param actionContext the action context
     * @return the boolean
     */
    public boolean commit(BusinessActionContext actionContext);
    /**
     * Rollback boolean.
     *
     * @param actionContext the action context
     * @return the boolean
     */
    public boolean rollback(BusinessActionContext actionContext);
}

public class TccActionOneImpl implements TccActionOne {
    @Override
    public boolean prepare(BusinessActionContext actionContext, int a) {
        String xid = actionContext.getXid();
        System.out.println("TccActionOne prepare, xid:" + xid);
        return true;
   }
    @Override
    public boolean commit(BusinessActionContext actionContext) {
        String xid = actionContext.getXid();
        System.out.println("TccActionOne commit, xid:" + xid);
        ResultHolder.setActionOneResult(xid, "T");
        return true;
   }
    @Override
    public boolean rollback(BusinessActionContext actionContext) {
        String xid = actionContext.getXid();
        System.out.println("TccActionOne rollback, xid:" + xid);
        ResultHolder.setActionOneResult(xid, "R");
        return true;
   }
}

public class TccActionTwoImpl implements TccActionTwo {
    @Override
    public boolean prepare(BusinessActionContext actionContext, String b) {
        String xid = actionContext.getXid();
        System.out.println("TccActionTwo prepare, xid:" + xid);
        return true;
   }
    @Override
    public boolean commit(BusinessActionContext actionContext) {
        String xid = actionContext.getXid();
        System.out.println("TccActionTwo commit, xid:" + xid);
        ResultHolder.setActionTwoResult(xid, "T");
        return true;
   }
    @Override
    public boolean rollback(BusinessActionContext actionContext) {
        String xid = actionContext.getXid();
        System.out.println("TccActionTwo rollback, xid:" + xid);
        ResultHolder.setActionTwoResult(xid, "R");
        return true;
   }
}

public class ResultHolder {
    private static Map<String, String> actionOneResults = new
ConcurrentHashMap<String, String>();
    private static Map<String, String> actionTwoResults = new
ConcurrentHashMap<String, String>();
    /**
     * Set action one result.
     *
     * @param txId   the tx id
     * @param result the result
     */
    public static void setActionOneResult(String txId, String result){
        actionOneResults.put(txId, result);
   }
    /**
     * Get action one result string.
     *
     * @param txId the tx id
     * @return the string
     */
    public static String getActionOneResult(String txId){
        return actionOneResults.get(txId);
        }
    /**
     * Set action two result.
     *
     * @param txId   the tx id
     * @param result the result
     */
    public static void setActionTwoResult(String txId, String result){
        actionTwoResults.put(txId, result);
   }
    /**
     * Get action two result string.
     *
     * @param txId the tx id
     * @return the string
     */
    public static String getActionTwoResult(String txId){
        return actionTwoResults.get(txId);
   }
}

public class TccTransactionService {
    private TccActionOne tccActionOne;
    private TccActionTwo tccActionTwo;
    /**
     * //发起分布式事务
     *
     * @return string string
     */
    @GlobalTransactional
    public String doTransactionCommit(){
        //第一个TCC 事务参与者
        boolean result = tccActionOne.prepare(null, 1);
        if(!result){
            throw new RuntimeException("TccActionOne failed.");
       }
        result = tccActionTwo.prepare(null, "two");
        if(!result){
            throw new RuntimeException("TccActionTwo failed.");
       }
        return RootContext.getXID();
   }
    /**
     * //Do transaction rollback string.
      *
     * @param map the map
     * @return the string
     */
    @GlobalTransactional
    public String doTransactionRollback(Map map){
        //第一个TCC 事务参与者
        boolean result = tccActionOne.prepare(null, 1);
        if(!result){
            throw new RuntimeException("TccActionOne failed.");
       }
        result = tccActionTwo.prepare(null, "two");
        if(!result){
            throw new RuntimeException("TccActionTwo failed.");
       }
        map.put("xid", RootContext.getXID());
        throw new RuntimeException("transacton rollback");
   }
    /**
     * Sets tcc action one.
     *
     * @param tccActionOne the tcc action one
     */
    public void setTccActionOne(TccActionOne tccActionOne) {
        this.tccActionOne = tccActionOne;
   }
    /**
     * Sets tcc action two.
     *
     * @param tccActionTwo the tcc action two
     */
    public void setTccActionTwo(TccActionTwo tccActionTwo) {
        this.tccActionTwo = tccActionTwo;
   }
}

public class LocalTccTransactionStarter {
    /**
     * The Application context.
     */
    static AbstractApplicationContext applicationContext = null;
    /**
     * The Tcc transaction service.
     */
    static TccTransactionService tccTransactionService = null;
    /**
     * The Tcc action one.
      */
    static TccActionOneImpl tccActionOne = null;
    /**
     * The Tcc action two.
     */
    static TccActionTwoImpl tccActionTwo = null;
    /**
     * The entry point of application.
     *
     * @param args the input arguments
     * @throws InterruptedException the interrupted exception
     */
    public static void main(String[] args) throws InterruptedException {
        applicationContext = new ClassPathXmlApplicationContext(new
String[] {"spring/seata-tcc.xml"});
        tccTransactionService = (TccTransactionService) 
applicationContext.getBean("tccTransactionService"   );
        tccActionOne = (TccActionOneImpl) 
applicationContext.getBean("tccActionOne");
        tccActionTwo = (TccActionTwoImpl) 
applicationContext.getBean("tccActionTwo");
        //分布式事务提交demo
        transactionCommitDemo();
        //分布式事务回滚demo
        transactionRollbackDemo();
        new ApplicationKeeper(applicationContext).keep();
   }
    private static void transactionCommitDemo() throws InterruptedException
{
        String txId = tccTransactionService.doTransactionCommit();
        System.out.println(txId);
        Assert.isTrue(StringUtils.isNotBlank(txId), "事务开启失败");
        Thread.sleep(1000L);
        Assert.isTrue("T".equals(ResultHolder.getActionOneResult(txId)), 
"tccActionOne commit failed");
        Assert.isTrue("T".equals(ResultHolder.getActionTwoResult(txId)), 
"tccActionTwo commit failed");
        System.out.println("transaction commit demo finish.");
   }
    private static void transactionRollbackDemo() throws
InterruptedException {
        Map map = new HashMap(16);
        try{
            tccTransactionService.doTransactionRollback(map);
            Assert.isTrue(false, "分布式事务未回滚");
       }catch (Throwable t) {
        Assert.isTrue(true, "分布式事务异常回滚");
       }
        String txId = (String) map.get("xid");
        Thread.sleep(1000L);
        Assert.isTrue("R".equals(ResultHolder.getActionOneResult(txId)), 
"tccActionOne commit failed");
        Assert.isTrue("R".equals(ResultHolder.getActionTwoResult(txId)), 
"tccActionTwo commit failed");
        System.out.println("transaction rollback demo finish.");
   }
}