通过上一篇面试被问了几百遍的 IoC 和 AOP，还在傻傻搞不清楚？我们了解了 IOC 和 AOP 这两个思想，下面我们先不去考虑Spring是如何实现这两个思想的，先通过一个银行转账的案例，分析一下该案例在代码层面存在什么问题？分析之后使用我们已有的知识来解决这些问题(痛点)。
其实这个过程就是在一步步分析并手动实现 IOC 和 AOP 。
案例介绍
银行转账：账户A向账户B转账(账户A减钱，账户B加钱)。为了简单起见，在前端页面中写死了两个账户。每次只需要输入转账金额，进行转账操作，验证功能即可。
案例表结构
name varcher 255 用户名money int 255 账户金额cardNo varcher 255 银行卡号案例代码调用关系
核心代码
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
TransferServiceImpl
AccountDao
JdbcAccountDaoImpl
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; }}案例问题分析
通过上面的流程分析以及简要代码，我们可以发现如下问题：
问题一： new 关键字将 service 层的实现类 TransferServiceImpl 和 Dao 层的具体实现类 JdbcAccountDaoImpl 耦合在了一起，当需要切换Dao层实现类的时候必须要修改 service 的代码、重新编译，这样不符合面向接口开发的最优原则。
问题二： service 层没有事务控制，如果转账过程中出现异常可能会导致数据错乱，后果很严重，尤其是在金融银行领域。
问题解决思路
new关键字耦合问题解决方案
实例化对象的方式处理new之外，还有什么技术？
答：反射(将类的权限定类名配置在xml文件中)
项目中往往有很多对象需要实例化，考虑使用工程模式通过反射来实例化对象。(工厂模式是解耦合非常好的一种方式)
代码中能否只声明所需实例的接口类型，不出现new关键字，也不出现工厂类的字眼？
答：可以，声明一个变量并提供一个set方法，在反射的时候将所需要的对象注入进去。
new关键字耦合问题代码改造
首先定义 bean.xml 文件
定义BeanFactory
BeanFactory
/** * 工厂类，生产对象(使用反射技术) * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用(map集合) * 任务二：对外提供获取实例对象的接口(根据id获取) */public class BeanFactory { private static Map map = new HashMap<>(); // 存储对象 /** * 读取解析xml，通过反射技术实例化对象并且存储待用(map集合) */ static { // 加载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.yanliang.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获取) * @param id * @return */ public static Object getBean(String id) { return map.get(id); }}对象的实例化工作交给BeanFactory来进行之后，我们再具体使用是就可以像如下这样了：
事务控制问题分析
在转账的业务代码中手动模拟转账异常，来验证一下。在两个账户的转入和转出之间模拟一个分母为0的异常。
accountDao.updateAccountByCardNo(to);int i = 1/0;accountDao.updateAccountByCardNo(from);然后启动程序，点击转账(李大雷 向 韩梅梅转 100 ￥)之后，会出现如下错误。
这时我们再查看数据库
发现 韩梅梅 的账户增加了100￥，但是李大雷的账户并没有减少(两个账户原本都有10000￥)。
出现这个问题的原因就是因为Service层没有事务控制的功能，在转账过程中出现错误(转入和转出之间出现异常，转入已经完成，转出没有进行)这事就会造成上面的问题。
数据库的事务问题归根结底是 Connection 的事务
- connection.commit() 提交事务
- connection.rollback() 回滚事务
在上面银行转账的案例中，两次update操作使用的是两个数据库连接，这样的话，肯定就不属于同一个事务控制了。
解决思路：
通过上面的分析，我们得出问题的原因是两次update使用了两个不同的connection连接。那么要想解决这个问题，我们就需要让两次update使用同一个connection连接
两次update属于同一个线程内的执行调用，我们可以给当前线程绑定一个Connection，和当前线程有关系的数据库操作都去使用这个connection(从当前线程中获取，第一次使用连接，发现当前线程没有，就从连接池获取一个连接绑定到当前线程)
另一方面，目前事务控制是在Dao层进行的(connection)，我们需要将事务控制提到service层(service层才是具体执行业务逻辑的地方，这里可能会调用多个dao层的方法，我们需要对service层的方法进行整体的事务控制)。
有了上面两个思路，下面我们进行代码修改。
事务控制代码修改
增加 ConnectionUtils 工具类
ConnectionUtils
增加 TransactionManager 事务管理类
TransactionManager
增加代理工厂 ProxyFactory
ProxyFactory
/** * 代理对象工厂：生成代理对象的 */public class ProxyFactory { private TransactionManager transactionManager; public void setTransactionManager(TransactionManager transactionManager) { this.transactionManager = transactionManager; } /** * 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; } }); }}修改beans.xml文件
beans
修改 JdbcAccountDaoImpl的实现
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 con = DruidUtils.getInstance().getConnection(); // 改造为：从当前线程当中获取绑定的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();// con.close(); return account; } @Override public int updateAccountByCardNo(Account account) throws Exception { // 从连接池获取连接// Connection con = DruidUtils.getInstance().getConnection(); // 改造为：从当前线程当中获取绑定的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();// con.close(); return i; }}修改 TransferServlet
TransferServlet
@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")public class TransferServlet extends HttpServlet {// // 1. 实例化service层对象// private TransferService transferService = new TransferServiceImpl(); // 改造为通过Bean工程获取service层对象// private TransferService transferService = (TransferService) BeanFactory.getBean("transferService"); // 从工程获取委托对象(委托对象增强了事务控制的功能) private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory"); private TransferService transferService = (TransferService) proxyFactory.getProxy(BeanFactory.getBean("transferService")) ; @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)); }}改造完之后，我们再次进行测试，这时会发现当转账过程中出现错误时，事务能够成功的被控制住(转出账户不会少钱，转入账户不会多钱)。
为什么要使用代理的方式来实现事务控制？
这里我们可以考虑一个问题，为什么要使用代理的方式来实现事务控制？
如果没有使用代理的方式，我们要向实现事务控制这需要将，事务控制的相关代码写在service层的TransferServiceImpl 具体实现中。
public class TransferServiceImpl implements TransferService { // 最佳状态 private AccountDao accountDao; // 构造函数传值/set方法传值 public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } @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; } }}这样的话，事务控制和具体的业务代码就耦合在了一起，如果有多个方法都需要实现事务控制的功能，我们需要在每个业务方法是都添加上这些代码。这样将会出现大量的重复代码。所以这里使用了 AOP 的思想通过动态代理的方式实现了事务控制。
7539
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
