spring事务控制4

最新推荐文章于 2024-04-22 23:29:05 发布
最新推荐文章于 2024-04-22 23:29:05 发布
阅读量135 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35426012/article/details/106130415
版权

spring基于xml配置事务

  1. 创建maven工程添加需要的依赖
<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>


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

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

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>

    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.7</version>
    </dependency>
  1. 编写持久层dao和实现类接口 和实体类
package org.example.domain;
//实体类
public class Account {

    private Integer id;
    private String name;
    private Float 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 Float getMoney() {
        return money;
    }

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

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

}


package org.example.dao;

import org.example.domain.Account;
import java.io.Serializable;

public class Account implements Serializable {
    /**
     * 根据Id查询账户
     * @param accountId
     * @return
     */
    Account findAccountById(Integer accountId);

    /**
     * 根据名称查询账户
     * @param accountName
     * @return
     */
    Account findAccountByName(String accountName);

    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);

}


package org.example.dao.impl;

import org.example.dao.IAccountDao;
import org.example.domain.Account;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;

import java.util.List;

public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {

    public Account findAccountById(Integer accountId) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }

    public Account findAccountByName(String accountName) {
        List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }

    public void updateAccount(Account account) {
        super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
    }
}
  1. 编写业务层service和实现类接口
package org.example.service;

import org.example.domain.Account;

public interface IAccountService {
    /**
     * 根据id查询账户信息
     * @param accountId
     * @return
     */
    Account findAccountById(Integer accountId);

    /**
     * 转账
     * @param sourceName    转成账户名称
     * @param targetName    转入账户名称
     * @param money         转账金额
     */
    void transfer(String sourceName,String targetName,Float money);
}


package org.example.service.impl;

import org.example.dao.IAccountDao;
import org.example.domain.Account;
import org.example.service.IAccountService;

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

		//产生异常后测试是否会回滚事务
        int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
    }

}
  1. 在bean.xml中导入约束配置持久层和业务层 配置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:aop="http://www.springframework.org/schema/aop"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置业务层-->
    <bean id="accountService" class="org.example.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置账户的持久层-->
    <bean id="accountDao" class="org.example.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/student"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- spring中基于XML的声明式事务控制配置步骤
       1、配置事务管理器
       2、配置事务的通知
               此时我们需要导入事务的约束 tx名称空间和约束，同时也需要aop的
               使用tx:advice标签配置事务通知
                   属性：
                       id：给事务通知起一个唯一标识
                       transaction-manager：给事务通知提供一个事务管理器引用
       3、配置AOP中的通用切入点表达式
       4、建立事务通知和切入点表达式的对应关系
       5、配置事务的属性
              是在事务的通知tx:advice标签的内部

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


    <!-- 配置事务的通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!-- 配置事务的属性
                isolation：用于指定事务的隔离级别。默认值是DEFAULT，表示使用数据库的默认隔离级别。
                propagation：用于指定事务的传播行为。默认值是REQUIRED，表示一定会有事务，增删改的选择。查询方法可以选择SUPPORTS。
                read-only：用于指定事务是否只读。只有查询方法才能设置为true。默认值是false，表示读写。
                timeout：用于指定事务的超时时间，默认值是-1，表示永不超时。如果指定了数值，以秒为单位。
                rollback-for：用于指定一个异常，当产生该异常时，事务回滚，产生其他异常时，事务不回滚。没有默认值。表示任何异常都回滚。
                no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时事务回滚。没有默认值。表示任何异常都回滚。
        -->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"></tx:method>
        </tx:attributes>
    </tx:advice>

    <!-- 配置aop-->
    <aop:config>
        <!-- 配置切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* org.example.service.impl.*.*(..))"></aop:pointcut>
        <!--建立切入点表达式和事务通知的对应关系 -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>
</beans>
  1. 测试
package org.example;

import static org.junit.Assert.assertTrue;

import org.example.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AppTest 
{
    @Autowired
    private IAccountService accountService;

    @Test
    public  void testTransfer(){
        accountService.transfer("aaa","bbb",100f);

    }
}

在这里插入图片描述
产生异常数据库值没有变

spring基于注解配置事务

  1. 持久层代码使用注解
package org.example.dao.impl;

import org.example.dao.IAccountDao;
import org.example.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import org.springframework.stereotype.Repository;

import java.util.List;


@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public Account findAccountById(Integer accountId) {
        List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }

    public Account findAccountByName(String accountName) {
        List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
        if(accounts.isEmpty()){
            return null;
        }
        if(accounts.size()>1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }

    public void updateAccount(Account account) {
        jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
    }
}
  1. 业务层代码使用@Transactional注解配置事务
package org.example.service.impl;

import org.example.dao.IAccountDao;
import org.example.domain.Account;
import org.example.service.IAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("accountService")
@Transactional(propagation= Propagation.SUPPORTS,readOnly=true)//只读型事务的配置
public class AccountServiceImpl implements IAccountService {

    @Autowired
    private IAccountDao accountDao;


    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    //需要的是读写型事务配置
    @Transactional(propagation= Propagation.REQUIRED,readOnly=false)
    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
        //2.1根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        //2.2根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        //2.3转出账户减钱
        source.setMoney(source.getMoney()-money);
        //2.4转入账户加钱
        target.setMoney(target.getMoney()+money);
        //2.5更新转出账户
        accountDao.updateAccount(source);

        int i=1/0;

        //2.6更新转入账户
        accountDao.updateAccount(target);
    }

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

    <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="org.example"></context:component-scan>
    <!-- 配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/student"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>


    <!-- spring中基于注解 的声明式事务控制配置步骤
       1、配置事务管理器
       2、开启spring对注解事务的支持
       3、在需要事务支持的地方使用@Transactional注解

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

    <!-- 开启spring对注解事务的支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

</beans>
code_greenhand
关注
专栏目录
spring手动控制事务开启_手动控制spring事务
weixin_29605669的博客
12-24 3958
用spring的时候,什么时候需要手动控制事务?在方法前加@Transaction不行么？有这么一种场景，用户在web页面点击一个按钮，后台需要几分钟或几小时的长时间执行一段程序。这时如果页面不响应，用户感觉就一直卡在这里了。一种方法是起一个线程来跑这个程序，让请求立即返回。但这与我们平时的代码不太一样。平时的代码如果有事务直接放在Service的方法上就行了，再这个真正的执行是在一个线程里。而这...
spring事务控制
03-04
spring事务控制jar包，请网上自寻下载
Spring的事务控制
weixin_53455615的博客
10-15 1874
（2）在applicationContext.xml可以通过${key}的方式获取value，也可以在spring容器中的类中通过@Value("${key}")注解给属性赋value值。程序员只需要编写调用持久层代码和业务逻辑代码。把开启事务的代码放在前置通知中，把事务回滚和事务提交的代码放在了后置通知中。在Spring整个Mybatis后，默认是每个sql语句看作一个事务，当我们有业务需要多条sql时我们就需要控制事务了。（1）在applicationContext.xml中引入配置文件。
Spring控制事务回滚
BadBoyxiaolin的博客
03-07 5872
调用本类方法导致传播行为失效，同一个 Service 的两个方法之间调用，就会出现这个问题，原因还是在代理对象这里，我们期待的调用是一个代理类的调用，但是我们若是直接在方法中内部调用，不好意思，被调用的方法的事务失效，没有被 AOP 增强。当添加了注解或者全局事务配置了路径，但是需要用到事务的方法所在的类没有注入到Spring容器中，这样事务也不会生效，通常我们都是添加到业务逻辑处理层，通常都是添加。：在业务代码中，需要对异常单独进行处理，异常不会抛出，但需要事务回滚的情况，这个时候就需要手动调用回滚。
Spring事务控制
逐梦苍穹的博客
08-14 1733
本文详细介绍Sping的两种事务控制方式：xml和注解
Spring Boot事务控制
小飞侠的博客
04-14 1782
业务开发操作数据库过程中，我们基本都会涉及事务的操作，事务可以保证业务逻辑的完整性。所有的数据访问技术都有事务处理机制，这些技术提供了API用来开启事务、提交事务来完成数据操作，或者在发生错误的时候回滚数据。而Spring的事务机制是用统一的机制来处理不同数据访问技术的事务处理。Spring的事务机制提供了一个PlatformTransactionManager接口，不同的数据访问技术的事务使用不同的接口实现。
【Spring进阶系列丨最终篇】一文详解Spring中的事务控制
热门推荐
陈橘又青的博客
04-22 2万+
- 事务需要放在业务层(service) - Spring的事务是基于AOP的 - Spring的事务控制有两种：编程式事务【了解】和==声明式事务==【重点】 - 声明式事务分为：基于xml配置和基于注解配置
spring手动控制事务
lockie的博客
10-15 4545
实际项目中要实现spring的事务大多数我们都是使用 @Transactional(rollbackFor = Exception.class) 注解即可，但是有些业务场景需要我们手动处理事务我们就可以这样： //开启事务 DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(); // 嵌套事务 defaultTransactionDefinition.setPropag
Spring怎么实现控制事务
天马行空的创作中心
10-25 5598
转自：https://www.cnblogs.com/teach/p/5823574.html 在开发中需要操作数据库，进行增、删、改操作的过程中属于一次操作，如果在一个业务中需要更新多张表，那么任意一张表的更新失败，整个业务的更新就是失败，这时那些更新成功的表必须回滚，否则业务会出错，这时就要用到事务，即这个业务的操作属于一个事务，事务具有原子性、隔离性、一致性、持续性。这时便用到了事务，事务控...
Spring 事务
lfm1010123的博客
10-31 2531
一、Spring 事务的实现方式 二、Spring 事务的隔离级别 三、Spring 事务的传播机制
spring多线程事务控制
qq_40133060的博客
12-03 2809
话不多说直接上代码 ```/** * 将一组数据平均分成n组 * * @param source 要分组的数据源 * @param n 平均分成n组 * @param <T> * @return */ public static <T> List<List<T>> averageAssign(List<T> source, int n) { Li
Spring事务处理原理步骤详解
08-19
Spring事务处理原理步骤详解 Spring事务处理原理步骤详解是指在Spring框架中实现事务处理的整个过程，它涉及到事务处理的实现、事务处理原理和事务管理器的配置等几个方面。下面是Spring事务处理原理步骤详解的知识...
简单了解Spring中的事务控制
08-25
Spring中的事务控制 一、事务概念 事务是一组操作的执行单元，相对于数据库的单条操作而言，事务管理的是一组SQL指令，如增删改查等，事务的特性体现在事务内包含的SQL指令必须全部执行成功，如果其中一条指令发生...
rhino grasshoper 框内物体排列（附视频）.gh
最新发布
10-18
【闭合线内物体按方向移动/排列】https://www.bilibili.com/video/BV1z1WfeSEWu?vd_source=b420114c993138474d2e93d83ead77a5
kwant-1.4.3-cp38-cp38-win_amd64.whl
10-18
kwant-1.4.3-cp38-cp38-win_amd64.whl
rhino grasshoper 景观椅（附视频）.gh
10-18
【rhino@grasshoper 曲线金属座椅景观案例（文件获取/见简介）】https://www.bilibili.com/video/BV1Dx4y147Lr?vd_source=b420114c993138474d2e93d83ead77a5
PCIe通义万问系列文档的第一部已整理完毕，含999个PCIe相关问答
10-18
《PCIe通义万问》系列文档旨在记录PCIe相关行业工程师们在PCIe协议学习、IP设计验证、产品测试及使用过程中遇到的问题、迸发的思考、进行的探讨及可能的解决方案，以期给遇到相同相似问题的同行们些许启发。文档涉及的技术方向主要为PCIe，也包含PCIe相关的CXL、UCIe及计算机体系结构相关内容。 本文档是《PCIe通义万问》系列文档之（一），含999个问题。问题内容有以下三个来源：MangoPapa（下称博主）的“PCIe每日一问一答”系列专栏；博主的博文留言及私信讨论；博主作为群主的“PCIe技术交流群”群聊内容。MangoPapa小助理、折叠、先杰、CR小队长、kangling共同完成了问答内容提取与归纳整理，噫嘘唏及慕荷负责文辞优化及编辑排版，上述人员及MangoPapa、JasonW、皮塞阿姨、席可儿参与了文档内容的审校。感谢以上人员的无私奉献。 本文档仅对讨论内容进行总结记录，不保证问题答案的正确性，部分问题只提供解决思路或讨论过程。术业有专攻，文内定有偏颇。如您发现谬误，一敬希原宥，二望乞点拨；如您持异见，欢迎来信讨论。如有需要，欢迎联系MangoPapa加入相关
毕业设计论文SpringBoot招投标管理系统.docx
10-18
毕业设计论文
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值