经过一个银行转帐的案例，手写实现IOC 和 AOP
经过上一篇面试被问了几百遍的 IoC 和 AOP，还在傻傻搞不清楚？咱们了解了 IOC 和 AOP 这两个思想，下面咱们先不去考虑Spring是如何实现这两个思想的，先经过一个银行转帐的案例，分析一下该案例在代码层面存在什么问题？分析以后使用咱们已有的知识来解决这些问题（痛点）。前端
其实这个过程就是在一步步分析并手动实现 IOC 和 AOP 。面试
案例介绍
银行转帐：帐户A向帐户B转帐（帐户A减钱，帐户B加钱）。为了简单起见，在前端页面中写死了两个帐户。每次只须要输入转帐金额，进行转帐操做，验证功能便可。sql
案例表结构
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));
}
}
TransferServicejson
TransferServiceImplapp
AccountDaoide
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<String,Object> 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<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"); // 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<Element> propertyList = rootElement.selectNodes("//property");
// 解析property，获取父元素
for (int i = 0; i < propertyList.size(); i++) {
Element element = propertyList.get(i); //<property name="AccountDao" ref="accountDao"></property>
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 的思想经过动态代理的方式实现了事务控制。
相关文章
- 1. 手写IOC实现过程
- 2. 经过拓展Function.prototype实现一个AOP
- 3. 经过手写SpringMVC理解IOC和DI
- 4. 手写@Component和@Resource实现IoC和DI
- 5. Spring Ioc和 aop 转
- 6. Spring AOP实现原理（五）手写一个Spring AOP框架
- 7. spring 事务案例--转帐
- 8. 手写一个IOC容器
- 9. spring IOC和AOP的底层实现
- 10. Spring中IOC和AOP的实现原理
- 更多相关文章...
- • 现实生活中的 XML - XML 教程
- • Spring IoC容器：BeanFactory和ApplicationContext - Spring教程
- • ☆基于Java Instrument的Agent实现
- • TiDB 在摩拜单车在线数据业务的应用和实践
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Duang!超快Wi-Fi来袭
- 2. 机器学习-补充03 神经网络之**函数(Activation Function)
- 3. git上开源maven项目部署 多module maven项目（多module maven+redis+tomcat+mysql）后台部署流程学习记录
- 4. ecliple-tomcat部署maven项目方式之一
- 5. eclipse新导入的项目经常可以看到“XX cannot be resolved to a type”的报错信息
- 6. Spark RDD的依赖于DAG的工作原理
- 7. VMware安装CentOS-8教程详解
- 8. YDOOK：Java 项目 Spring 项目导入基本四大 jar 包 导入依赖，怎样在 IDEA 的项目结构中导入 jar 包 导入依赖
- 9. 简单方法使得putty（windows10上）可以免密登录树莓派
- 10. idea怎么用本地maven
欢迎关注本站公众号,获取更多信息
