JAVA编程118——事务控制/动态代理

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

一、目录结构

在这里插入图片描述

二、数据库结构及测试数据

在这里插入图片描述

三、代码详解

1、xml配置文件：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"
         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.mollen</groupId>
    <artifactId>exam</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.2</version>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>

        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.6</version>
        </dependency>
        
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <target>1.7</target>
                    <source>1.7</source>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
2、数据源配置文件：db.properties
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/my_db2
jdbc.user=root
jdbc.password=root
3、实体类：Account.java
package com.mollen.bean;

/**
 * @ClassName: Account
 * @Auther: Mollen
 * @CreateTime: 2018-11-06  11:53:29
 * @Description:
 */
public class Account {
    private int id;
    private String name;
    private double money;

    public Account() {
    }

    public Account(int id, String name, double money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
    
    //...getter/setter
}
4、dao层：

1、Dao接口：AccountDao.java

package com.mollen.dao;

import com.mollen.bean.Account;

/**
 * @ClassName: AccountDao
 * @Auther: Mollen
 * @CreateTime: 2018-11-06  11:55:11
 * @Description:
 */
public interface AccountDao {

    /**
     * 1.根据用户名查询账户信息
     * @return
     */
    public Account findByName(String name) throws Exception;

    /**
     * 2.更新账户信息
     */
    public void upDate(String name,double money) throws Exception;

}

2、Dao实现类:AccountDaoImpl.java

package com.mollen.dao.impl;

import com.mollen.bean.Account;
import com.mollen.dao.AccountDao;
import com.mollen.utils.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;

import java.sql.SQLException;

/**
 * @ClassName:  AccountDaoImpl
 * @Auther:     Mollen
 * @CreateTime: 2018-11-06  11:58:35
 * @Description:
 */
public class AccountDaoImpl implements AccountDao {

    QueryRunner queryRunner = new QueryRunner();

    public void setQueryRunner(QueryRunner queryRunner) {
        this.queryRunner = queryRunner;
    }

    /**
     * 1.根据用户名查询账户信息
     * @return
     */
    public Account findByName(String name) throws SQLException{
            return   queryRunner.query(JdbcUtils.getConnection(),"SELECT * FROM account WHERE name = ?",new BeanHandler<Account>(Account.class),name);
    }

    /**
     * 2.更新账户信息
     */
    public void upDate(String name,double money) throws SQLException{
            queryRunner.update(JdbcUtils.getConnection(),"UPDATE account SET money = ? WHERE name = ?",money,name);
    }

}
5、Service层：

1、Service层接口：AccountService.java

package com.mollen.service;

/**
 * @ClassName: AccountService
 * @Auther: Mollen
 * @CreateTime: 2018-11-06  14:13:50
 * @Description:
 */
public interface AccountService {

    /**
     * 转账业务
     * @param source
     * @param target
     * @param money
     * @throws Exception
     */
    public void transfer(String source,String target,double money) throws Exception;

}

2、Service接口实现类：AccountServiceImpl.java

package com.mollen.service.impl;

import com.mollen.bean.Account;
import com.mollen.dao.AccountDao;
import com.mollen.dao.impl.AccountDaoImpl;
import com.mollen.service.AccountService;

/**
 * @ClassName: AccountServiceImpl
 * @Auther: Mollen
 * @CreateTime: 2018-11-06  14:17:16
 * @Description:
 */
public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao = new AccountDaoImpl();

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

    public void transfer(String source, String target, double money) throws Exception {
        //1.查询转出账户的账户余额
        Account source_account = accountDao.findByName(source);
        //2.转出账户的余额减少
        source_account.setMoney(source_account.getMoney()-money);
        //3.修改转出账户余额
        accountDao.upDate(source,source_account.getMoney());

        //手动抛出异常
        //int i = 10 /0 ;

        //1.查询转入账户的余额
        Account target_account = accountDao.findByName(target);
        //2.转入账户余额增加
        target_account.setMoney(target_account.getMoney()+money);
        //3.修改转入账户的余额
        accountDao.upDate(target,target_account.getMoney());

    }
}

6、创建jdbc工具类：JdbcUtils.java

package com.mollen.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.beans.PropertyVetoException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

/**
 * @ClassName:  JdbcUtils
 * @Auther:     Mollen
 * @CreateTime: 2018-11-06  14:49:43
 * @Description:
 *
 */
public class JdbcUtils {

    //1.创建线程标志对象存储对象(保证事务过程中用的是同一个连接)
    private static ThreadLocal<Connection> threadLocal = new InheritableThreadLocal<>();

    //3.获取线程池连接对象
    public static Connection getConnection(){
        //获取标志
        Connection connection = threadLocal.get();
        try {
            if (connection == null) {
                connection  = JdbcUtils.getDataSource().getConnection();
                //存入标志
                threadLocal.set(connection);
            }
            return connection;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //4.获取数据源
    public static DataSource getDataSource() throws IOException, PropertyVetoException {

        ComboPooledDataSource dataSource = new ComboPooledDataSource();

        Properties properties = new Properties();
        InputStream is = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
        properties.load(is);

        dataSource.setDriverClass(properties.getProperty("jdbc.driverClass"));
        dataSource.setJdbcUrl(properties.getProperty("jdbc.jdbcUrl"));
        dataSource.setUser(properties.getProperty("jdbc.user"));
        dataSource.setPassword(properties.getProperty("jdbc.password"));

        return dataSource;
    }

    //5.解除线程与连接绑定
    public static void remove(){
        threadLocal.remove();
    }
}

7、创建事务类：TransactionManager.java

package com.mollen.utils;

import java.sql.SQLException;

/**
 * @ClassName: TransactionManager
 * @Auther: Mollen
 * @CreateTime: 2018-11-06  14:49:58
 * @Description:
 */
public class TransactionManager {

    /**
     * 1.开启事务
     */
    public static void startTransaction(){
        try {
            JdbcUtils.getConnection().setAutoCommit(false);
            System.out.println("事务开启！");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 2.提交事务
     */
    public static void commitTransaction(){
        try {
            JdbcUtils.getConnection().commit();
            System.out.println("事务提交！");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /**
     * 3.回滚事务
     */
    public static void rollbackTransaction(){
        try {
            JdbcUtils.getConnection().rollback();
            System.out.println("事务回滚！");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 4.关闭连接
     */
    public static void close(){
        try {
            JdbcUtils.getConnection().close();
            System.out.println("连接关闭！");
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
}

8、创建动态代理测试类

package com.mollen.test;

import com.mollen.service.AccountService;
import com.mollen.service.impl.AccountServiceImpl;
import com.mollen.utils.TransactionManager;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


/**
 * @ClassName: MyTest
 * @Auther: Mollen
 * @CreateTime: 2018-11-06  18:41:31
 * @Description:
 */

public class MyTest {
    AccountService accountService = new AccountServiceImpl();


    /**
     * 1、第一种方案：Jdk动态代理方式进行事务控制 --> 真实对象必须实现接口
     */
    @Test
    public void transfer1() {
        /**
         *  ClassLoader loader, 真实对象的类加载器
         *  Class<?>[] interfaces, 真实对象实现的所有接口
         *  InvocationHandler h  代理对象的处理类
         */
        AccountService accountService_proxy = (AccountService) Proxy.newProxyInstance(
                accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 调用代理对象任意方法,InvocationHandler中的invoke()都会执行
                     * @param proxy  代理对象
                     * @param method 代理对象调用的方法
                     * @param args  代理对象调用方法时掺入的参数
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //声明一个事务执行结果
                        Object obj = null;
                        try {
                            //1.开启事务--业务执行之前
                            TransactionManager.startTransaction();
                            //2.执行业务--执行业务操作
                            obj = method.invoke(accountService, args);
                            //3.提交事务--业务正常执行
                            TransactionManager.commitTransaction();
                        } catch (Exception e) {
                            e.printStackTrace();
                            //4.回滚事务--业务执行异常
                            TransactionManager.rollbackTransaction();
                        } finally {
                            //5.关闭连接
                            TransactionManager.close();
                        }
                        return obj;
                    }
                });
        try {
            accountService_proxy.transfer("aaa", "bbb", 100);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 2、第二种方案：使用cglib动态代理技术
     */
    @Test
    public void transfer2() {
        //1. 创建cglib的核心对象
        Enhancer enhancer = new Enhancer();
        //2. 设置产生的代理对象的父类
        enhancer.setSuperclass(accountService.getClass());
        //3. 设置调用代理对象的回调函数
        enhancer.setCallback(new MethodInterceptor() {
            /**
             *
             * @param proxy  代理对象
             * @param method 代理对象执行的方法
             * @param args   代理对象调用方法时传入的参数
             * @param methodProxy  调用方法的代理对象  一般没什么用
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                Object obj = null;
                try {
                    //1. 在转账业务执行之前  开启事物
                    TransactionManager.startTransaction();
                    //2. 执行原有的转账业务
                    obj = method.invoke(accountService, args);
                    //3. 转账业务执行成功-- 提交事物
                    TransactionManager.commitTransaction();
                } catch (Exception e) {
                    e.printStackTrace();
                    //4. 转账业务执行失败---回滚事物
                    TransactionManager.rollbackTransaction();
                } finally {
                    TransactionManager.close();
                }
                return obj;
            }
        });
        AccountService accountService_proxy = (AccountService) enhancer.create();
        try {
            accountService_proxy.transfer("aaa", "bbb", 100);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 3、第三种方案：使用cglib动态代理技术第二种方式
     */
    @Test
    public void transfer3() {

        AccountService accountService_proxy = (AccountService) Enhancer.create(
                accountService.getClass(),
                new MethodInterceptor() {
                    /**
                     *
                     * @param proxy  代理对象
                     * @param method 代理对象执行的方法
                     * @param args   代理对象调用方法时传入的参数
                     * @param methodProxy  调用方法的代理对象  一般没什么用
                     * @return
                     * @throws Throwable
                     */
                    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

                        Object obj = null;
                        try {
                            //1. 在转账业务执行之前  开启事物
                            TransactionManager.startTransaction();
                            //2. 执行原有的转账业务
                            obj = method.invoke(accountService, args);
                            //3. 转账业务执行成功-- 提交事物
                            TransactionManager.commitTransaction();
                        } catch (Exception e) {
                            e.printStackTrace();
                            //4. 转账业务执行失败---回滚事物
                            TransactionManager.rollbackTransaction();
                        } finally {
                            TransactionManager.close();
                        }
                        return obj;
                    }
                });
        try {
            accountService_proxy.transfer("aaa", "bbb", 100);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
阔皮大师
关注
专栏目录
【JAVA高级】——吃透JDBC中的事务及事务的封装
不迁怒，不贰过。小知识，大智慧。
11-01 6518
吃透JDBC中的事务及事务的封装
Java 多线程事务回滚 ——多线程插入数据库时事务控制
热门推荐
shehuinidaye的博客
04-18 2万+
背景 日常项目中，经常会出现一个场景，同时批量插入数据库数据，由于逻辑复杂或者其它原因，我们无法使用sql进行批量插入，这个时候我们首先想到多线程并发插入，但是如何控制事务呢 … 直接上干货 实现效果 开启多条子线程，并发插入数据库 当其中一条线程出现异常，或者处理结果为非预期结果，则全部线程均回滚 代码实现 @Service public class CompanyUserBatchServ...
java事务 - 使用动态代理
09-13
使用动态代理控制事务,代码更加简洁、清爽
Java事务之六——使用动态代理(Dynamic Proxy)
weixin_34007886的博客
02-24 168
　　在本系列的上一篇文章中，我们讲到了使用Template模式进行事务管理，这固然是一种很好的方法，但是不那么完美的地方在于我们依然需要在service层中编写和事务处理相关的代码，即我们需要在service层中声明一个TransactionTemplate。在本篇文章中，我们将使用Java提供的动态代理（Dynamic Proxy）功能来完成事务处理，你将看到无论是在service层还是DAO层...
Java事务处理全解析（六）—— 使用动态代理（Dynamic Proxy）完成事务
low_coder
12-02 1076
在本系列的上一篇文章中，我们讲到了使用Template模式进行事务管理，这固然是一种很好的方法，但是不那么完美的地方在于我们依然需要在service层中编写和事务处理相关的代码，即我们需要在service层中声明一个TransactionTemplate。在本篇文章中，我们将使用Java提供的动态代理（Dynamic Proxy）功能来完成事务处理，你将看到无论是在service层还是DAO层都不
JAVA编程119——事务控制/动态代理/代码优化
mollen的博客
11-07 234
一、优化方案：将代理类单独抽取出来封装成为一个代理工厂 package com.mollen.config; import com.mollen.utils.TransactionManager; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib...
计算机软件开发的Java编程语言及应用——评《Java编程方法论》.pdf
03-08
【Java编程语言特点】 Java编程语言是面向对象的高级编程语言，它的主要特点包括： 1. **操作灵活性**：Java的语法简洁且易于理解，它允许程序员以更少的代码实现复杂的逻辑，降低了编程的复杂性，提高了开发效率...
Java 代理 代理模式 静态代理与动态代理 常见的动态代理实现 .md
最新发布
08-11
Spring框架广泛使用了动态代理技术来实现面向切面编程(AOP)。通过Spring AOP，开发人员可以在不修改业务代码的情况下添加日志记录、事务管理等功能。Spring AOP支持基于JDK Proxy和CGLIB的动态代理。 - **基于JDK ...
java动态代理处理事务
csdn_meng的博客
11-02 1万+
·动态代理模型· 有如下UserManage接口：public interface UserManager{ //增加用户接口 public void addUser(User user); //删除用户 public void deleteUser(String userId); //修改用户 public void updateUser(User
java事物代理
u010256177的专栏
12-29 673
package cn.itcast.utils; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.Connection; import javax.ejb.TransactionAttribute;
编程式事务 (Java)
AKALXH的博客
04-15 5134
编程式事务可以支持编程式事务和声明式事务。提供的最原始的事务管理方式是基于编程式事务。而的编程式事务管理是使用模板方法设计模式对原始事务管理方式的封装。编程式事务是一种在数据库操作中使用的事务处理方式，通过编写程序来控制事务的提交或回滚。与声明式事务相比，编程式事务需要手动指定事务的启动、提交和回滚等操作，具有更精细的控制能力。编程式事务可以根据业务逻辑和数据操作的复杂度进行灵活的控制和处理，保证数据的一致性和完整性；编程式事务代码可以直接显示了事务的边界和执行顺序，方便理解和调试；
Java连载118-编译一个类（包括内部函数、方法、类型、参数）
weixin_44630050的博客
05-27 180
一、反编译一个类（包括内部函数、方法、类型、参数） package com.bjpowernode.java_learning; ​ public class D118_CustomerService { public boolean login(String name,String pwd) { if("admin".contentEquals(name) && "123".contentEquals(pwd)) { return true; }
7.基于java的动态代理来管理事务
weixin_44853600的博客
05-19 337
1.what 通过一个动态代理的对象，来执行原对象的方法 动态：可以通过反射来执行原对象的不同方法 代理：可以在代理对象中添加增强代码 2.why 通过动态代理，可以向原对象中不同方法添加所需一样的代码（如：上节的事务管理）。提高代码的可读性 3.code 基于接口的动态代理 1. 模拟一个消费者 */ public class Client { public static void main(String[] args) { final Producer producer
Java中处理事务的代理Proxy模式
zhou363667565的专栏
07-10 443
我们知道,在Hibernate中除开查询数据之外.对数据库进行,添加,修改,删除数据的时,需要对事务的手动提交. 在session对数据保存数据时,都需要手动开启事务,这样的操作非常的繁琐. 所以,我们决定使用Proxy类.去帮助我们处理,这样的操作.   Transaxtion tx = session.beginTransaction(); session.save(obj); t...
java 编程式事务_编程式事务管理
weixin_34151005的博客
02-19 332
### 手动完成事务管理```通过手动编写代码的方式完成事务的管理(不推荐)```### TransactionTemplate```为了简化事务管理的代码:提供了模板类 TransactionTemplate```### 手动完成事务管理的步骤```1. 配置事务管理器，Spring使用PlatformTransactionManager接口来管理事务，所以咱们需要使用到他的实现类``````2...
java中数据库事务和代理(初级)
Asinios的专栏
07-05 256
1.事务 引入案例：银行转账 A账户给B账户转账 如果转账中出现异常，事务就必须停止，且回滚。也就是转账过程，要么全部成功，要么全部失败，所以必须放在同一个事务 然而，Connection默认是事务自动提交的，要在同一个事务中操作，就必须多个关于数据的操作必须是同一个连接 保证操作中是同一个Connection就需要设置ThreadLocal操作 结...
Java中的事务
qq_39889242的博客
08-10 752
到处抄的，有问题评论写一下。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值