Spring -- 手写 IOC 和 AOP

一、银行转账案例

先使用原始 servlet 方式模拟一个银行转账的功能，关键代码如下：

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

• TransferService 接口及实现类

  public interface TransferService {
      void transfer(String fromCardNo,String toCardNo,int money) throws Exception;
  }
  

  public class TransferServiceImpl implements TransferService {
  
      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(to);
              accountDao.updateAccountByCardNo(from);
      }
  }
  

• AccountDao 层接口及基于 JDBC 的实现类

  public interface AccountDao {
      Account queryAccountByCardNo(String cardNo) throws Exception;
      int updateAccountByCardNo(Account account) throws Exception;
  }
  

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

• 单例模式获取阿里巴巴德鲁伊数据源

  public class DruidUtils {
  
      private DruidUtils(){}
  
      private static DruidDataSource druidDataSource = new DruidDataSource();
  
      static {
          druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
          druidDataSource.setUrl("jdbc:mysql://localhost:3306/bank");
          druidDataSource.setUsername("root");
          druidDataSource.setPassword("123456");
      }
  
      public static DruidDataSource getInstance() {
          return druidDataSource;
      }
  
  }
  

二、银行转账功能问题分析

• 在上述案例实现中，service 层实现类在使用 dao 层对象时，直接在 TransferServiceImpl 中通过 AccountDao accountDao = new JdbcAccountDaoImpl()获得了 dao 层对象，然而⼀个 new 关键字却将 TransferServiceImpl 和 dao 层具体的⼀个实现类 JdbcAccountDaoImpl 耦合在了⼀起，如果说技术架构发生⼀些变动，dao 层的实现要使用其它技术，比如 Mybatis，那么每⼀个 new 的地方都需要修改源代码，重新编译，面向接口开发的意义将大打折扣
• service 层代码没有进行事务控制 ，如果转账过程中出现异常，将可能导致
  数据库数据错乱，后果可能会很严重，尤其在金融业务中

三、问题解决思路，并进行代码改造

3.1 实例化对象的方式除了 new 之外，还有什么技术？

答案：反射Class.forName("全限定类名")；但是这个全限定类名不能写在 Java 代码中，不然还是会造成耦合，所以我们可以把类的全限定类名配置在 xml 中
另外项目中往往有很多对象需要实例化，那就使用工厂模式通过反射技术来生产对象

3.2 根据上述思路开始进行初步的代码改造

1. 自定义一个 beans.xml

2. 引入 dom4j 用来解析 xml，自定义一个工厂类，使用反射技术生产对象

   
   
     dom4j
     dom4j
     1.6.1
   
   
   
     jaxen
     jaxen
     1.1.6
   
   

   public class BeanFactory {
   
       /**
        * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
        * 任务二：对外提供获取实例对象的接口（根据id获取）
        */
   
       private static Map 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 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");        // accountDao
                   String clazz = element.attributeValue("class");  // com.wujun.edu.dao.impl.JdbcAccountDaoImpl
                   // 通过反射技术实例化对象
                   Class aClass = Class.forName(clazz);
                   Object o = aClass.newInstance();  // 实例化之后的对象
   
                   // 存储到map中待用
                   map.put(id,o);
               }
           } catch (DocumentException e) {
               e.printStackTrace();
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           } catch (IllegalAccessException e) {
               e.printStackTrace();
           } catch (InstantiationException e) {
               e.printStackTrace();
           }
       }
   
       // 任务二：对外提供获取实例对象的接口（根据id获取）
       public static  Object getBean(String id) {
           return map.get(id);
       }
   
   }
   

3. 相关业务代码改造

   //private AccountDao accountDao = new JdbcAccountDaoImpl();
    private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
   
   // 1. 实例化service层对象
   //private TransferService transferService = new TransferServiceImpl();
   private TransferService transferService = (TransferService) BeanFactory.getBean("transferService");
   

4. 可以看到，new 关键字已经被干掉，但代码还不是最佳状态，因为干掉了 new 关键字实现了松耦合，但是代码上又重复出现了 BeanFactory 这个工厂类，而最佳状态是，业务层只是申明一个接口，别的什么都没有，继续改造

   public class BeanFactory {
   
       /**
        * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
        * 任务二：对外提供获取实例对象的接口（根据id获取）
        */
   
       private static Map 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 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");        // accountDao
                   String clazz = element.attributeValue("class");  // com.wujun.edu.dao.impl.JdbcAccountDaoImpl
                   // 通过反射技术实例化对象
                   Class aClass = Class.forName(clazz);
                   Object o = aClass.newInstance();  // 实例化之后的对象
   
                   // 存储到map中待用
                   map.put(id,o);
               }
   
               // 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
               // 有property子元素的bean就有传值需求
               List propertyList = rootElement.selectNodes("//property");
               // 解析property，获取父元素
               for (int i = 0; i < propertyList.size(); i++) {
                   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];
                       if(method.getName().equalsIgnoreCase("set" + name)) {  // 该方法就是 setAccountDao(AccountDao accountDao)
                           method.invoke(parentObject,map.get(ref));
                       }
                   }
   
                   // 把处理之后的parentObject重新放到map中
                   map.put(parentId,parentObject);
               }
           } catch (DocumentException e) {
               e.printStackTrace();
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           } catch (IllegalAccessException e) {
               e.printStackTrace();
           } catch (InstantiationException e) {
               e.printStackTrace();
           } catch (InvocationTargetException e) {
               e.printStackTrace();
           }
       }
   
       // 任务二：对外提供获取实例对象的接口（根据id获取）
       public static  Object getBean(String id) {
           return map.get(id);
       }
   
   }
   

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

四、事务控制问题分析

• 数据库事务归根结底其实是 Connection 的事务
  1. 提交事务：connection.commit();
  2. 回滚事务：connection.rollback();
  3. 自动提交：connection.setAutoCommit()
     • 参数传入 true 或者 false
     • 代码中没有进行相关设置，但是这个 autoCommit 默认为 true，所以事务就默认为自动提交
• 按照现有的银行转账代码，如果两次 update 之间发生异常的话，那么就会发生数据错乱，原因如下：
  1. 两次 update 使用了两个数据库 connection 链接，这样的话肯定是不属于一个事务控制了
  2. 事务控制目前在 Dao 层进行，没有控制在 service 层
• 解决思路：
  1. 让两次 update 使用同一个 connection 链接，我们可以给当前线程绑定一个 connection，和当前线程有关系的数据库操作，都去使用这个 connection（从当前线程中去拿）
  2. 把事务控制添加在 service 层

五、事务代码代码改造

• 当前线程绑定唯一 connection

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

  //从连接池获取连接
  // Connection con = DruidUtils.getInstance().getConnection();
  Connection con = connectionUtils.getInstance().getCurrentThreadConn();
  

• 自定义一个 TransactionManager，将事务控制添加在 service 层

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

  @Override
  public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {
  
      try {
          // 开启事务(关闭事务的自动提交)
          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);
  
          // 提交事务
          TransactionManager.getInstance().commit();
      } catch (Exception e) {
          e.printStackTrace();
          // 回滚事务
          TransactionManager.getInstance().rollback();
  
          // 抛出异常便于上层servlet捕获
          throw e;
  
      }
  }
  

六、使用动态代理再次改造 service 层事务控制

当前代码中，每个 service 方法中都得添加 try catch 手动控制事务的代码逻辑，方法一多，我们的代码修改维护就会显得非常麻烦，代码层次也显得臃肿不堪，而这些事务控制的代码其实并不是业务代码，属于横切逻辑代码，所以使用动态代理去做这件事情，较为合理

6.1 改造思路

1. 使用工厂模式来统一生成代理对象
2. 使用动态代理技术生成 TransferServiceImpl 的代理对象
3. TransferServlet 不再调用 TransferServiceImpl，而是调用 TransferServiceImpl 的代理对象

6.2 最终代码改造

优化 beans.xml

JdbcAccountDaoImpl

public class JdbcAccountDaoImpl implements AccountDao {

    private ConnectionUtils connectionUtils;

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

    @Override
    public Account queryAccountByCardNo(String cardNo) throws Exception {
        //从当前线程当中获取绑定的connection连接
        Connection con = connectionUtils.getCurrentThreadConn();
        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();

        return account;
    }

    @Override
    public int updateAccountByCardNo(Account account) throws Exception {
        // 从当前线程当中获取绑定的connection连接
        Connection con = connectionUtils.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();
        return i;
    }
}

TransferServiceImpl

public class TransferServiceImpl implements TransferService {

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

    @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(to);
        int c = 1 / 0;
        accountDao.updateAccountByCardNo(from);
    }
}

ConnectionUtils

public class ConnectionUtils {

    private ThreadLocal threadLocal = new ThreadLocal<>(); // 存储当前线程的连接

    /**
     * 从当前线程获取连接
     */
    public Connection getCurrentThreadConn() throws SQLException {
        /**
         * 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取一个连接绑定到当前线程
          */
        Connection connection = threadLocal.get();
        if(connection == null) {
            // 从连接池拿连接并绑定到线程
            connection = DruidUtils.getInstance().getConnection();
            // 绑定到当前线程
            threadLocal.set(connection);
        }
        return connection;

    }
}

TransactionManager

public class TransactionManager {

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

    // 开启手动事务控制
    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();
    }
}

ProxyFactory

public class ProxyFactory {

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

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

BeanFactory

public class BeanFactory {

    /**
     * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
     * 任务二：对外提供获取实例对象的接口（根据id获取）
     */
    private static Map 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 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");        // accountDao
                String clazz = element.attributeValue("class");  // com.wujun.edu.dao.impl.JdbcAccountDaoImpl
                // 通过反射技术实例化对象
                Class aClass = Class.forName(clazz);
                Object o = aClass.newInstance();  // 实例化之后的对象

                // 存储到map中待用
                map.put(id, o);

            }

            // 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
            // 有property子元素的bean就有传值需求
            List propertyList = rootElement.selectNodes("//property");
            // 解析property，获取父元素
            for (int i = 0; i < propertyList.size(); i++) {
                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];
                    if (method.getName().equalsIgnoreCase("set" + name)) {  // 该方法就是 setAccountDao(AccountDao accountDao)
                        method.invoke(parentObject, map.get(ref));
                    }
                }

                // 把处理之后的parentObject重新放到map中
                map.put(parentId, parentObject);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    // 任务二：对外提供获取实例对象的接口（根据id获取）
    public static Object getBean(String id) {
        return map.get(id);
    }
}

TransferServlet 最终调用代码

private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
private TransferService transferService = (TransferService) proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;