spring-12.事务

最新推荐文章于 2024-03-27 18:04:13 发布

水下鱼

最新推荐文章于 2024-03-27 18:04:13 发布

阅读量157

点赞数

分类专栏： spring 文章标签： spring

本文链接：https://blog.csdn.net/u012748059/article/details/108596034

版权

spring 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1.处理事务，需要怎么做，做什么

spring处理事务的模型，使用的步骤都是固定的，把事务使用的信息提供给spring就可以了
1.事务内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback。事务管理器是一个接口和他的众多实现类。
接口：PlatformTransactionManager，定义了事务重要方法commit，rollback
实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了

mybatis访问数据库—spring创建的是DataSourceTransactionManager
hibernate访问数据库—spring创建的是HibernateTransactionManager

怎么使用：需要告诉spring你用的是哪种数据库的访问技术，怎么告诉spring呢？声明数据库访问技术的事务管理器实现类，在spring的配置文件中使用bean声明就可以了

2.业务方法需要什么样的事务？
1）事务的隔离级别，有4个值
DEFAULT:采用DB默认的事务隔离级别，MySQL的默认为REPEATABLE_READ;Oracle默认为READ_COMMITTED

READ_UNCOMMITTED：读未提交，未解决任何并发问题
READ_COMMITTED：读已提交，解决脏读，存在不可重复读与幻读
REPEATABLE_READ：可重复读，解决脏读，不可重复读，存在幻读
SERIALIZABLE：串行化，不存在并发问题
2）事务的超时时间：表示一个方法的最长的执行时间，如果方法执行超过了时间，事务就回滚，单位是秒，整数值，默认值是-1
3）事务的传播行为：控制业务方法是不是有事务的，是什么样的事务的，7个传播行为，表示你的业务方法调用时，事务在方法之间是如何使用的。
PROPAGATION_REQUIRED
指定的方法必须在事务内执行，若当前存在事务，就加入到当前事务中，若当前没有事务，则创建一个新事务
PROPAGATION_SUPPORT
指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行
PROPAGATION_REQUIRES_NEW
总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事物执行完毕

3.spring提交事务回滚事务的时机
1）当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务
2）当你的业务方法抛出运行时异常，spring执行回滚，调用事务管理器的rollback
运行时异常的定义：RuntimeException和他的子类都是运行时异常，例如NullPointException、NumberFormatException
3）当你的业务方法抛出非运行时异常，主要是受查异常时，提交事务
受查异常：在你写代码中，必须处理的异常。例如IOException，SQLException

3.总结spring的事务
1.管理事务的是事务管理器和他的实现类
2.指定哪些类哪些方法需要加入事务的功能
3.指定方法需要的隔离级别，传播行为，超时

2.无事务实例

创建实体类

public class Goods {
    private Integer id;
    private String name;
    private Integer amount;
    private Float price;

    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 Integer getAmount() {
        return amount;
    }

    public void setAmount(Integer amount) {
        this.amount = amount;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }
}

public class Sale {
    private Integer id;
    private Integer gid;
    private Integer nums;

    public Integer getId() {
        return id;
    }

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

    public Integer getGid() {
        return gid;
    }

    public void setGid(Integer gid) {
        this.gid = gid;
    }

    public Integer getNums() {
        return nums;
    }

    public void setNums(Integer nums) {
        this.nums = nums;
    }
}

public interface GoodsDao {
    int updateGoods(Goods goods);
    Goods selectGoods(Integer id);
}

<?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.chongqing.dao.GoodsDao">

    <select id="selectGoods" resultType="com.chongqing.domain.Goods">
        select id,name,amount,price from goods where id=#{gid}
    </select>

    <update id="updateGoods">
        update goods set amount=amount-#{amount} where id=#{id}
    </update>

</mapper>

public interface SaleDao {
    int insertSale(Sale sale);
}

<?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.chongqing.dao.SaleDao">
    <insert id="insertSale">
        insert into sale(gid,nums) values (#{gid},#{nums})
    </insert>
</mapper>

3.异常类

//自定义的运行时异常
public class NotEnoughException extends RuntimeException{
    public NotEnoughException() {
        super();
    }

    public NotEnoughException(String message) {
        super(message);
    }
}

4.service类

public interface BuyGoodsService {
    void buy(Integer goodsId,Integer nums);
}

实现类

public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    @Override
    public void buy(Integer goodsId, Integer nums) {
        //记录销售信息，向sale表添加记录
        Sale sale=new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);


        //更新库存
        Goods goods=goodsDao.selectGoods(goodsId);
        if(goods==null){
            //商品不存在
            throw new NullPointerException(goodsId+"商品不存在");
        }else if (goods.getAmount()<nums){
            throw new NotEnoughException("编号是："+goodsId+"数量不够");
        }
        //修改库存
        Goods buyGoods=new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);
    }

5.配置文件

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

    <context:property-placeholder location="classpath:jdbc.properties"/>
<!--声明数据源DataSource，作用是连接数据库的    -->

    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
           init-method="init" destroy-method="close">

<!--        set注入给DruidDataSource提供连接数据库信息-->

<!--
    <property name="url" value="${jdbc:mysql://localhost:3306/springdb?useUnicode=true&amp;characterEncoding=utf8}"/>
-->

        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.passwd}"/>
        <property name="maxActive" value="${jdbc.max}"/>
    </bean>

<!--    声明的是mybatis中提供的SqlSessionFactoryBean类，这个类是内部创建SqlSessionFactory的-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--        set注入，把数据库连接池付给了dataSource属性-->
        <property name="dataSource" ref="myDataSource"/>

<!--        mybatis主配置文件的位置-->
<!--        configLocation属性是Resource类型，读取配置文件
            它的赋值，使用value，指定文件的路径，使用classpath：表示文件的位置
-->
        <property name="configLocation" value="classpath:mybatis.xml"/>
<!--        <property name="mapperLocations" value="classpath:mapper/*Dao.xml"/>-->
    </bean>


<!--    创建dao对象，使用SqlSession的getMapper(StudentDao.class)
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

<!--        指定sqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>

<!--        指定包名，包名是dao接口所在的包名
            MapperScannerConfigurer 会扫描这个包中的所有接口，
            把每个接口都执行一次getMapper()方法，得到每个接口的dao对象
            创建好的dao对象放入到spring的容器中的
            -->
        <property name="basePackage" value="com.chongqing.dao"/>

    </bean>


<!--    声明service-->
    <bean id="buyGoodsService" class="com.chongqing.service.BuyGoodsServiceImpl">
        <property name="saleDao" ref="saleDao"/>
        <property name="goodsDao" ref="goodsDao"/>

    </bean>
</beans>

6.测试类

@Test
    public void test()
    {
        String config="applicationContext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        BuyGoodsService service=(BuyGoodsService)ctx.getBean("buyGoodsService");

        service.buy(1001,200);
    }

3. 事务的实现

spring框架中提供的事务处理方案
1.适合中小项目使用的，注解方案
spring框架自己用AOP实现给业务方法增加事务的功能，使用@Transactional注解增加事务

@Transactional注解是spring框架自己注解，放在public方法上面，表示当前方法具有事务，可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等

使用@Transactional步骤

1）需要声明事务管理器对象

<bean id="xx" class="DataSourceTransactionManager">

2）开启事务注解驱动，告诉spring框架，我要使用注解的方式管理事务
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能
spring给业务方法加入事务
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知

@Around("你要增加的事务功能的业务方法名称")
Object myAround(){
    开启事务，spring给你开启
    try{
        buy(1001,10);
        spring的事务管理.commit();
    }catch(Exception e){
        spring的事务管理.rollback();
    }
}

3）在你的方法上面加入@Transactional

2.适合大型项目，有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中声明类，方法需要的事务，这种方式业务方法和事务配置完全分离。

实现步骤：都是在xml配置文件中实现
1）要使用的是aspectj框架，需要加入依赖

<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-aspects</artifactId>
    <version>4.3.16.RELEASE</version>
 </dependency>

2）声明事务管理器对象

 <bean id="xx" class="DataSourceTransactionManager">

3）声明方法需要的事务类型（配置方法的事务属性（隔离级别、传播行为、超时））

4）配置aop,指定哪些类要创建代理

4.注解使用事务

在applicationContext.xml中增加

<!--    使用spring的事务处理-->
<!--    1.申明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!--        连接的数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource"/>


    </bean>

<!--    2.开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象-->
<!--    transaction-manager：事务管理器对象的id-->


    <tx:annotation-driven transaction-manager="transactionManager"/>

添加注解


 /**
     *
     rollbackFor:表示发生指定的异常一定回滚
     处理逻辑为：
     1）spring框架会首先去检查方法抛出的异常是不是在
     rollbackFor的列表中，如果在rollback列表中，不管是什么类型的异常，
     一定回滚
     2）如果抛出的异常不在rollbackFor的列表中，spring会判断是不是
     runtimeException，如果是一定回滚

     */

    @Transactional(
          propagation = Propagation.REQUIRED,
           isolation = Isolation.DEFAULT,
           readOnly = false,
           rollbackFor = {
                   NullPointerException.class,NotEnoughException.class
            }
    )

5.aspectj使用事务

1.加入依赖

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

2.配置文件

<!--    声明式事务处理:和源代码完全分离的-->
<!--    1.声明事务管理器对象-->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>

    </bean>

<!--    2.声明业务方法他的事务属性（隔离级别，传播行为，超时时间）-->

    <tx:advice id="myAdvice" transaction-manager="transactionManager">

<!--        tx:attributes:配置事务属性-->

        <tx:attributes>
<!--      tx:method:给具体的方法配置事务属性，method可以有多个，分别
          给不同的方法设置事务属性

          name:方法名称 1）完整的方法名称，不带有包和类
                        2）方法可以使用通配符，*表示任意字符

         propagation：传播行为，枚举值
         isolation：隔离级别
         rollback-for：你指定的异常类名，全限定类名，发生异常一定回滚
            -->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException.class,com.chongqing.exception.NotEnoughException"/>
        </tx:attributes>
    </tx:advice>

<!--    配置aop-->
    <aop:config>

<!--        配置切入点表达式：指定哪些包中类，要使用事务
            id:切入点表达式的名称，唯一值
            expression：切入点表达式，指定哪些类要使用事务
            aspectj 会创建代理对象

-->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

<!--        配置增强器：关联advise和pointcut
            advice-ref 通知，类的配置
            pointcut-ref 切入点表达式的id

            -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>

水下鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring-12.事务

1.处理事务，需要怎么做，做什么spring处理事务的模型，使用的步骤都是固定的，把事务使用的信息提供给spring就可以了1.事务内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback。事务管理器是一个接口和他的众多实现类。接口：PlatformTransactionManager，定义了事务重要方法commit，rollback实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了mybatis访问数据库—spring创建的是DataSourceTr
复制链接

扫一扫