Spring（五）转账问题引发的事务控制 && 通过动态代理不断的优化

Bertha 。 2021-06-22 15:37 299阅读 0赞

### 目录 ###

*  一、添加的转账功能
 *   *  1. 转账业务面临的问题
     *  2. 编写ConnectionUtils
     *  3. 编写事务管理工具类
     *  4. 编写业务层和持久层事务控制代码并配置spring的ioc
     *  5. 测试一下
 *  二、动态代理
 *   *  1. 基于接口的动态代理
     *  2. 基于子类的动态代理
 *  三、使用动态代理实现事务控制
 *   *  1. 创建一个BeanFactory：
     *  2. 修改Service实现类中的代码，我们可以看到，简洁了很多：
     *  3. \*\*\`bean.xml\`：\*\*
     *  4. 测试类：

# 一、添加的转账功能 #

## 1. 转账业务面临的问题 ##

我们在之前的案例中，略做拓展。  
我们想添加一个转账的业务逻辑，

![在这里插入图片描述][20200512141720692.png]  
**那么在service接口中，我们添加对应的方法：**

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

**service实现类中，也给出具体的实现方法：**

@Override
    public void transfer(String sourceName, String targetName, Float money) { 
        // 1.根据名称查询转出账户
        Account source = accountDao.findAccountByName(sourceName);
        // 2.根据名称查询转入账户
        Account target = accountDao.findAccountByName(targetName);
        // 3.转出账户减钱
        source.setMoney(source.getMoney() - money);
        // 4.转入账户加钱
        target.setMoney(target.getMoney() + money);
        // 5.更新转出账户
        accountDao.updateAccount(source);
        // 6.更新转入账户
        accountDao.updateAccount(target);
    }

我们可以看到，我们还需要accountDao提供一个新的方法，根据账户名称查询账户，  
**持久层接口：**

/** * 根据账户名称查询账户 * * @param accountName * @return 如果有唯一的一个结果，就返回；如果没有结果就返回null；如果结果集超过1个，就抛出异常 */
    Account findAccountByName(String accountName);

**持久层实现类方法：**

@Override
    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 (SQLException e) { 
            throw new RuntimeException(e);
        }
    }

**接下来，我们测试一下这个方法：**  
我们先看一下原本数据库的数据：  
![在这里插入图片描述][20200512115229427.png]  
我们运行这个方法：

@Test
    public void testTransfer() { 
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService accountService = (IAccountService) ac.getBean("accountService");
        accountService.transfer("aaa", "bbb", 100f);
    }

新的数据结果：  
![在这里插入图片描述][20200512115311396.png]  
现在来看，好像是没有什么问题的。

可是我们做一个假设，如果在转账的中间出现了问题，出现了异常会怎么办？  
例如，我们模拟一下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]

我们再次执行这个程序，可以预见的是，上面在更新完转出账户之后，程序必然会抛出一个异常，然后后面的程序就终止了，这样就会有很大的问题，而且我们打开数据库：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]  
你会不会想到这是因为没有使用事务的原因呢？  
但是显然不是，因为如果我们没有使用事务，我们前面做的增删改操作都不会有作用，可是我们的代码是没有问题的。  
这是怎么回事呢？  
这是因为每一次的Dao方法执行，都会获取一个新的连接，也会自动提交一次，，这样前面的都提交了，最后一个在执行之前却遇到了异常，没有能够执行提交。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]

怎么解决呢？我们的设想应该是，一个service方法，应该共享一个连接，使用一个事务。  
我们进行一些改造。

## 2. 编写ConnectionUtils ##

package com.veeja.utils;
    
    import javax.sql.DataSource;
    import java.sql.Connection;
    
    /** * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定 */
    public class ConnectionUtils { 
    
        private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    
        private DataSource dataSource;
    
        public void setDataSource(DataSource dataSource) { 
            this.dataSource = dataSource;
        }
    
        /** * 获取当前线程上的连接 */
        public Connection getThreadConnection() { 
            // 1.先从ThreadLocal上获取
            Connection connection = tl.get();
            try { 
                // 2.判断当前线程上是否有连接
                if (connection == null) { 
                    // 3.从数据源中获取一个连接，并且存入ThreadLocal中
                    connection = dataSource.getConnection();
                    tl.set(connection);
                }
                // 4.返回当前线程上的连接
                return connection;
            } catch (Exception e) { 
                throw new RuntimeException(e);
            }
        }
    
        /** * 把连接和线程解绑 */
        public void removeConnection() { 
            tl.remove();
        }
    }

## 3. 编写事务管理工具类 ##

package com.veeja.utils;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    
    /** * 和事务管理相关的工具类 * 它包含了：开启事务，提交事务，回滚事务和释放连接 * * @author veeja */
    public class TransactionManager { 
    
        private ConnectionUtils 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();
            }
        }
    }

## 4. 编写业务层和持久层事务控制代码并配置spring的ioc ##

业务层代码，**`AccountServiceImpl`** ：

package com.veeja.service.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.domain.Account;
    import com.veeja.service.IAccountService;
    import com.veeja.utils.TransactionManager;
    
    import java.util.List;
    
    /** * 账户的业务层实现类 */
    public class AccountServiceImpl implements IAccountService { 
    
        private IAccountDao accountDao;
        private TransactionManager txManager;
    
        public void setTxManager(TransactionManager txManager) { 
            this.txManager = txManager;
        }
    
        public void setAccountDao(IAccountDao accountDao) { 
            this.accountDao = accountDao;
        }
    
        @Override
        public List<Account> findAllAccount() { 
            try { 
                // 1.开启事务
                txManager.beginTransaction();
                // 2.执行操作
                List<Account> accounts = accountDao.findAll();
                // 3.提交事务
                txManager.commit();
                // 4.返回结果
                return accounts;
            } catch (Exception e) { 
                // 5.回滚操作
                txManager.rollback();
                throw new RuntimeException(e);
            } finally { 
                // 6.释放连接
                txManager.release();
            }
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            try { 
                // 1.开启事务
                txManager.beginTransaction();
                // 2.执行操作
                Account account = accountDao.findAccountById(accountId);
                // 3.提交事务
                txManager.commit();
                // 4.返回结果
                return account;
            } catch (Exception e) { 
                // 5.回滚操作
                txManager.rollback();
                throw new RuntimeException(e);
            } finally { 
                // 6.释放连接
                txManager.release();
            }
        }
    
        @Override
        public void saveAccount(Account account) { 
            try { 
                // 1.开启事务
                txManager.beginTransaction();
                // 2.执行操作
                accountDao.saveAccount(account);
                // 3.提交事务
                txManager.commit();
            } catch (Exception e) { 
                // 5.回滚操作
                txManager.rollback();
            } finally { 
                // 6.释放连接
                txManager.release();
            }
        }
    
        @Override
        public void updateAccount(Account account) { 
            try { 
                // 1.开启事务
                txManager.beginTransaction();
                // 2.执行操作
                accountDao.updateAccount(account);
                // 3.提交事务
                txManager.commit();
            } catch (Exception e) { 
                // 5.回滚操作
                txManager.rollback();
                e.printStackTrace();
            } finally { 
                // 6.释放连接
                txManager.release();
            }
    
        }
    
        @Override
        public void deleteAccount(Integer accountId) { 
            try { 
                // 1.开启事务
                txManager.beginTransaction();
                // 2.执行操作
                accountDao.deleteAccount(accountId);
                // 3.提交事务
                txManager.commit();
            } catch (Exception e) { 
                // 5.回滚操作
                txManager.rollback();
                e.printStackTrace();
            } finally { 
                // 6.释放连接
                txManager.release();
            }
        }
    
        @Override
        public void transfer(String sourceName, String targetName, Float money) { 
            try { 
                // 1.开启事务
                txManager.beginTransaction();
                /* * 2.执行操作 * 2.1.根据名称查询转出账户 * 2.2.根据名称查询转入账户 * 2.3.转出账户减钱 * 2.4.转入账户加钱 * 2.5.更新转出账户 * 2.6.更新转入账户 */
                Account source = accountDao.findAccountByName(sourceName);
                Account target = accountDao.findAccountByName(targetName);
                source.setMoney(source.getMoney() - money);
                target.setMoney(target.getMoney() + money);
                accountDao.updateAccount(source);
                accountDao.updateAccount(target);
                // 3.提交事务
                txManager.commit();
            } catch (Exception e) { 
                // 5.回滚操作
                txManager.rollback();
            } finally { 
                // 6.释放连接
                txManager.release();
            }
        }
    }

持久层代码，**`AccountDaoImpl`** ：

package com.veeja.dao.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.domain.Account;
    import com.veeja.utils.ConnectionUtils;
    import org.apache.commons.dbutils.QueryRunner;
    import org.apache.commons.dbutils.handlers.BeanHandler;
    import org.apache.commons.dbutils.handlers.BeanListHandler;
    
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.List;
    
    /** * 账户的持久层实现类 */
    public class AccountDaoImpl implements IAccountDao { 
    
        private QueryRunner runner;
        private ConnectionUtils connectionUtils;
    
        public void setRunner(QueryRunner runner) { 
            this.runner = runner;
        }
    
        public void setConnectionUtils(ConnectionUtils connectionUtils) { 
            this.connectionUtils = connectionUtils;
        }
    
        @Override
        public List<Account> findAll() { 
            System.out.println("AccountDaoImpl.findAll()...");
            try { 
                return runner.query(connectionUtils.getThreadConnection(), "select * from account", new BeanListHandler<Account>(Account.class));
            } catch (Exception e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public Account findAccountById(Integer accountId) { 
            try { 
                return runner.query(connectionUtils.getThreadConnection(), "select * from account where id = ?",
                        new BeanHandler<Account>(Account.class), accountId);
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void saveAccount(Account account) { 
            try { 
                runner.update(connectionUtils.getThreadConnection(), "insert into account(name,money) values(?,?)",
                        account.getName(), account.getMoney());
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void updateAccount(Account account) { 
            try { 
                runner.update(connectionUtils.getThreadConnection(), "update account set name=?,money=? where id = ?",
                        account.getName(), account.getMoney(), account.getId());
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        public void deleteAccount(Integer accountId) { 
            try { 
                runner.update(connectionUtils.getThreadConnection(), "delete from account where id = ?", accountId);
            } catch (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    
        @Override
        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 (SQLException e) { 
                throw new RuntimeException(e);
            }
        }
    }

**`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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
        <bean id="accountService" class="com.veeja.service.impl.AccountServiceImpl">
            
            <property name="accountDao" ref="accountDao"></property>
            
            <property name="txManager" ref="txManager"></property>
        </bean>
    
        
        <bean id="accountDao" class="com.veeja.dao.impl.AccountDaoImpl">
            
            <property name="runner" ref="runner"/>
            
            <property name="connectionUtils" ref="connectionUtils"></property>
        </bean>
    
        
        <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.cj.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdatabase?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC"/>
            <property name="user" value="root"></property>
            <property name="password" value="0000"></property>
        </bean>
    
        
        <bean id="connectionUtils" class="com.veeja.utils.ConnectionUtils">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <bean id="txManager" class="com.veeja.utils.TransactionManager">
            
            <property name="connectionUtils" ref="connectionUtils"></property>
        </bean>
    
    </beans>

## 5. 测试一下 ##

我们再用刚才的方式，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]  
**我们把数据库的中aaa和bbb的money值都改为1000，**  
执行一下看一看：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 4]  
我们看到，程序报了异常，可是数据库中的金额都没有发生变化，算是解决了我们刚才的问题。

可是，现在的代码，变得有些臃肿了，业务层方法里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。  
如果我们此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还  
只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。  
这时候怎么办呢？

# 二、动态代理 #

## 1. 基于接口的动态代理 ##

**`IProducer` 接口：**

package com.veeja.proxy;
    
    /** * 对生产厂家的要求 * @Author veeja * 2020/5/12 17:50 */
    public interface IProducer { 
    
        /** * 销售 * * @param money */
        public void saleProduct(float money);
    
        /** * 售后服务 * * @param money */
        public void afterService(float money);
    }

**`Producer` 实现类：**

package com.veeja.proxy;
    
    /** * 一个生产者 * * @Author veeja * 2020/5/12 17:47 */
    public class Producer implements IProducer { 
        
        /** * 销售 * * @param money */
        @Override
        public void saleProduct(float money) { 
            System.out.println("销售产品，并拿到钱：" + money);
        }
    
        /** * 售后服务 * * @param money */
        @Override
        public void afterService(float money) { 
            System.out.println("提供售后服务，并拿到钱：" + money);
        }
    }

**`Client` 类：**

package com.veeja.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * 模拟一个消费者 * * @Author veeja * 2020/5/12 17:52 */
    public class Client { 
        public static void main(String[] args) { 
            Producer producer = new Producer();
    
            /* * 动态代理： * 特点：字节码随用随修改，随用随加载 * 作用：不修改源码的基础上对方法增强 * 分类： * 基于接口的动态代理 * 基于子类的动态代理 * * 基于接口的动态代理： * 涉及的类：Proxy * 提供者：JDK官方 * 如何创建代理对象： * 使用Proxy类中的newProxyInstance方法 * 创建代理对象的要求： * 被代理类最少实现一个接口，如果没有则不能使用 * newProxyInstance方法的参数： * ClassLoader:类加载器，用于加载代理对象字节码的，和代理对象使用相同的类加载器。固定写法。 * Class[]:字节码数组，用于让代理对象和被代理对象有相同的方法。固定写法。 * InvocationHandler:用于提供增强的方法。 * 它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。 * 这个接口的实现类是谁用谁书写。 */
    
            IProducer proxyProducer = (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                    producer.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        /** * * 作用：执行被代理对象的任何接口方法都会经过该方法 * @param proxy 代理对象的引用 * @param method 当前执行的方法 * @param args 当前执行方法所需的参数 * @return 和被代理对象方法有相同的返回值 * @throws Throwable */
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            // 提供增强的方法
                            Object returnValue = null;
                            // 1. 获取方法执行的参数
                            Float money = (Float) args[0];
                            // 2. 判断当前方法是不是销售
                            if ("saleProduct".equals(method.getName())) { 
                                returnValue = method.invoke(producer, money * 0.8f);
                            }
                            return returnValue;
                        }
                    }
            );
    
    
            proxyProducer.saleProduct(5000f);
        }
    }

## 2. 基于子类的动态代理 ##

**导入依赖坐标：**

<dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.1_3</version>
    </dependency>

**`Producer` 代码：**

package com.veeja.cglib;
    
    import com.veeja.proxy.IProducer;
    
    /** * 一个生产者 * * @Author veeja * 2020/5/12 17:47 */
    public class Producer { 
    
        /** * 销售 * * @param money */
        public void saleProduct(float money) { 
            System.out.println("销售产品，并拿到钱：" + money);
        }
    
        /** * 售后服务 * * @param money */
        public void afterService(float money) { 
            System.out.println("提供售后服务，并拿到钱：" + money);
        }
    }

**`Client` 代码：**

package com.veeja.cglib;
    
    import com.veeja.proxy.IProducer;
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * 模拟一个消费者 * * @Author veeja * 2020/5/12 17:52 */
    public class Client { 
        public static void main(String[] args) { 
            final Producer producer = new Producer();
    
            /* * 动态代理： * 特点：字节码随用随修改，随用随加载 * 作用：不修改源码的基础上对方法增强 * 分类： * 基于接口的动态代理 * 基于子类的动态代理 * 基于子类的动态代理： * 涉及的类：Enhancer * 提供者：第三方cglib库 * 如何创建代理对象： * 使用Enhancer类中的create方法 * 创建代理对象的要求： * 被代理类不能是final类 * create方法的参数： * Class:指定一个字节码，指定被代理对象的字节码 * callback:用于提供增强的方法。 * 它是让我们写如何代理。我们一般都是写一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。 * 我们一般写的都是该接口的子接口实现类：MethodInterceptor */
            Producer cglibProducer = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() { 
                /** * 执行被代理对象的任何方法都会经过该方法 * @param proxy * @param method * @param args * 上面三个参数的和基于接口的动态代理中invoke方法的参数是一样的 * @param methodProxy 当前执行方法的代理对象 * @return * @throws Throwable */
                @Override
                public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { 
                    // 提供增强的方法
                    Object returnValue = null;
                    // 1. 获取方法执行的参数
                    Float money = (Float) args[0];
                    // 2. 判断当前方法是不是销售
                    if ("saleProduct".equals(method.getName())) { 
                        returnValue = method.invoke(producer, money * 0.8f);
                    }
                    return returnValue;
                }
            });
            cglibProducer.saleProduct(10000f);
        }
    }

# 三、使用动态代理实现事务控制 #

我们根据上面的动态代理，是不是能解决一下我们事务控制里面遇到的问题呢？

## 1. 创建一个BeanFactory： ##

package com.veeja.factory;
    
    import com.veeja.service.IAccountService;
    import com.veeja.utils.TransactionManager;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    /** * 用于创建Service的代理对象的工厂 * * @Author veeja * 2020/5/13 0:38 */
    public class BeanFactory { 
    
        private IAccountService accountService;
        private TransactionManager txManager;
    
        public void setTxManager(TransactionManager txManager) { 
            this.txManager = txManager;
        }
    
        public final void setAccountService(IAccountService accountService) { 
            this.accountService = accountService;
        }
    
        /** * 获取Service代理对象 * * @return */
        public IAccountService getAccountService() { 
            return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                    accountService.getClass().getInterfaces(),
                    new InvocationHandler() { 
                        /** * 添加事务的支持 * * @param proxy * @param method * @param args * @return * @throws Throwable */
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
                            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();
                            }
                        }
                    });
        }
    }

## 2. 修改Service实现类中的代码，我们可以看到，简洁了很多： ##

## 3. **`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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
        <bean id="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>
    
        
        <bean id="beanFactory" class="com.veeja.factory.BeanFactory">
            
            <property name="accountService" ref="accountService"></property>
            
            <property name="txManager" ref="txManager"></property>
        </bean>
    
        
        <bean id="accountService" class="com.veeja.service.impl.AccountServiceImpl">
            
            <property name="accountDao" ref="accountDao"></property>
        </bean>
    
        
        <bean id="accountDao" class="com.veeja.dao.impl.AccountDaoImpl">
            
            <property name="runner" ref="runner"/>
            
            <property name="connectionUtils" ref="connectionUtils"></property>
        </bean>
    
        
        <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.cj.jdbc.Driver"></property>
            <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdatabase?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC"/>
            <property name="user" value="root"></property>
            <property name="password" value="0000"></property>
        </bean>
    
        
        <bean id="connectionUtils" class="com.veeja.utils.ConnectionUtils">
            
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <bean id="txManager" class="com.veeja.utils.TransactionManager">
            
            <property name="connectionUtils" ref="connectionUtils"></property>
        </bean>
    
    </beans>

## 4. 测试类： ##

/** * 使用Junit单元测试，测试我们的配置 */
    public class AccountServiceTest { 
        @Test
        public void testTransfer() { 
            ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
            IAccountService accountService = (IAccountService) ac.getBean("proxyAccountService");
            accountService.transfer("aaa", "bbb", 100f);
        }
    }

我们运行，发现：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 5]  
程序抛出了异常，但是账也没有转过去，完成了！

--------------------

end.

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 6]

[20200512141720692.png]: /images/20210615/70c95e7c4bda4f90919832e28f4e6f3f.png
[20200512115229427.png]: /images/20210615/2ab29e64dfc1412fbc01c6f457d0f351.png
[20200512115311396.png]: /images/20210615/a8a6f44ea4114bcbbaaafec42a710d6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20210615/a64adfda4dc94a2b8127dc091f8b8115.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20210615/74954f6d336743229dade60bb41aceb9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20210615/3fe4cf8f06b346b8b6c97c49bd10acc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]: /images/20210615/f5c53d1679be4139aaac03cf61f2bbef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 4]: /images/20210615/c610bef4102d42c9a1886fb5eb54e8b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 5]: /images/20210615/31e5f6d777b54785b16732dd98231380.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 6]: /images/20210615/4f10ff23b1fc428ab36404c267bf5901.png