通过AOP和IOC改造银行转账案例

亦凉 2022-12-02 12:29 115阅读 0赞

# 1 银行转账案例界面 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

#  2 表结构 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1][]

# 3 代码调用关系 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2][]

# 4 关键代码 #

（1）TransferServlet

@WebServlet(name = "transferServlet", urlPatterns = "/transferServlet")
    public class TransferServlet extends HttpServlet {
        // 1. 实例化service层对象（需要被改造）
        private TransferService transferService = new TransferServiceImpl();
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp)
             throws ServletException, IOException {
             doPost(req, resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse
                resp) throws ServletException, IOException {
            // 设置请求体的字符编码
            req.setCharacterEncoding("UTF-8");
            String fromCardNo = req.getParameter("fromCardNo");
            String toCardNo = req.getParameter("toCardNo");
            String moneyStr = req.getParameter("money");
            int money = Integer.parseInt(moneyStr);
            Result result = new Result();
            try {
                  // 2. 调⽤service层⽅法
                  transferService.transfer(fromCardNo, toCardNo, money);
                  result.setStatus("200");
            } catch (Exception e) {
                  e.printStackTrace();
                  result.setStatus("201");
                  result.setMessage(e.toString());
            }
            // 响应
            resp.setContentType("application/json;charset=utf-8");
            resp.getWriter().print(JsonUtils.object2Json(result));
        }
    }

（2）TransferService 的实现类

public class TransferServiceImpl implements TransferService {
    
        // 需要被改造，当 AccountDao 的实现类发生了切换，这里的代码也要跟着改动了 
        private AccountDao accountDao = new JdbcAccountDaoImpl();
    
        /**
         * 没有加事务控制
         */
        @Override
        public void transfer(String fromCardNo, String toCardNo, int money)
            throws Exception {
            Account from = accountDao.queryAccountByCardNo(fromCardNo);
            Account to = accountDao.queryAccountByCardNo(toCardNo);
            from.setMoney(from.getMoney()-money);
            to.setMoney(to.getMoney()+money);
            accountDao.updateAccountByCardNo(from);
            accountDao.updateAccountByCardNo(to);
        }
    }

（3）AccountDao 基于 JDBC 的实现类

public class JdbcAccountDaoImpl implements AccountDao {
    
        @Override
        public Account queryAccountByCardNo(String cardNo) throws Exception {
            //从连接池获取连接
            Connection con = DruidUtils.getInstance().getConnection();
            String sql = "select * from account where cardNo=?";
            PreparedStatement preparedStatement = con.prepareStatement(sql);
            preparedStatement.setString(1,cardNo);
            ResultSet resultSet = preparedStatement.executeQuery();
            Account account = new Account();
            while(resultSet.next()) {
                account.setCardNo(resultSet.getString("cardNo"));
                account.setName(resultSet.getString("name"));
                account.setMoney(resultSet.getInt("money"));
            }
            resultSet.close();
            preparedStatement.close();
            con.close();
            return account;
        }
    
        @Override
        public int updateAccountByCardNo(Account account) throws Exception {
            //从连接池获取连接
            Connection con = DruidUtils.getInstance().getConnection();
            String sql = "update account set money=? where cardNo=?";
            PreparedStatement preparedStatement = con.prepareStatement(sql);
            preparedStatement.setInt(1,account.getMoney());
            preparedStatement.setString(2,account.getCardNo());
            int i = preparedStatement.executeUpdate();
            preparedStatement.close();
            con.close();
            return i;
        }
    }

# 5 问题分析 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3][]

#  #

> **问题⼀：**
> 
> 在上述案例实现中，service 层实现类在使⽤ dao 层对象时，直接在 TransferServiceImpl 中通过 AccountDao accountDao = new JdbcAccountDaoImpl() 获得了 dao层对象，然⽽⼀个 new 关键字却将 TransferServiceImpl 和 dao 层具体的⼀个实现类 JdbcAccountDaoImpl 耦合在了⼀起，如果技术架构发⽣变动，dao 层的实现要使⽤其它技术， ⽐如 Mybatis，思考切换起来的成本？每⼀个 new 的地⽅都需要修改源代码，重新编译，⾯向接⼝开发的意义将⼤打折扣。
> 
> **问题⼆：**
> 
> service 层代码没有进⾏事务控制 ！如果转账过程中出现异常，将可能导致数据库数据错乱，后果可能会很严重，尤其在⾦融业务。

# 6 问题解决思路 #

## 6.1 问题一解决思路 ##

（1）实例化对象的⽅式除了  new  之外，还有什么技术？反射  ( 需要把类的全限定类名配置在  xml)

（2） 考虑使⽤设计模式中的⼯⼚模式解耦合，在⼯⼚中使 ⽤反射技术实例化对象。以后需要什么对象，就直接去工厂取。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4][]

（3）进一步优化：代码中能否只声明所需实例的接⼝类型，不出现 new 也不出现⼯⼚类的字眼？能的！声明⼀个变量并提供 set ⽅法，在反射的时候通过 set 方法注入所需要的对象。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5][]

## 6.2 问题二解决思路 ##

service 层没有添加事务控制，出现异常会导致数据错乱。

**分析：**数据库事务归根结底是 Connection 的事务，Connection 默认开启了事务自动提交。

> connection.commit()
> 
> connection.rollback()

![20200831072514302.png][]

（1）两次 update 使用了两个数据库连接 Connection，导致不属于同一个事务控制。

（2）事务控制在 Dao 层，没有控制在 Service 层

**解决思路：**

（1）让两次 update 使用同一个数据库连接 Connection。因为两次 update 属于同一个线程内的执行调用，可以给当前线程绑定一个 Connection，和当前线程有关的数据库操作都使用该 Connection。

（2）把事务控制添加在 service 层

# 7 代码改造 #

## 7.1 针对问题一的代码改造 ##

（1）beans.xml

（2）BeanFactory 生产对象

加载 BeanFactory 时，先执行 static 代码块，加载解析xml中bean的信息，通过反射技术实例化bean对象，然后放入map中待用。

提供方法供外部根据id获取bean。维护bean的依赖关系，调用set方法传值。

/**
     * 工厂类，生产对象（使用反射技术）
     */
    public class BeanFactory {
    
        /**
         * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
         * 任务二：对外提供获取实例对象的接口（根据id获取）
         */
    
        private static Map<String,Object> map = new HashMap<>();  // 存储对象
    
    
        static {
            // 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
            // 加载xml，以字节流的形式加载到内存
            InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
            // 解析xml
            SAXReader saxReader = new SAXReader();
            try {
                Document document = saxReader.read(resourceAsStream);
                Element rootElement = document.getRootElement();
                List<Element> beanList = rootElement.selectNodes("//bean");
                for (int i = 0; i < beanList.size(); i++) {
                    Element element =  beanList.get(i);
                    // 处理每个bean元素，获取到该元素的 id 和 class 属性
                    String id = element.attributeValue("id");        
                    String clazz = element.attributeValue("class");  
                    // 通过反射技术实例化对象
                    Class<?> aClass = Class.forName(clazz);
                    Object o = aClass.newInstance();  // 实例化之后的对象
                    // 存储到map中待用
                    map.put(id,o);
    
                }
    
                // 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
                // 有 property 子元素的 bean 就有传值需求
                List<Element> propertyList = rootElement.selectNodes("//property");
                // 解析 property，获取父元素
                for (int i = 0; i < propertyList.size(); i++) {
                    //<property name="AccountDao" ref="accountDao"></property>
                    Element element =  propertyList.get(i);   
                    String name = element.attributeValue("name");
                    String ref = element.attributeValue("ref");
    
                    // 找到当前需要被处理依赖关系的bean
                    Element parent = element.getParent();
    
                    // 调用父元素对象的反射功能
                    String parentId = parent.attributeValue("id");
                    Object parentObject = map.get(parentId);
                    // 遍历父对象中的所有方法，找到 "set" + name
                    Method[] methods = parentObject.getClass().getMethods();
                    for (int j = 0; j < methods.length; j++) {
                        Method method = methods[j];
                        // 该方法就是 setAccountDao(AccountDao accountDao)
                        if(method.getName().equalsIgnoreCase("set" + name)) {  
                            method.invoke(parentObject,map.get(ref));
                        }
                    }
                    // 把处理之后的parentObject重新放到map中
                    map.put(parentId,parentObject);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } 
        }
    
        // 任务二：对外提供获取实例对象的接口（根据id获取）
        public static  Object getBean(String id) {
            return map.get(id);
        }
    
    }

（3）改造 TransferServlet

//private TransferService transferService = new TransferServiceImpl();
    private TransferService transferService = (TransferService) BeanFactory.getBean("transferService");

（4）改造 TransferServiceImpl

// private AccountDao accountDao = new JdbcAccountDaoImpl();
    // private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
    
    private AccountDao accountDao;
    // 构造函数传值/set方法传值
    public void setAccountDao(AccountDao accountDao) {
           this.accountDao = accountDao;
    }

## 7.2 针对问题二的代码改造 ##

### 7.2.1 改造一 ###

（1）Dao 层，从当前线程获取绑定的 connection 连接

public int updateAccountByCardNo(Account account) throws Exception {
            // 从连接池获取连接 Connection con = DruidUtils.getInstance().getConnection();
            // 改造为：从当前线程当中获取绑定的 connection 连接
            Connection con = ConnectionUtils.getInstance().getCurrentThreadConn();
            String sql = "update account set money=? where cardNo=?";
            PreparedStatement preparedStatement = con.prepareStatement(sql);
            preparedStatement.setInt(1,account.getMoney());
            preparedStatement.setString(2,account.getCardNo());
            int i = preparedStatement.executeUpdate();
    
            preparedStatement.close();
            //不用关闭了，不然别的方法用不了了 
            //con.close();
            return i;
    }

（2）ConnectionUtils 保证一个线程只有一个连接

public class ConnectionUtils {
    
        private ConnectionUtils() {}
    
        // 单例模式，构造函数私有化
        private static ConnectionUtils connectionUtils = new ConnectionUtils();
    
        public static ConnectionUtils getInstance() {
            return connectionUtils;
        }
    
        // 存储当前线程的连接
        private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); 
    
        /**
         * 从当前线程获取连接
         */
        public Connection getCurrentThreadConn() throws SQLException {
            /**
             * 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取一个连接绑定到当前线程
              */
            Connection connection = threadLocal.get();
            if(connection == null) {
                // 从连接池拿连接并绑定到线程
                connection = DruidUtils.getInstance().getConnection();
                // 绑定到当前线程
                threadLocal.set(connection);
            }
            return connection;
        }
    }

（3）service 层添加事务

public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {
    
          //Connection connection = ConnectionUtils.getInstance().getCurrentThreadConn();
    
          try{
                // 开启事务（关闭自动提交事务）
                //connection.setAutoCommit(false);
                TransactionManager.getInstance().beginTransaction();
    
                Account from = accountDao.queryAccountByCardNo(fromCardNo);
                Account to = accountDao.queryAccountByCardNo(toCardNo);
                from.setMoney(from.getMoney()-money);
                to.setMoney(to.getMoney()+money);
                accountDao.updateAccountByCardNo(to);
                int c = 1/0;
                accountDao.updateAccountByCardNo(from);
    
                // 提交事务（正常执行）
                //connection.commit();
                TransactionManager.getInstance().commit();
          }catch (Exception e) {
                e.printStackTrace();
                // 回滚事务（发生异常）
                //connection.rollback();
                TransactionManager.getInstance().rollback();
                // 抛出异常便于上层servlet捕获
                throw e;
         }
    }

（4）增加 TransactionManager 事务管理器类**，**把事务的管理放在一个类里

/**
     *
     * 事务管理器类：负责手动事务的开启、提交、回滚
     */
    public class TransactionManager {
    
        private ConnectionUtils connectionUtils;
    
        public void setConnectionUtils(ConnectionUtils connectionUtils) {
            this.connectionUtils = connectionUtils;
        }
    
        // 单例模式
        private TransactionManager(){}
    
        private static TransactionManager transactionManager = new TransactionManager();
    
        public static TransactionManager getInstance() {
            return  transactionManager;
        }
    
        // 开启手动事务控制
        public void beginTransaction() throws SQLException {
            connectionUtils.getCurrentThreadConn().setAutoCommit(false);
        }
    
        // 提交事务
        public void commit() throws SQLException {
            connectionUtils.getCurrentThreadConn().commit();
        }
    
        // 回滚事务
        public void rollback() throws SQLException {
            connectionUtils.getCurrentThreadConn().rollback();
        }
    }

思考：如果有 service层的上千百万个类的上千百万个方法都要加事务，咋办？用动态代理，把事务逻辑代码和业务逻辑代码分离。

### 7.2.2 改造二 ###

采用动态代理改造 Service 层事务控制

[磨人的动态代理][Link 1]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6][]

（1）代理对象工厂 ProxyFactory

/**
     * 代理对象工厂：生成代理对象的
     */
    
    public class ProxyFactory {
    
        private ProxyFactory(){}
    
        private static ProxyFactory proxyFactory = new ProxyFactory();
    
        public static ProxyFactory getInstance() {
            return proxyFactory;
        }
    
        /**
         * Jdk动态代理
         * @param obj  委托对象
         * @return   代理对象
         */
        public Object getJdkProxy(Object obj) {
    
            // 获取代理对象
            return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
                    new InvocationHandler() {
                        @Override
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                            Object result = null;
                            try{
                                // 开启事务(关闭事务的自动提交)
                                transactionManager.beginTransaction();
    
                                result = method.invoke(obj,args);
    
                                // 提交事务
    
                                transactionManager.commit();
                            }catch (Exception e) {
                                e.printStackTrace();
                                // 回滚事务
                                transactionManager.rollback();
    
                                // 抛出异常便于上层servlet捕获
                                throw e;
    
                            }
                             return result;
                        }
                    });
    
        }
    
        /**
         * 使用cglib动态代理生成代理对象
         * @param obj 委托对象
         * @return
         */
        public Object getCglibProxy(Object obj) {
            return  Enhancer.create(obj.getClass(), new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    Object result = null;
                    try{
                        // 开启事务(关闭事务的自动提交)
                        transactionManager.beginTransaction();
                        result = method.invoke(obj,objects);
                        // 提交事务
                        transactionManager.commit();
                    }catch (Exception e) {
                        e.printStackTrace();
                        // 回滚事务
                        transactionManager.rollback();
                        // 抛出异常便于上层servlet捕获
                        throw e;
                    }
                    return result;
                }
            });
        }
    }

（2）TransferServlet 改为依赖代理类

// 1. 实例化service层对象
    //private TransferService transferService = new TransferServiceImpl();
    //private TransferService transferService = (TransferService) BeanFactory.getBean("transferService");
    
    // 从工厂中获取代理service的对象
    private TransferService transferService = (TransferService) ProxyFactory.getInstance().getJdkProxy(BeanFactory.getBean("transferService")) ;

### 7.2.3 改造三 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7][]

把依赖都配置到xml，把实例化交给 BeanFactory

<bean id="connectionUtils" class="com.utils.ConnectionUtils"></bean>
    
    
    <bean id="transactionManager" class="com.utils.TransactionManager">
         <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>
    
    
    <bean id="proxyFactory" class="com.factory.ProxyFactory">
         <property name="TransactionManager" ref="transactionManager"/>
    </bean>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: /images/20221123/db0c98373ecf492090dbc461bb37e862.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1]: /images/20221123/88be717988c342128bd5e53cb105425a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2]: /images/20221123/d773b546c6e24603b3a1cb17aa30b194.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3]: /images/20221123/8b748a6c292648ee9a83e83a30106dcd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4]: /images/20221123/c371c556c44049ab92a0b44514a2e695.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5]: /images/20221123/5fd95107c92b4685b58a5a0b71893c57.png
[20200831072514302.png]: /images/20221123/d583ea5ebf304bd9adf73bfa7d9c1776.png
[Link 1]: https://xiangou.blog.csdn.net/article/details/108187684
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6]: /images/20221123/a219a21c1238488e9f099ecb7e55bc83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7]: /images/20221123/bf2e52ee46ba4b17b7523c42b0128945.png