Spring——事务管理

事务

（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败
（2）典型场景：银行转账

事务四个特性（ACID

原子性（atomicity） 一个事务是一个不可分割的工作单位，事务中包括的操作要么都做，要么都不做。
一致性（consistency） 事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
隔离性（isolation） 一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（durability） 持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

环境搭建

模拟银行转账

数据库表

Dao层

public interface AccountDao {

    /**
     * 增加金额
     * @param username 转账人
     * @param money 金额
     */
    void addMoney(String username, BigDecimal money);

    /**
     * 减少金额
     * @param username 收账人
     * @param money 金额
     */
    void reduceMoney(String username, BigDecimal money);
}

@Repository
public class AccountDaoImpl implements AccountDao {

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Override
    public void addMoney(String username, BigDecimal money) {
        String sql = "update t_account set money=money+? where username=?";
        jdbcTemplate.update(sql, money, username);
    }

    @Override
    public void reduceMoney(String username, BigDecimal money) {
        String sql = "update t_account set money=money-? where username=?";
        jdbcTemplate.update(sql, money, username);
    }
}

service层

@Service
public class AccountService {

    @Autowired
    AccountDao accountDao;

    /**
     * 转账
     * @param fromName 转账人
     * @param toName 收账人
     * @param money 金额
     */
    public void transfer(String fromName, String toName, BigDecimal money){

        accountDao.reduceMoney(fromName, money);
        accountDao.addMoney(toName, money);

    }

}

配置文件

数据库配置

jdbc.username=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/wcy
jdbc.driver=com.mysql.cj.jdbc.Driver

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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <context:component-scan base-package="com.wcy"/>

    <!--配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--引用外部配置文件 配置数据源-->
    <context:property-placeholder location="classpath:db.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
    </bean>

    <!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>


</beans>

测试

@Test
public void transfer() {
	ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
	AccountService accountService = context.getBean("accountService", AccountService.class);
	accountService.transfer("wcy", "wp", new BigDecimal(100));
}

在不发生异常的情况下，执行转账的方法没有问题
但是如果在转账图中发生了异常，就会造成不对应的情况，所以需要用到事务管理

Spring事务管理

事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）

Spring 进行事务管理操作有两种方式：编程式事务管理和声明式事务管理（使用）

声明式事务管理
（1）基于注解方式（使用）
（2）基于 xml 配置文件方式

Spring 进行声明式事务管理，底层使用 AOP 原理

Spring 事务管理 API
提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

基于注解的事务管理

在配置文件中配置事务管理器，并开启注解事务管理

需要导入tx名称空间

<!--开启基于注解的事务管理-->
<tx:annotation-driven transaction-manager="transactionManager"/>

<!--配置事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"/>
</bean>

在service层添加注解

@Service
@Transactional
public class AccountService {
}

@Transactional 可以添加到类上面，也可以添加方法上面
如果把这个注解添加类上面，这个类里面所有的方法都添加事务
如果把这个注解添加方法上面，为这个方法添加事务

这样就完成了基本的事务管理

事务的操作

在@Transactional中可以配置许多的参数

// 事务的传播行为
Propagation propagation() default Propagation.REQUIRED;

// 事务的隔离级别
Isolation isolation() default Isolation.DEFAULT;

// 超时时间
int timeout() default -1;

//是否只读
boolean readOnly() default false;

// 回滚配置
Class<? extends Throwable>[] rollbackFor() default {};

// 回滚配置
String[] rollbackForClassName() default {};

// 不回滚
Class<? extends Throwable>[] noRollbackFor() default {};

// 不回滚
String[] noRollbackForClassName() default {};

propagation

作用：配置事务的传播特性

实际就是多事务方法直接进行调用，在这个过程中事务是如何进行管理的
spring中定义了7种传播行为

ioslation

作用：配置事务隔离级别

事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题

有三个读问题：脏读、不可重复读、虚（幻）读

脏读：即为事务1第二次读取时，读到了事务2未提交的数据。若事务2回滚，则事务1第二次读取时，读到了脏数据。
举例：学生表中张三的成绩是59，事务一修改了学生表张三的成绩69，但是事务还没有提交，这个时候事务二来读取张三的成绩，读到了69，但是事务一出问题回滚了，数据库学生表中张三还是59，明显事务二读的数据不对，“脏读”了。
不可重复读：事务一第二次查询某条数据时，读到了事务二提交的修改的该数据
举例：事务一第一次读取张三的成绩是59（事务没结束），这个时候，事务二改了张三的成绩为69并且commit，这时候事务一又去读取张三的成绩，哎？变成69了，就是重复读数据不一致，不可重复读。
事务2在事务1第二次读取时，提交了数据。导致事务1前后两次读取的数据量不一致
举例：事务一读取学生表总共有45人（事务没结束），这个时候事务二突然插入一条学生数据，事务一再次读取总数，发现变成了46条数据，就是两次读取的数据数量不一致。

通过配置ioslation来解决

timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是 -1 ，设置时间以秒单位进行计算

readOnly：是否只读

（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

rollbackFor：回滚

（1）设置出现哪些异常进行事务回滚，通过Class对象来设置

noRollbackFor：不回滚

（1）设置出现哪些异常不进行事务回滚，通过Class对象来设置

rollbackForClassName

（1）设置出现哪些异常进行事务回滚，通过类名来设置

纯注解方式的事务管理

使用配置类来替代配置文件

@Configuration
@ComponentScan(basePackages = {"com.wcy"})
@EnableTransactionManagement  //开启事务管理
public class TransactionConfig {

    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        dataSource.setUrl("jdbc:mysql://localhost:3306/wcy");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        return dataSource;
    }

    /**
     * 配置jdbcTemplate 和配置文件中的bean标签作用一样
     * DataSource参数通过byType的方式自动注入 也可以使用byName
     * Autowired可以写可以不写
     */
    @Bean
    public JdbcTemplate jdbcTemplate(@Autowired DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    @Bean
    public TransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

}

@EnableTransactionManagement的作用和<tx:annotation-driven transaction-manager="transactionManager"/>的作用一样
@Bean和bean标签的作用一样

添加@Transactional注解

@Service
@Transactional(
        propagation = Propagation.REQUIRED,
        rollbackFor = {Exception.class}
)
public class AccountService {
}

基于xml配置的事务管理

不需要开启注解事务，使用aop来切入

<!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务通知-->
    <tx:advice transaction-manager="transactionManager" id="transactionAdvice">
        <tx:attributes>
            <!--配置那些方法需要添加事务 可以使用通配符*来配置-->
            <!--可以配置事务的参数 和注解中的一样-->
            <tx:method name="transfer" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--aop事务切入-->
    <aop:config>
        <aop:pointcut id="point" expression="execution(* com.wcy.service.AccountService.*(..))"/>
        <aop:advisor advice-ref="transactionAdvice" pointcut-ref="point"/>
    </aop:config>

Service中不需要@Transactionl注解

事务的基本配置~

posted @ 2021-12-10 11:28 茶音白阅读(92) 评论(0) 收藏举报

刷新页面返回顶部

茶音白