Spring事务
登录
标签搜索
侧边栏壁纸
博主昵称
limei

  • 累计撰写 21 篇文章
  • 累计收到 390 条评论
Spring

Spring事务

limei
limei
2023-09-26 / 1 评论 / 27 阅读 / 正在检测是否收录...

1.事物的介绍

1.1 什么是事务？

事务指数据库中多个操作合并在一起形成的操作序列

1.2事务的作用

1.当数据库操作序列中个别操作失败时，提供一种方式使数据库状态恢复到正常状态（A），保障数据库即使在异常状态下仍能保持数据一致性（C）（要么操作前状态，要么操作后状态）。

2.当出现并发访问数据库时，在多个访问间进行相互隔离，防止并发访问操作结果互相干扰（I）。

  • 事务特征（ACID）

    • 原子性（Atomicity）指事务是一个不可分割的整体，其中的操作要么全执行或全不执行
    • 一致性（Consistency）事务前后数据的完整性必须保持一致
    • 隔离性（Isolation）事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离
    • 持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

1.3事务的隔离级

  • 脏读：允许读取未提交的信息

    • 原因：Read uncommitted
      -解决方案： （表级读锁）

  • 不可重复读：读取过程中单个数据发生了变化

    • 解决方案： Repeatable read （行级写锁）

  • 幻读：读取过程中数据条目发生了变化

    • 解决方案： Serializable（表级写锁）

2.事物管理

2.1Spring事务核心对象

  • J2EE开发使用分层设计的思想进行，对于简单的业务层转调数据层的单一操作，事务开启在业务层或者数据层并无太大差别，当业务中包含多个数据层的调用时，需要在业务层开启事务，对数据层中多个操作进行组合并归属于同一个事务进行处理

  • Spring为业务层提供了整套的事务解决方案

    • PlatformTransactionManager
    • TransactionDefinition
    • TransactionStatus

2.2 PlatformTransactionManager

  • 平台事务管理器实现类

    • DataSourceTransactionManager 适用于Spring JDBC或MyBatis
    • HibernateTransactionManager 适用于Hibernate3.0及以上版本
    • JpaTransactionManager 适用于JPA
    • JdoTransactionManager 适用于JDO
    • JtaTransactionManager 适用于JTA
  • JPA（Java Persistence API）Java EE 标准之一，为POJO提供持久化标准规范，并规范了持久化开发的统一API，符合JPA规范的开发可以在不同的JPA框架下运行
  • JDO(Java Data Object )是Java对象持久化规范，用于存取某种数据库中的对象，并提供标准化API。与JDBC相比，JDBC仅针对关系数据库进行操作，JDO可以扩展到关系数据库、文件、XML、对象数据库（ODBMS）等，可移植性更强
  • JTA（Java Transaction API）Java EE 标准之一，允许应用程序执行分布式事务处理。与JDBC相比，JDBC事务则被限定在一个单一的数据库连接，而一个JTA事务可以有多个参与者，比如JDBC连接、JDO 都可以参与到一个JTA事务中

此接口定义了事务的基本操作

  • 获取事务 ：

    TransactionStatus getTransaction(TransactionDefinition definition)

  • 提交事务 ：

    void commit(TransactionStatus status)

  • 回滚事务 ：

    void rollback(TransactionStatus status)

2.3 TransactionDefinition

此接口定义了事务的基本信息

  • 获取事务定义名称

    String getName()

  • 获取事务的读写属性

    boolean isReadOnly()

  • 获取事务隔离级别

    int getIsolationLevel()

  • 获事务超时时间

    int getTimeout()

  • 获取事务传播行为特征

    int getPropagationBehavior()

2.4 TransactionStatus

此接口定义了事务在执行过程中某个时间点上的状态信息及对应的状态操作

3.事务控制案例(编程式)

首先 需要下载需要的sql：sql下载

案例目录结构


银行转账业务说明:
银行转账操作中，涉及从A账户到B账户的资金转移操作。数据层仅提供单条数据的基础操作，未设计多账户间的业务操作。

实体类和jdbc的编写

package com.limei.domain;
import java.io.Serializable;
public class Account implements Serializable {

    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/lianxi
jdbc.username=root
jdbc.password=123456

dao层和AccountDao.xml编写

package com.limei.dao;

import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface AccountDao {
    /**
     * 入账操作
     * @param name      入账用户名
     * @param money     入账金额
     */
    void inMoney(@Param("name") String name, @Param("money") Double money);

    /**
     * 出账操作
     * @param name      出账用户名
     * @param money     出账金额
     */
    void outMoney(@Param("name") String name, @Param("money") Double money);

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.limei.dao.AccountDao">

    <update id="inMoney">
        update account set money = money + #{money} where name = #{name}
    </update>

    <update id="outMoney">
        update account set money = money - #{money} where name = #{name}
    </update>

</mapper>

service层编写

package com.limei.service;

import java.util.List;

public interface AccountService {

    /**
     * 转账操作
     * @param outName     出账用户名
     * @param inName      入账用户名
     * @param money       转账金额
     */
    public void transfer(String outName, String inName, Double money);

}

package com.limei.service.impl;


import com.limei.dao.AccountDao;
import com.limei.domain.Account;
import com.limei.service.AccountService;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.sql.DataSource;

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }


    public void transfer(String outName, String inName, Double money) {
        //开启事务
        PlatformTransactionManager ptm = new DataSourceTransactionManager (dataSource);
        //事务定义
        TransactionDefinition td = new DefaultTransactionDefinition ();
        //事务状态
        TransactionStatus ts = ptm.getTransaction(td);

        accountDao.inMoney(outName,money);
        int i = 1/0;
        accountDao.outMoney(inName,money);

        //提交事务
        ptm.commit(ts);
    }

}

aop的编写

import com.limei.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext ("applicationContext.xml");
        AccountService accountService = (AccountService) ctx.getBean("accountService");
        accountService.transfer("李四","张三",100D);
    }
}

applicationContext.xml编写

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

    <context:property-placeholder location="classpath:*.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <bean id="accountService" class="com.limei.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.limei.domain"/>
    </bean>

    <bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.limei.dao"/>

    </bean>
</beans>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.limei.aop</groupId>
    <artifactId>Spring_aop</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

    </dependencies>
</project>

4.aop改造事务(编程式)

使用AOP控制事务

将业务层的事务处理功能抽取出来制作成AOP通知，利用环绕通知运行期动态织入。在limei下创建aop,然后在aop下创建TxAdvice类。

package com.limei.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.sql.DataSource;
public class TxAdvice {
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Object transactionManager(ProceedingJoinPoint pjp) throws Throwable {
        //开启事务
        PlatformTransactionManager ptm = new DataSourceTransactionManager(dataSource);
        //事务定义
        TransactionDefinition td = new DefaultTransactionDefinition();
        //事务状态
        TransactionStatus ts = ptm.getTransaction(td);

        Object ret = pjp.proceed(pjp.getArgs());

        //提交事务
        ptm.commit(ts);
        return ret;
    }

}

}

配置AOP通知类，并注入dataSource。

<bean id="txAdvice" class="com.itheima.aop.TxAdvice">
    <property name="dataSource" ref="dataSource"/>
</bean>

使用环绕通知将通知类织入到原始业务对象执行过程中

<aop:config>
    <aop:pointcut id="pt" expression="execution(* *..transfer(..))"/>
    <aop:aspect ref="txAdvice">
        <aop:around method="tx" pointcut-ref="pt"/>
    </aop:aspect>
</aop:config>

5.声明式事务(XML格式)

在事务控制案例中的 applicationContext.xml中增加以下配置：

<!--开启事务-->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--使用tx命名空间配置事务专属通知类-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*" read-only="false" />
            <tx:method name="get*" read-only="true" />
            <tx:method name="find*" read-only="true" />
        </tx:attributes>
    </tx:advice>


    <!--使用aop:advisor在AOP配置中引用事务专属通知类-->
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* com.limei.service.*Service.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>

aop:advice与aop:advisor区别

  • aop:advice配置的通知类可以是普通java对象，不实现接口，也不使用继承关系

  • aop:advisor配置的通知类必须实现通知接口

    • MethodBeforeAdvice
    • AfterReturningAdvice
    • ThrowsAdvice

6.tx-method的详解和传播行为

tx配置----tx:method

事务的传播行为

7.声明式事务改造(注解)

可以在上述AccountService接口中 添加事务，替换applicationContext.xml 中的事务

@Transactional

  • 名称：@Transactional
  • 类型：方法注解，类注解，接口注解
  • 位置：方法定义上方，类定义上方，接口定义上方
  • 作用：设置当前类/接口中所有方法或具体方法开启事务，并指定相关事务属性

  • 范例：

    @Transactional(
    readOnly = false,
    timeout = -1,
    isolation = Isolation.DEFAULT,
    rollbackFor = {ArithmeticException.class, IOException.class},
    noRollbackFor = {},
    propagation = Propagation.REQUIRES_NEW
)

tx:annotation-driven

在applicationContext.xml中添加下面这段代码

  • 名称：tx:annotation-driven
  • 类型：标签
  • 归属：beans标签
  • 作用：开启事务注解驱动，并指定对应的事务管理器

  • 范例：

    <tx:annotation-driven transaction-manager="txManager"/>
0
暂无标签
版权属于： limei
本文链接： https://ggxiaolin.eu.org/index.php/archives/29/
作品采用： 《 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 》许可协议授权

评论 (1)

取消
  1. 头像
    这个人
    Windows 10 · Google Chrome

    |´・ω・)ノ

    回复