java spring 事物 ( 已转账为例 ) 基于 xml 配置，事务类型说明

Z时代
2024-01-10
分类：综合

本文内容纲要：java spring 事物 ( 已转账为例 ) 基于 xml 配置，事务类型说明

< 1 > 配置文件

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-4.0.xsd"
>
    <!-- 配置 C3P0 连接池数据源, 作为 DAO 层的数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl">
            <value>jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8</value>
        </property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="user" value="root"></property>
        <property name="password" value="920619"></property>
    </bean>
    <!-- 配置 DAO 层, 把 C3P0 连接池作为数据源注入到 DAO 层 -->
    <bean id="accountDao" class="spring.things.AccountDao">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置 SERVICE 层, 把 DAO 层注入到 SERVICE 层 -->
    <bean id="accountService" class="spring.things.AccountService">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!-- 配置事物管理类 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置业务层的代理 -->
    <bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
        <!-- 注入被代理对象 -->
        <property name="target" ref="accountService"></property>
        <!-- 注入事物管理类 -->
        <property name="transactionManager" ref="transactionManager"></property>
        <!-- 注入事物属性 -->
        <property name="transactionAttributes">
            <props>
                <!-- 被代理对象的方法名格式 可用通配符 *, 如 A* 标识以 A 开头的所有类 -->
                <!-- 
                    PROPAGATION: 事物的传播行为
                    ISOLATION:   事物的隔离级别
                    readOnly:    只读
                    -Exception:  发生哪些异常回滚事物
                    +Exception:  发生哪些异常不会滚事物  
                -->
                <prop key="transfer">PROPAGATION_REQUIRES_NEW</prop>
            </props>
        </property>
    </bean>
</beans>

事务传播行为类型 : PROPAGATION	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务；如果已经存在一个事务，加入到这个事务中。（这个是最常见的选择）
PROPAGATION_SUPPORTS	支持当前事务。如果当前没有事务，就以非事务方式执行
PROPAGATION_MANDATORY	使用当前的事务。如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW	新建事务。如果当前存在事务，就把当前事务挂起
PROPAGATION_NOT_SUPPORTED	以非事务的方式执行操作。如果当前存在事务，就把当前事务挂起
PROPAGATION_NEVER	以非事务方式执行。如果当前存在事务，则抛出异常
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作

隔离级别 : ISOLATION	脏读	不可重复读	幻象读	第一类丢失更新	第二类丢失更新
ISOLATION_READ_UNCOMMITED	允许	允许	允许	不允许	允许
ISOLATION_READ_COMMITED	不允许	允许	允许	不允许	允许
ISOLATION_REPEATABLE_READ	不允许	不允许	允许	不允许	不允许
ISOLATION_SERIALIZABLE	不允许	不允许	不允许	不允许	不允许

< 二 > DAO 和 SERVICE 层接口

package spring.things;
public interface IAccountDao {
    /**
     * 转出钱的方法
     * @param outName : 转出人
     * @param money   : 金额
     */
    public void outMoney(String outName, double money);
    /**
     * 收钱的方法
     * @param inName : 收钱人
     * @param money  : 金额
     */
    public void inMoney(String inName, double money);
}
package spring.things;
public interface IAccountService {
    /**
     * 转账的方法
     * @param outUser: 出账人
     * @param inUser : 收账人
     * @param money  : 金额
     */
    public void transfer(String outUser, String inUser, double money);
}

< 三 > 接口的实现类

package spring.things;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
public class AccountDao extends JdbcDaoSupport implements IAccountDao {
    @Override
    public void outMoney(String outName, double money) {
        String sql = "update User set money = money - ? where UserName = ?";
        this.getJdbcTemplate().update(sql, money, outName);
    }
    @Override
    public void inMoney(String inName, double money) {
        String sql = "update User set money = money + ? where UserName = ?";
        this.getJdbcTemplate().update(sql, money, inName);
    }
}
package spring.things;
public class AccountService implements IAccountService {
    // 注入的 Dao 层
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    // 这个方法在测试中是一个事物单元
    @Override
    public void transfer(String outName, String inName, double money) {
        accountDao.outMoney(outName, money);
        accountDao.inMoney(inName, money);
    }
}

< 四 > 测试类

package spring.things;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)  // 注入 JUNIT 的字节码
@ContextConfiguration("classpath:spring/things/Things.xml") // 注入 SPORING 配置文件
public class ATest_01 {
    // 注入代理类, 注意, 被代理实现类的接收接口 而不是 实现类
    @Resource(name = "accountServiceProxy")
    private IAccountService accountService;
    @Test
    public void demo_1(){
        accountService.transfer("张三", "李四", 200);
    }
}