Spring中事务控制基于XML的AOP实现事务控制

最新推荐文章于 2023-01-26 21:44:41 发布
最新推荐文章于 2023-01-26 21:44:41 发布
阅读量102 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/108514215
版权

Spring中事务控制基于XML的AOP实现事务控制

1.1 基于XML的AOP实现事务控制
1.打开IDEA界面如图所示，点击Create New Project。在这里插入图片描述
2.选择Maven工程和JDK的版本，点击Next。如图所示：在这里插入图片描述
3.填写项目的名称和保存的地址，点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?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.txw</groupId>
    <artifactId>day04__02account_aoptx_xml</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式-->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入spring的依赖jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <!--导入spring整合junit的jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--导入dbutils的依赖jar包-->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <!--导入MySQL的依赖jar包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!--导入c3p0的依赖jar包-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <!--导入Junit单元测试的依赖jar包-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <!--导入lombok的依赖jar包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
    </dependencies>
</project>

5.创建账户的实体类的代码如下：

package com.txw.domain;

import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
/**
 * 账户的实体类
 * @author adair
 */
@Data        // 自动生成set和get方法
@ToString      // 重写toString方法
@SuppressWarnings("all")         //  注解警告信息
public class Account implements Serializable {
    private Integer id;       // 账户的id
    private String name;      // 账户的名称
    private Float money;      // 账户的余额
}

6.创建账户的持久层接口的代码如下：

package com.txw.dao;

import com.txw.domain.Account;
import java.util.List;
/**
 * 账户的持久层接口
 * @author Adair
 */
@SuppressWarnings("all")         //  注解警告信息
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     * 根据id查询
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存账户
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 删除账户
     * @param acccountId
     */
    void deleteAccount(Integer acccountId);
    /**
     * 根据名称查询账户
     * @param accountName
     * @return  如果有唯一的一个结果就返回，如果没有结果就返回null
     *          如果结果集超过一个就抛异常
     */
    Account findAccountByName(String accountName);
}

7．创建账户的持久层实现类的代码如下：

package com.txw.dao.impl;

import com.txw.dao.IAccountDao;
import com.txw.domain.Account;
import com.txw.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.util.List;
/**
 * 账户的持久层实现类
 * @author Adair
 */
@SuppressWarnings("all")         //  注解警告信息
public class AccountDaoImpl implements IAccountDao {
    // 声明QueryRunner业务对象
    private QueryRunner runner;
    // 声明ConnectionUtils业务对象
    private ConnectionUtils connectionUtils;
    /**
     * set注入
     * @param runner
     */
    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    /**
     * set注入
     * @param connectionUtils
     */
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
    /**
     * 查询所有
     * @return
     */
    public List<Account> findAllAccount() {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据id查询
     * @param accountId
     * @return
     */
    public Account findAccountById(Integer accountId) {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 保存账户
     * @param account
     */
    public void saveAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 更新账户
     * @param account
     */
    public void updateAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 更新账户
     * @param accountId
     */
    public void deleteAccount(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 根据名称查询账户
     * @param accountName
     * @return
     */
    public Account findAccountByName(String accountName) {
        try{
            List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ? ",new BeanListHandler<Account>(Account.class),accountName);
            if(accounts == null || accounts.size() == 0){
                return null;
            }
            if(accounts.size() > 1){
                throw new RuntimeException("结果集不唯一，数据有问题");
            }
            return accounts.get(0);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

8.创建账户的业务层接口的代码如下:

package com.txw.service;

import com.txw.domain.Account;
import java.util.List;
/**
 * 账户的业务层接口
 * @author Adair
 */
@SuppressWarnings("all")         //  注解警告信息
public interface IAccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
        /**
     * 根据id查询
     * @return
     */
    Account findAccountById(Integer accountId);
    /**
     * 保存账户
     * @param account
     */
    void saveAccount(Account account);
    /**
     * 更新账户
     * @param account
     */
    void updateAccount(Account account);
    /**
     * 删除账户
     * @param acccountId
     */
    void deleteAccount(Integer acccountId);
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    void transfer(String sourceName,String targetName,Float money);
}

9.创建账户的业务层实现类的代码如下：

package com.txw.service.impl;

import com.txw.dao.IAccountDao;
import com.txw.domain.Account;
import com.txw.service.IAccountService;
import java.util.List;
/**
 * 账户的业务层实现类
 * 事务控制应该都是在业务层
 * @author Adair
 */
@SuppressWarnings("all")         // 注解警告信息
public class AccountServiceImpl implements IAccountService{
    // 声明IAccountDao业务对象
    private IAccountDao accountDao;
    /**
     * set注入
     * @param accountDao
     */
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
    /**
     * 查询所有
     * @return
     */
    public List<Account> findAllAccount() {
       return accountDao.findAllAccount();
    }
    /**
     * 根据id查询
     * @param accountId
     * @return
     */
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }
    /**
     * 保存账户
     * @param account
     */
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
    /**
     * 更新账户
     * @param account
     */
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }
    /**
     * 删除账户
     * @param acccountId
     */
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }
    /**
     * 转账
     * @param sourceName        转出账户名称
     * @param targetName        转入账户名称
     * @param money             转账金额
     */
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            // 根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            // 根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            // 转出账户减钱
            source.setMoney(source.getMoney()-money);
            // 转入账户加钱
            target.setMoney(target.getMoney()+money);
            // 更新转出账户
            accountDao.updateAccount(source);
//            int i=1/0;
            // 更新转入账户
            accountDao.updateAccount(target);
    }
}

10.创建连接的工具类的代码如下：

package com.txw.utils;

import javax.sql.DataSource;
import java.sql.Connection;
/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 * @author Adair
 */
@SuppressWarnings("all")         //  注解警告信息
public class ConnectionUtils {
    // 声明ThreadLocal业务对象
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    // 声明DataSource业务对象
    private DataSource dataSource;
    /**
     * set注入
     * @param dataSource
     */
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getThreadConnection() {
        try{
            // 先从ThreadLocal上获取
            Connection conn = tl.get();
            // 判断当前线程上是否有连接
            if (conn == null) {
                // 从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            // 返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
    /**
     * 把连接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

11.创建和事务管理相关的工具类代码如下：

package com.txw.utils;

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 * @author Adair
 */
@SuppressWarnings("all")         //  注解警告信息
public class TransactionManager {
    // 声明ConnectionUtils业务对象
    private ConnectionUtils connectionUtils;
    /**
     * set注入
     * @param connectionUtils
     */
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
    /**
     * 开启事务
     */
    public  void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 提交事务
     */
    public  void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 回滚事务
     */
    public  void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 释放连接
     */
    public  void release(){
        try {
            connectionUtils.getThreadConnection().close();//还回连接池中
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

12.在resource创建bean,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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
     <!-- 配置Service -->
    <bean id="accountService" class="com.txw.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <!--配置Dao对象-->
    <bean id="accountDao" class="com.txw.dao.impl.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"></bean>
    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="com.txw.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!-- 配置事务管理器-->
    <bean id="txManager" class="com.txw.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
    <!--配置aop-->
    <aop:config>
        <!--配置通用切入点表达式-->
        <aop:pointcut id="pt1" expression="execution(* com.txw.service.impl.*.*(..))"></aop:pointcut>
        <aop:aspect id="txAdvice" ref="txManager">
            <!--配置前置通知：开启事务-->
            <aop:before method="beginTransaction" pointcut-ref="pt1"></aop:before>
            <!--配置后置通知：提交事务-->
            <aop:after-returning method="commit" pointcut-ref="pt1"></aop:after-returning>
            <!--配置异常通知：回滚事务-->
            <aop:after-throwing method="rollback" pointcut-ref="pt1"></aop:after-throwing>
            <!--配置最终通知：释放连接-->
            <aop:after method="release" pointcut-ref="pt1"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

13.测试类的代码如下：

package com.txw.test;

import com.txw.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;
/**
 * 使用Junit单元测试：测试我们的配置
 * @author Adair
 */
@SuppressWarnings("all")         //  注解警告信息
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
    // 声明IAccountService业务对象
    @Autowired
    private  IAccountService as;
    @Test
    public  void testTransfer(){
        as.transfer("aaa","bbb",100f);
    }
}

运行之前的数据库的数据如图所示：在这里插入图片描述
运行测试代码如图所示：在这里插入图片描述
运行之后的数据库的数据如图所示：说明控制住事务！在这里插入图片描述

学无止路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
spring aop两种配置方式
09-03
主要为大家详细介绍了spring aop两种配置方式,主要是注解配置AOP和xml配置aop，需要的朋友可以参考下
04 Spring: 10.Spring中事务控制（上）
Marlon康
09-10 166
04 Spring: 10.Spring中事务控制 1 基于XML的AOP实现事务控制、2 作业-基于注解的AOP实现事务控制及问题分析_上、3 作业-基于注解的AOP实现事务控制及问题分析_下、4 spring中事务控制的一组API、5 spring事务控制的代码准备、6 spring基于XML的声明式事务控制-配置步骤、7 spring基于注解的声明式事务控制、8 spring基于纯注解的...
Spring中基于注解的AOP实现事务控制
weixin_45430616的博客
01-29 236
数据库表 IDEA中创建maven项目 整体构架 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" ...
spring笔记下(AOP、事务管理)
白豆五的博客
01-26 1266
todo
Spring--基于AOP实现事务控制
龙源IT 的博客
10-04 1914
事务是一组操作组成的单元模块，执行操作时，要么操作成功，要么失败回滚到最开始的状态。本篇文章以银行转账案例为例，实现基于AOP的事务控制。
spring框架源码三、自定义aop实现事务控制
CaptainCats的博客
10-06 581
用工厂类生成BankAccountService的动态代理，BankAccountController调用BankAccountService的动态代理对象，在代理对象中增强横切逻辑。
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
spring框架手动提交事务，jdbctample
04-03
按老师的说法是基于xml方式，但不准确，因为也用到了注解 <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy> xml中要有这句，可以解决子类类报错的问题。 或者去掉这句话，同时去掉...
Spring 代理 Aop 实现原理讲解.docx
12-01
 IoC原理分析  基于XML的IoC实现 ... Spring AOP基于XML和注解的实现Spring应用之Spring JDBC实现Spring应用之JdbcDaoSupport  Spring应用之事务支持  Spring与Mybatis整合
spring aop (面向切面编程)实现事务管理(^_^^_^)
jaryle的专栏
03-23 2900
事务嵌套，不回滚的问题描述： 要想事务起作用，必须是主方法名上有@Transactional注解，方法体内不能用try catch；如果用try catch，则catch中必须用throw new RuntimeException(); @Transactional注解应该只被应用到public方法上，不要用在protected、private等方法上，即使用了也将被忽略，不起作用。这是由Sp...
AOP实现事务控制
sky2line的专栏
11-14 711
（1）
AOP结合注解实现项目中接口调用情况监控
qq_44749491的博客
11-23 5800
一文学会项目中如何进行接口调用情况监控的实用功能
基于注解的AOP实现事务控制
...
04-26 249
需要注意在使用注解时，后置通知与异常通知执行顺序颠倒，所以要用环绕通知来解决此问题。 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/XMLSche...
AOP事务管理
博客
01-19 515
事务作用：在数据层保障一系列的数据库操作同成功同失败Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败数据层有事务我们可以理解，为什么业务层也需要处理事务呢？举个简单的例子：转账业务会有两次数据层的调用，一次是加钱一次是减钱把事务放在数据层，加钱和减钱就有两个事务没办法保证加钱和减钱同时成功或者同时失败这时候就需要将事务放在业务层进行处理Spring为了管理事务，提供了一个平台事务管理器PlatformTransactionManager。
基于注解的SpringAop事务管理
weixin_43323647的博客
09-21 89
前置事务： /** * 前置通知 */ //@Before(value = "pt1()") public void beforeprintLog(){ System.out.println("Logger类中的beforepringLog开始记录日志"); } 后置事务： /** * 后置通知 */ //@After(value = "pt1()") public void afterprintLog(){
spring第二篇之AOP及其事物的管理
manba123456的博客
03-15 1012
概念： AOP是一种面向切面编程思想，是OOP的延续。其核心思想就是：横向重复，纵向抽取。Spring AOP中的动态代理很好的体现了这种思想。 如何去理解这种思想呢？如下图所示： AOP作用：不修改源码的情况下对程序进行增强。AOP可以进行权限校验、日志记录、性能监控、事务控制。 Spring底层AOP实现原理：动态代理(增强一个类中方法) 1，JDK动态代理(优先) 被代理对...
使用aop来实现事务功能（日志）
weixin_48656058的博客
11-25 3118
通俗讲, AOP思想就是把中间的非主流程的代码(比如:验证、事务管理、缓存、日志记录等), 横向抽取出来放在一个公共的类中, 也就是切面.可以通过Spring框架来配置该切面
详解 Spring 注解@Transactional事务Aop实现原理
heikeb的专栏
08-29 1802
详解 Spring 注解@Transactional事务控制原理
实现spring Aop 注解实现事务处理
D_ohko的博客
01-05 1480
声明式事务管理也有两种常用的方式，一种是基于tx和aop名字空间的xml配置文件，另一种就是基于@Transactional注解。显然基于注解的方式更简便和防spring侵入。 以myBatis为例   基于注解的声明式事务管理配置@Transactional 首先这个配置要先在连接数据的配置文件中配置： 这是我的配置文件 class="org.springframewor
Spring AOP配置的理解 尤其是事务控制的理解
最新发布
07-13
Spring AOP（面向切面编程）是Spring框架中的一个重要特性，它允许开发者在程序运行时动态地将额外的行为织入到现有的代码中，而不需要修改原始代码。其中，事务控制是Spring AOP的一个常见应用场景。 在Spring中，事务控制是通过AOP来实现的。通过配置AOP，我们可以将事务相关的代码（如开启事务、提交事务、回滚事务等）织入到业务方法的执行过程中。这样，我们就可以将事务的管理与业务逻辑解耦，提高代码的可维护性和可重用性。 在进行Spring AOP配置时，我们通常需要以下几个步骤： 1. 引入AOP依赖：在项目的依赖管理文件（如pom.xml）中添加相关的AOP依赖，如spring-aop和spring-context等。 2. 配置AOP代理：在Spring配置文件（如applicationContext.xml）中配置AOP代理，通常使用<aop:config>元素进行配置。在配置中，我们可以指定要代理的目标对象和切面类，以及切面类中定义的通知（如@Before、@After、@Around等）。 3. 配置事务管理器：在Spring配置文件中配置事务管理器，通常使用<tx:annotation-driven>元素进行配置。在配置中，我们可以指定事务管理器的类型（如基于JDBC的事务管理器或基于JTA的事务管理器）。 4. 配置事务切面：在切面类中，我们可以使用@Transactional注解来标记需要进行事务管理的方法或类。通过这些注解，Spring会在方法执行前后自动开启、提交或回滚事务。 总结来说，Spring AOP配置的核心就是定义切面类和通知，并通过AOP代理将其织入到目标对象的方法执行过程中。对于事务控制，我们可以利用@Transactional注解来定义需要进行事务管理的方法或类。这样，Spring会根据配置自动管理事务的开启、提交和回滚操作，简化了事务管理的代码编写。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学无止路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值