Spring在业务层加入事务管理

已于 2022-11-02 09:04:51 修改
阅读量169 收藏 1
点赞数
文章标签： spring java mybatis 后端 数据库
于 2022-11-02 09:03:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/you4580/article/details/127645181
版权

文章目录
1.实体类
2.持久层接口
3.持久层实现类
4.业务层接口
5.业务层实现类
ConnectionUtils：从数据源中获取一个链接，并且实现和线程的绑定
TransactionManager :和事务管理相关的工具类
AccountDaoImpl实现类
AccountServiceImpl实现类
bean.xml文件
1.实体类

//实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
    private Integer id;
    private String name;
    private Float money;
}

2.持久层接口

//账户的持久层接口
public interface AccountDao {
    //查询所有
    List<Account> findAllAccount();

    //查询一个
    Account findAccountById(Integer id);

    //保存
    void saveAccount(Account account);

    //更新
    void updateAccount(Account account);

    //删除
    void deleteAccount(Integer id);

    //根据名称查询账户
    Account findAccountByName(String accountName);
}

3.持久层实现类

//持久层实现类
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner runner;


    public List<Account> findAllAccount() {
        try {
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountById(Integer id) {
        try {
            return runner.query("select * from account where id=?",new BeanHandler<Account>(Account.class),id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void saveAccount(Account account) {
        try {
            runner.update("insert into account(name,money) values(?,?)",account.getName(),account.getMoney());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {
        try {
            runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void deleteAccount(Integer id) {
        try {
            runner.update("delete from account where id=?",id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public Account findAccountByName(String accountName) {
        try {
            List<Account> accounts = runner.query("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);
        }
    }
}

4.业务层接口

public interface AccountService {
    //查询所有
    List<Account> findAllAccount();

    //查询一个
    Account findAccountById(Integer id);

    //保存
    void saveAccount(Account account);

    //更新
    void updateAccount(Account account);

    //删除
    void deleteAccount(Integer id);

    //转账
    void transfer(String sourceName,String targetName,Float monry);
}

5.业务层实现类

//业务层实现类，业务层调用持久层
@Service("accountService")
public class AccountServiceImpl implements AccountService{

    @Autowired
    private AccountDao accountDao;


    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    public void deleteAccount(Integer id) {
        accountDao.deleteAccount(id);
    }
    public void transfer(String sourceName, String targetName, Float money) {
        //根据名称查询转出账户
        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);
    }
}

 

 对上述代码进行改进：

ConnectionUtils：从数据源中获取一个链接，并且实现和线程的绑定

//从数据源中获取一个链接，并且实现和线程的绑定
public class ConnectionUtils {
    private ThreadLocal<Connection> t = new ThreadLocal<Connection>();
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Connection getConnection(){
        try {
            //先从线程上获取
            Connection conn = t.get();
            //判断当前线程上是否有链接
            if(conn==null){
                //从数据源中获取一个链接，并且存入线程中
                conn = dataSource.getConnection();
                t.set(conn);
            }
            return conn;
        } catch (SQLException e) {
           throw new RuntimeException(e);
        }
    }
    //把连接和线程解绑
    public void removeConnection(){
        t.remove();
    }
}

TransactionManager :和事务管理相关的工具类

//和事务管理相关的工具类
public class TransactionManager {
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public void beginTransaction(){
        //开启事务
        try {
            connectionUtils.getConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void commit(){
        //提交事务
        try {
            connectionUtils.getConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void rollback(){
        //回滚事务
        try {
            connectionUtils.getConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public void release(){
        //释放链接
        try {
            connectionUtils.getConnection().close();//把conn还回连接池中
            connectionUtils.removeConnection();//将conn和线程解绑
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

AccountDaoImpl实现类

//持久层实现类
public class AccountDaoImpl implements AccountDao {
    private QueryRunner runner;
    private ConnectionUtils connectionUtils;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public List<Account> findAllAccount() {
        try {
            return runner.query(connectionUtils.getConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountById(Integer id) {
        try {
            return runner.query(connectionUtils.getConnection(),"select * from account where id=?",new BeanHandler<Account>(Account.class),id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void saveAccount(Account account) {
        try {
            runner.update(connectionUtils.getConnection(),"insert into account(name,money) values(?,?)",account.getName(),account.getMoney());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void updateAccount(Account account) {
        try {
            runner.update(connectionUtils.getConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public void deleteAccount(Integer id) {
        try {
            runner.update(connectionUtils.getConnection(),"delete from account where id=?",id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    public Account findAccountByName(String accountName) {
        try {
            List<Account> accounts = runner.query(connectionUtils.getConnection(),"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);
        }
    }
}

AccountServiceImpl实现类

//业务层实现类，业务层调用持久层
public class AccountServiceImpl implements AccountService{

    private AccountDao accountDao;
    private TransactionManager transactionManager;

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

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public List<Account> findAllAccount() {
        try {
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事务
            transactionManager.commit();
            //4.返回结果
            return accounts;
        } catch (Exception e) {
            //5.回滚事务
            transactionManager.rollback();
            //这个必须写，否则产生异常没有返回值，程序编译器就有错
            throw new RuntimeException(e);
        }finally {
            //6.释放资源
            transactionManager.release();
        }
    }

    public Account findAccountById(Integer id) {
        try {
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(id);
            //3.提交事务
            transactionManager.commit();
            //4.返回结果
            return account;
        } catch (Exception e) {
            //5.回滚事务
            transactionManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放资源
            transactionManager.release();
        }
    }
    public void saveAccount(Account account) {
        try {
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事务
            transactionManager.commit();
        } catch (Exception e) {
            //5.回滚事务
            transactionManager.rollback();
        }finally {
            //6.释放资源
            transactionManager.release();
        }
    }
    public void updateAccount(Account account) {
        try {
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account );
            //3.提交事务
            transactionManager.commit();
        } catch (Exception e) {
            //5.回滚事务
            transactionManager.rollback();
        }finally {
            //6.释放资源
            transactionManager.release();
        }
    }
    public void deleteAccount(Integer id) {
        try {
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(id);
            //3.提交事务
            transactionManager.commit();
        } catch (Exception e) {
            //5.回滚事务
            transactionManager.rollback();
        }finally {
            //6.释放资源
            transactionManager.release();
        }
    }
    public void transfer(String sourceName, String targetName, Float money) {
        try {
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            //根据名称查询转出账户
            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);
            //3.提交事务
            transactionManager.commit();
        } catch (Exception e) {
            //5.回滚事务
            transactionManager.rollback();
            e.printStackTrace();
        }finally {
            //6.释放资源
            transactionManager.release();
        }
    }
}

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: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
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--Spring在创建容器时，要扫描的包-->
    <context:component-scan base-package="com.hh"/>

    <!--配置AccountDao-->
    <bean id="accountDao" class="com.hh.dao.AccountDaoImpl">
        <property name="connectionUtils" ref="connectionUtils"/>
        <property name="runner" ref="queryRunner"/>
    </bean>

    <!--配置AccountService-->
    <bean id="accountService" class="com.hh.service.AccountServiceImpl">
        <property name="transactionManager" ref="transactionManage"/>
        <property name="accountDao" ref="accountDao"/>
    </bean>

    <!--配置事务管理器-->
    <bean id="transactionManage" class="com.hh.utils.TransactionManager">
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>

    <!--配置QueryRunner-->
    <bean id="queryRunner" 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 name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring"/>
        <property name="user" value="root"/>
        <property name="password" value="123"/>
    </bean>

    <!--配置ConnectionUtils工具类-->
    <bean id="connectionUtils" class="com.hh.utils.ConnectionUtils">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

 

you4580
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring事务管理
转错的弯，走错的路
04-28 3958
id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> name="dataSource" ref="dataSource" /> tx:annotation-driven transaction-manager="transactionManage
Spring事务管理(业务层)
wjl__ai__的博客
05-06 390
事务控制 编程式 注解式 声明式 ACID原则 Atomicity:原子性 Consistency:一致性 Isolation:隔离性 Durability:持久性 TransactionDefinition定义的事务传播属性 编号 传播属性 描述 1 PROPAGATION_REQUIRED 如果存在事务，则支持当前事务。如果没有当前事务，则开启新的事务 2 PROPAGATION_SUPPORTS 如果存在事务，则支持当前事务。如果没有当前事务，则非事务地执行 3 PRO
Spring 事务（一）
攻城狮
06-28 457
事物自定义标签&lt;tx:annotation-driven/&gt;那我们就从这个标签入手，那一定会在spring-tx项目中。从resources\META-INF\spring.handlers里面查看会转向到TxNamespaceHandler类。public class TxNamespaceHandler extends NamespaceHandlerSupport { ...
SpringBoot项目实战：业务层开发
m0_47268721的博客
12-29 889
标准业务层包结构： 自定义异常结构继承体系 创建一个IUserService接口： public interface IUserService { //用户注册 void reg(User user); } 创建实现类：注意！@Service这个注解是加在实现类上的，如果不加会导致springboot找不到实现类。 md5加密算法：考虑到密码以明文显示不安全，这里多加一个md5加密。存入数据库的密码都是加过加密之后的字符串，增加了数据库的安全性。 package com.zjq.s
spring添加事物管理
baidu_38405837的博客
09-06 266
1：spring配置文件添加头：版本依照自己本地修改 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:a...
Spring 使用注解方式进行事务管理配置方式
08-30
Spring框架的注解式事务管理是一种便捷的方式来控制事务在应用程序中的行为，特别是在JavaEE开发中。这种方式使得开发者可以在不修改大量XML配置的情况下，通过在类或方法上添加注解来实现事务管理。以下是对Spring...
Spring事务管理Demo
05-01
2. **声明式事务管理**：这是Spring最常用的方式，通过在配置文件或者使用`@Transactional`注解来定义事务边界，使得事务管理与业务逻辑分离，降低了代码的耦合度。`@Transactional`注解可以应用于方法级别，表示该...
spring事务管理
10-27
在Spring框架中，编程式事务管理主要通过`org.springframework.transaction.support.TransactionTemplate`或`org.springframework.transaction.PlatformTransactionManager`来实现。 **示例代码分析**： 首先，...
spring事务管理.rar
05-07
- **声明式事务管理**：这是Spring中最常用的方式，基于AOP（面向切面编程）实现，无需在业务代码中显式管理事务。通过在配置文件或注解中声明事务规则，Spring会自动处理事务的开始、提交、回滚等操作。 ### 3. ...
使用Spring AOP 对业务层提供事务支持
weixin_44757931的博客
12-23 549
使用Spring AOP 对业务层提供事务支持 经过之前的学习，大家肯定都对 Spring的两大核心：IOC【控制反转】和AOP【面向切面】有所了解了。那么我们现在就来实战一波，来体会下AOP的强大之处。 首先我们来简单复习下什么是AOP，AOP中文意思就是面向切面编程，我们都知道面向接口编程，面向对象编程，那这个切面是个啥子东东。在此之前我们先说说动态代理。我们都学过动态代理，通过动态代理我们可...
spring 整合 mybatis 时在业务层开启事务实现方式
向明天的美好出发
02-05 143
Spring 应用及原理分析
壮乡码农
12-22 1168
Spring 是一个轻量级的开发框架，以ioC和AOP为内核，提供了展现层Spring MVC和业务事务管理等众多企业级应用技术。还能整合众多的第三方类库，是目前java非常流行的框架。Spring 的核心思想就是IOC和AOP。 1.什么是IoC与DI ioC与DI都是描述的同一件事，但是出发点不同。ioC的英文全称是Inversion of Contronl,翻译过来是反转控制。DI 英文全称为Depedency Inection ，翻译过来是依赖注入。IOC和DI...
自定义ioc/aop（一）
HaiYun
03-12 1188
自定义ioc
Android 自定义网络加载工具类 HttpURLConnectionUtils
roll圈圈的博客
03-23 4787
代码已经上传到github，欢迎Star。https://github.com/MZCretin/HttpUrlConnectionUtilDemo 转载请注明出处：简书地址：http://www.jianshu.com/p/3da7f0dc11a0一个自己封装的用HttpUrlConnection请求的网络工具类，但只适合新手研究或者做些小demo用下， 毕竟现在对于Android开发的网络框架
ConnectionUtil
ouou009的专栏
03-27 1354
static     {         jdbcAddress = PropertieTools.getInstance().getStringVal(Constants.PROPERTIES_JDBC_ADDRESS);         jdbcLoginname = PropertieTools.getInstance().getStringVal(Constants.PROPERTI
ConnectionUtils
emperor_xdy的专栏
10-21 1668
package util; import java.io.IOException; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import
Spring中使用动态代理实现事务控制
你今天真好看呀
10-27 1065
这是个很好的案例，能让你对事务，动态代理，Spring中IOC容器有一个更为深刻的理解。 文章目录0.实体类1.持久层接口2.持久层实现类3.业务层接口4.业务层实现类5.获取连接工具类6.事务管理工具类7.创建AccountService代理对象的工厂8.bean.xml配置文件9.测试类 0.实体类 //实体类 @Data @AllArgsConstructor @NoArgsConstruc...
Spring事务管理配置详解
"这篇文档介绍了如何在SSH架构的项目中集成Spring的声明式事务管理功能，主要涉及到Spring 2.0 AOP库的添加以及在`applicationContext.xml`中的事务管理器配置和事务传播特性的设定。" 在Java Web开发中，Spring...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值