Spring-事务管理（一）——动态代理实现

最新推荐文章于 2020-09-10 20:58:37 发布
最新推荐文章于 2020-09-10 20:58:37 发布
阅读量521 收藏 2
点赞数 1
分类专栏： javaEE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43661408/article/details/104418767
版权

一、概述

模拟银行转钱的案例，
在service中执行代码逻辑中是

  1. 根据名称查询转出账户
  2. 根据名称查询转入账户
  3. 转出账户减钱
  4. 转入账户加钱
  5. 更新转出账户
  6. 更新转入账户

当上述步骤中任何一步发生错误时，应该发生事务回滚的操作。

下面采用动态代理+纯注解方式实现事务的管理

案例文件架构
在这里插入图片描述

二、案例的代码实现

导入的依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</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.48</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.26.0-GA</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>
    </dependencies>

实体类

public class Account implements Serializable {
    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 +
                '}';
    }

第一步：首先配置类，代替了xml

SpringConfiguration

/**
 * 用来替代bean.xml
 */
@Configuration //表明这是一个配置类
@ComponentScan("com.itheima") //告诉spring要扫描包
@Import(Jdbcconfig.class) //引入连接数据库的配置类
@PropertySource("classpath:jdbcConfig.properties") //jdbc的相关属性设置
public class SpringConfiguration {}

Jdbcconfig

public class Jdbcconfig {
	//将properties文件中的信息读取出来，配置文件中等号左边是什么，注解中就使用什么
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    //自动提交事务时
    @Bean(name="runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(){
        return new QueryRunner();
    }
    //地址池
    @Bean(name="dataSource")
    public DataSource createDataSource(){
        try {
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return  ds;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

jdbcConfig.properties在resources中
需要自己设置用户名和密码

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

第二步：工具类

从地址池获取连接绑定线程，还有事务管理工具类包含开始事务，提交事务，回滚事务，释放连接

ConnectionUtils

@Component("connectionUtils")
public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    @Autowired
    private DataSource dataSource;
    /**
     * 获取当前线程上的连接
     */
    public Connection getTreadConnection(){

        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if(conn == null){
                //3.从数据园中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
    /**
     * 把链接和线程解绑
     */
    public void removeConnection(){
        tl.remove();
    }
}

TransactionManager

@Component("txManager")
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;
    /**
     * 开始事务
     */
    public void beginTransaction(){
        try {
            connectionUtils.getTreadConnection().setAutoCommit(false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 提交事务
     */
   public void commit(){
       try {
           connectionUtils.getTreadConnection().commit();
       } catch (Exception e) {
           e.printStackTrace();
       }

    }
    /**
     * 回滚事务
     */
    public void rollback(){
        try {
            connectionUtils.getTreadConnection().rollback();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 关闭连接
     */
    public void release(){
        try {
            connectionUtils.getTreadConnection().close();
            connectionUtils.removeConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

第三步： 持久层（dao层）

AccountImpl接口

/**
 * 账户持久层接口
 */
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     *查询一个
     */
    Account findAccountById(Integer id);
    /**
     * 保存
     */
    void saveAccount(Account account);
    /**
     * 更新
     */
    void updateAccount(Account account);
    /**
     * 删除
     */
    void deleteAccount(Integer id);
    /**
     * 根据姓名查找
     */
    Account findAccountByName(String name);
}

AccountImpl 实现类

/**
 * 账户持久层实现类
 */
@Repository("accountDao")
public class AccountImpl implements IAccountDao {
    @Autowired
    private QueryRunner runner;
    @Autowired
    private ConnectionUtils connectionUtils;

    public List<Account> findAllAccount() {
        try {
           return runner.query(connectionUtils.getTreadConnection(),"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.getTreadConnection(),"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.getTreadConnection(),"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.getTreadConnection(),"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.getTreadConnection(),"delete from account where id= ?",id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    public Account findAccountByName(String name) {
        try {
            List<Account> accounts = runner.query(connectionUtils.getTreadConnection(),"select * from account where name = ?", new BeanListHandler<Account>(Account.class), name);
            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);
        }
    }
}

第四步：servcie层

AccountServiceImpl接口

public interface IAccountService{
    /**
     * 查询所有
     * @return
     */
    List<Account> findAllAccount();
    /**
     *查询一个
     */
    Account findAccountById(Integer id);
    Account findAccountByName(String name);
    /**
     * 保存
     */
    void saveAccount(Account account);
    /**
     * 更新
     */
    void updateAccount(Account account);
    /**
     * 删除
     */
    void deleteAccount(Integer id);
    /**
     * 转账，转出，转入，金额
     */
    void transfer(String sourceName,String targetName,Float money);

}

AccountServiceImpl实现类

@Service("accountService")
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private IAccountDao accountDao;

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

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

    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) {
        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);
    }
}

第五步：编写代理类 （非常重要）

Beanfactory

/**
 * 用于创建Service的代理对象的工厂
 */
@Component("beanFactory")
public class Beanfactory {
   @Autowired
    private IAccountService accountService;
   @Autowired
    private TransactionManager txManager;
    /**
     * 获取Service代理对象
     * @return
     */
    @Bean("proxyAccountService")
    public IAccountService getAccountService() {
        return (IAccountService)Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 添加事务的支持
                     *
                     * @param proxy
                     * @param method
                     * @param args
                     * @return
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        if("test".equals(method.getName())){
                            return method.invoke(accountService,args);
                        }

                        Object rtValue = null;
                        try {
                            //1.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

最后编写测试类

AccountServiceTest

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {
    @Autowired
    @Qualifier("proxyAccountService") //使用Service的代理对象的工厂
    private IAccountService as;
    @Test
    public void testfindAll() {
        List<Account> accounts = as.findAllAccount();
        for (Account account:accounts){
            System.out.println(account);
        }
    }
    @Test
    public void testFindOne() {
        Account account = as.findAccountById(1);
            System.out.println(account);
    }
    @Test
    public void testSave() {
        Account account = new Account();
        account.setMoney(1200f);
        account.setName("test");
        as.saveAccount(account);

    }
    @Test
    public void testUpdate() {
        Account account = as.findAccountById(5);
        account.setMoney(5632f);
        as.updateAccount(account);

    }
    @Test
    public void testDelete() {
        as.deleteAccount(4);
    }
    @Test
    public void findAccountByName(){
        Account account = as.findAccountByName("aaa");
        System.out.println(account);
    }
    @Test
    public void testTransfer(){
        as.transfer("bbb","aaa",20f);
    }
}

结果：

在这里插入图片描述
因为在service的转账逻辑中设置一个异常 int i=1/0；所以转账不能成功
在这里插入图片描述去掉设置int i=1/0; 后 成功
在这里插入图片描述

超负荷小生
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
主流框架二：Spring（4）动态代理实现事务控制
rnang0的博客
08-25 213
主流框架二：Spring（3）Spring基于注解的IOC和案例分析
spring 动态代理及事务
loulou2014的博客
04-23 321
1:首先我们来简单了解一下spring的概念 它是一个 full-stack 框架，提供了从表现层到业务层再到持久层的一套完整的解决方案。我们在项目中可以只使用 spring 一个框架， 它就可以提供表现层的 mvc 框架，持久层的 Dao 框架。它的两大核心 IoC 和 AOP 更是为我们程序解耦和代码简洁易维护提供了支持 当然他还有一个不是功能的功能及集成其他框架（当年面试官问我的时候怎么也没...
Spring事务管理机制的实现原理-动态代理
热门推荐
hwssz的专栏
08-17 1万+
<br />　之前在做项目中遇到spring无法进行事务代理问题，最后发现是因为没有写接口，原因当时明白了，看到这篇文章写的清楚些，转过来<br /> <br />我们先来分析一下Spring事务管理机制的实现原理。由于Spring内置AOP默认使用动态代理模式实现，我们就先来分析一下动态代理模式的实现方 法。动态代理模式的核心就在于代码中不出现与具体应用层相关联的接口或者类引用，如上所说，这个代理类适用于任何接口的实现。下面我们来看一个例子。 public class TxHandler implemen
Spring中使用动态代理实现事务控制
你今天真好看呀
10-27 1054
这是个很好的案例，能让你对事务，动态代理，Spring中IOC容器有一个更为深刻的理解。 文章目录0.实体类1.持久层接口2.持久层实现类3.业务层接口4.业务层实现类5.获取连接工具类6.事务管理工具类7.创建AccountService代理对象的工厂8.bean.xml配置文件9.测试类 0.实体类 //实体类 @Data @AllArgsConstructor @NoArgsConstruc...
【事务】浅谈事务管理（传统方式+动态代理方式+AOP方式+Transcation注解方式）
weixin_44823875的博客
03-27 329
【Spring】（3）浅谈事务管理（1）动态代理实现事务管理（1.1）准备步骤（1.1.1）准备pojo实体类（1.1.2）连接线程的工具类：用来从数据源中获取一个连接，并且实现和线程的绑定（1.1.3）事务管理相关的工具类（1.2）编写步骤（1.2.1）持久层Dao编写（接口没写）（1.2.2）业务层Service编写（接口没写）（1.2.3）代理工厂编写（1.3）测试步骤（2）使用AOP注解方...
Spring_事务控制_动态代理
底层码农
05-03 6719
Spring_事务控制_动态代理
四、Spring源码分析——动态代理
08-11
在Spring框架中，动态代理是实现AOP（面向切面编程）的核心技术之一。它允许我们在不修改原有代码的情况下，为方法添加额外的功能，如事务管理、日志记录等。本篇文章将深入探讨Spring中的动态代理机制，以及它是...
Spring3事务管理——使用@Transactional 注解.rar
09-16
在Spring框架中，事务管理是核心特性之一，它确保了数据操作的一致性和完整性。Spring3引入了基于注解的事务管理，极大地简化了事务配置，使得开发者可以在方法级别声明事务边界，这就是`@Transactional`注解的用处...
spring--5.1.5.RELEASE.jar.rar
01-09
Spring AOP通过动态代理机制实现了这一功能，它可以为普通Java对象（POJO）添加额外的行为，无需侵入到原有的业务逻辑中。在5.1.5.RELEASE版本中，Spring AOP提供了更丰富的切面定义方式，包括注解和XML配置，使得...
spring-framework-4.3.3.RELEASE.rar
03-07
2. **面向切面编程（Aspect-Oriented Programming, AOP）**：Spring提供了基于代理的AOP实现，允许开发者定义横切关注点，如日志、事务管理等，这些关注点可以跨多个对象透明地应用。 3. **容器（Container）**：...
spring的事物管理以及spring的两个动态代理
sssyyyy7的博客
04-19 293
注意有一点 : service层在调用的时候也就是事物管理的那个方法里不能用try{}catch(){} , 如果用了 ,异常被捕获了 , 事物管理就发现不了异常 ,也就不会进行回滚 还有个spring的动态代理提一下 spring的动态的代理模式有两种 JDK动态代理,基于接口(默认代理模式)，CGLIB动态代理（若要使用需要进行配置） 1.使用aop配置： <aop:config pr...
Spring事务实现原理—Aop以及动态代理
JFIA的博客
06-09 2036
Spring事务实现原理—Aop以及动态代理 Spring事务管理机制的实现原理是由Spring内置的AOP——默认使用动态代理模式实现的。 AOP Spring的两大核心之一就是AOP，AOP：面向切面编程。在说原理之前，得先知道一些 AOP的专业术语。 AOP的专业术语 连接点（JoinPoint）：增强执行的位置（增加代码的位置），Spring只支持方法； 切点（PointCut）：具体的连接点；一般可能通过一个表达式来描述； 增强（Advice）：也称为消息，指的是增加的额外的代码，Spring中，
浅析“代理模式”实现spring事务管理
json20080301
12-21 179
模拟用户调用： [code="java"] package bean.parterdesign.proxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public class Client { /** * @param args */ publi...
Spring--配置事务管理器
qq_35634418的博客
08-09 473
    &lt;!-- 添加事务 1.配置一个事务管理器 id一定要这么写，否则找不到该bean --&gt;     &lt;bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"&gt;         &lt;property name="dat...
动态代理实现事务控制—浅析aop原理
qq_43138206的博客
04-21 710
本人小白一枚，欢迎大家一起讨论学习，如有错误，还望大家指教。 在阐述Aop之前，我们先进行简单分析，在我们进行开发时，一个业务需求可能会去数据库进行多次操作，有时候我们需要保证一系列操作要么全部成功，要么全部失败，其实这个就是事务操作。现在我们开发一般都采用三层结构，如果我们控制事务的代码放在Dao对象中，在Dao对象的每个方法中去打开和关闭事务，当业务层调用Dao时，如果只调用一个Dao对象...
【设计模式】动态代理实现事物管理
邢美玲
04-04 254
代理模式的云里雾里
反射的初步应用——静态代理以及动态代理例子
suitianshuang
09-10 249
反射的应用：动态代理 动态代理，在编译时候不指明代理类，而在运行时确定。 静态代理：代理类和被代理类都是在编译期间就确定下来，这样不利于程序的拓展，同时每一个地阿里类只能为一个接口服务，这样一来程序开发必然会产生过多的代理，最好可以通过一个代理类完成全部的代理功能。 动态代理和静态代理相比的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样我们就可以更加灵活和统一的处理众多方法。 静态代理举例： package com.ntt.sts; import
Java 动态代理详解以及在Spring事务控制中的使用案例
IT_10的博客
01-04 301
准备前期代码 public interface IProducer { /** * 销售 * @param money */ public void saleProduct(float money); /** * 售后 * @param money */ public void afterProduct(...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值