第三部分 ⼿写实现 IoC AOP

上⼀部分我们理解了 IoC AOP 思想,我们先不考虑 Spring 是如何实现这两个思想的,此处准备了⼀ 个『银⾏转账』的案例,请分析该案例在代码层次有什么问题 ?分析之后使⽤我们已有知识解决这些问 题(痛点)。其实这个过程我们就是在⼀步步分析并⼿写实现 IoC AOP

1节 银⾏转账案例界⾯

2节 银⾏转账案例表结构

3节 银⾏转账案例代码调⽤关系

4节 银⾏转账案例关键代码

TransferServlet

package com.lagou.edu.servlet;
import com.lagou.edu.service.impl.TransferServiceImpl;
import com.lagou.edu.utils.JsonUtils;
import com.lagou.edu.pojo.Result;
import com.lagou.edu.service.TransferService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 应癫
*/
@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接⼝及实现类

package com.lagou.edu.service;
/**
* @author 应癫
*/
public interface TransferService {
 void transfer(String fromCardNo,String toCardNo,int money) throws
Exception; }
package com.lagou.edu.service.impl;
import com.lagou.edu.dao.AccountDao;
import com.lagou.edu.dao.impl.JdbcAccountDaoImpl;
import com.lagou.edu.pojo.Account;
import com.lagou.edu.service.TransferService;
/**
* @author 应癫
*/
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(from);
 accountDao.updateAccountByCardNo(to);
 }
}

AccountDao层接⼝及基于Jdbc的实现类

package com.lagou.edu.dao;
import com.lagou.edu.pojo.Account;
/**
* @author 应癫
*/
public interface AccountDao {
 Account queryAccountByCardNo(String cardNo) throws Exception;
 int updateAccountByCardNo(Account account) throws Exception; }

JdbcAccountDaoImplJdbc技术实现Dao层接⼝)

package com.lagou.edu.dao.impl;
import com.lagou.edu.pojo.Account;
import com.lagou.edu.dao.AccountDao;
import com.lagou.edu.utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @author 应癫
*/
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;
 }
第5节 银⾏转账案例代码问题分析
(1)问题⼀:在上述案例实现中,service 层实现类在使⽤ dao 层对象时,直接在
TransferServiceImpl 中通过 AccountDao accountDao = new JdbcAccountDaoImpl() 获得了 dao层对
象,然⽽⼀个 new 关键字却将 TransferServiceImpl 和 dao 层具体的⼀个实现类
JdbcAccountDaoImpl 耦合在了⼀起,如果说技术架构发⽣⼀些变动,dao 层的实现要使⽤其它技术,
⽐如 Mybatis,思考切换起来的成本?每⼀个 new 的地⽅都需要修改源代码,重新编译,⾯向接⼝开发
的意义将⼤打折扣?
(2)问题⼆:service 层代码没有竟然还没有进⾏事务控制 ?!如果转账过程中出现异常,将可能导致
数据库数据错乱,后果可能会很严重,尤其在⾦融业务。
第6节 问题解决思路
 @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节 银⾏转账案例代码问题分析

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

6节 问题解决思路

针对问题⼀思考:
实例化对象的⽅式除了 new 之外,还有什么技术?反射 ( 需要把类的全限定类名配置在 xml )
考虑使⽤设计模式中的⼯⼚模式解耦合,另外项⽬中往往有很多对象需要实例化,那就在⼯⼚中使 ⽤反 射技术实例化对象,⼯⼚模式很合适

更进⼀步,代码中能否只声明所需实例的接⼝类型,不出现 new 也不出现⼯⼚类的字眼,如下 图? 能!声明⼀个变量并提供 set ⽅法,在反射的时候将所需要的对象注⼊进去吧

针对问题⼆思考:
service 层没有添加事务控制,怎么办?没有事务就添加上事务控制,⼿动控制 JDBC Connection 事务,但要注意将 Connection 和当前线程绑定(即保证⼀个线程只有⼀个 Connection ,这样操作才针对的是同⼀个 Connection ,进⽽控制的是同⼀个事务)

7节 案例代码改造

1 )针对问题⼀的代码改造
  • beans.xml
<?xml version="1.0" encoding="UTF-8" ?>
<beans>
 <bean id="transferService"
class="com.lagou.edu.service.impl.TransferServiceImpl">
 <property name="AccountDao" ref="accountDao"></property>
 </bean>
 <bean id="accountDao"
class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl">
 </bean>
</beans>
  • 增加 BeanFactory.java
package com.lagou.edu.factory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @author 应癫
*/
public class BeanFactory {
 /**
 * ⼯⼚类的两个任务
 * 任务⼀:加载解析xml,读取xml中的bean信息,通过反射技术实例化bean对象,然后放⼊
map待⽤
 * 任务⼆:提供接⼝⽅法根据id从map中获取bean(静态⽅法)
 */
 private static Map<String,Object> map = new HashMap<>();
 static {
 InputStream resourceAsStream =
BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
 SAXReader saxReader = new SAXReader();
 try {
 Document document = saxReader.read(resourceAsStream);
 Element rootElement = document.getRootElement();
 List<Element> list = rootElement.selectNodes("//bean");
 // 实例化bean对象
 for (int i = 0; i < list.size(); i++) {
 Element element = list.get(i);
 String id = element.attributeValue("id");
 String clazz = element.attributeValue("class");
 Class<?> aClass = Class.forName(clazz);
 Object o = aClass.newInstance();
 map.put(id,o);
 }
 // 维护bean之间的依赖关系
 List<Element> propertyNodes =
rootElement.selectNodes("//property");
 for (int i = 0; i < propertyNodes.size(); i++) {
 Element element = propertyNodes.get(i);
 // 处理property元素
 String name = element.attributeValue("name");
 String ref = element.attributeValue("ref");
 
 String parentId =
element.getParent().attributeValue("id");
 Object parentObject = map.get(parentId);
 Method[] methods = parentObject.getClass().getMethods();
 for (int j = 0; j < methods.length; j++) {
 Method method = methods[j];
 if(("set" + name).equalsIgnoreCase(method.getName()))
{
 // bean之间的依赖关系(注⼊bean)
 Object propertyObject = map.get(ref);
 method.invoke(parentObject,propertyObject);
 }
 }
 // 维护依赖关系后重新将bean放⼊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();
 }
 }
 public static Object getBean(String id) {
 return map.get(id);
 }
}
  • 修改 TransferServlet

  • 修改 TransferServiceImpl

2 )针对问题⼆的改造
  • 增加 ConnectionUtils
package com.lagou.edu.utils;
import java.sql.Connection;
import java.sql.SQLException;
/**
* @author 应癫
*/
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;
 }
}
  • 增加 TransactionManager 事务管理器类
package com.lagou.edu.utils;
import java.sql.SQLException;
/**
* @author 应癫
*/
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 代理⼯⼚类
package com.lagou.edu.factory;
import com.lagou.edu.utils.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author 应癫
*/
public class ProxyFactory {
 private TransactionManager transactionManager;
 public void setTransactionManager(TransactionManager
transactionManager) {
 this.transactionManager = transactionManager;
 }
 public Object getProxy(Object target) {
 return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.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(target,args);
 // 提交事务
 transactionManager.commit();
 }catch(Exception e) {
 e.printStackTrace();
 // 回滚事务
 transactionManager.rollback();
 // 异常向上抛出,便于servlet中捕获
 throw e.getCause();
 }
 return result;
 }
 });
 }
}
  • 修改 beans.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!--跟标签beans,⾥⾯配置⼀个⼜⼀个的bean⼦标签,每⼀个bean⼦标签都代表⼀个类的配置--
><beans>
 <!--id标识对象,class是类的全限定类名-->
 <bean id="accountDao"
class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl">
 <property name="ConnectionUtils" ref="connectionUtils"/>
 </bean>
 <bean id="transferService"
class="com.lagou.edu.service.impl.TransferServiceImpl">
 <!--set+ name 之后锁定到传值的set⽅法了,通过反射技术可以调⽤该⽅法传⼊对应
的值-->
 <property name="AccountDao" ref="accountDao"></property>
 </bean>
 <!--配置新增的三个Bean-->
 <bean id="connectionUtils"
class="com.lagou.edu.utils.ConnectionUtils"></bean>
 <!--事务管理器-->
 <bean id="transactionManager"
class="com.lagou.edu.utils.TransactionManager">
 <property name="ConnectionUtils" ref="connectionUtils"/>
 </bean>
 <!--代理对象⼯⼚-->
 <bean id="proxyFactory" class="com.lagou.edu.factory.ProxyFactory">
 <property name="TransactionManager" ref="transactionManager"/>
 </bean>
</beans>
  • 修改 JdbcAccountDaoImpl
package com.lagou.edu.dao.impl;
import com.lagou.edu.pojo.Account;
import com.lagou.edu.dao.AccountDao;
import com.lagou.edu.utils.ConnectionUtils;
import com.lagou.edu.utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @author 应癫
*/
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 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连接
 //Connection con = DruidUtils.getInstance().getConnection();
 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
package com.lagou.edu.servlet;
import com.lagou.edu.factory.BeanFactory;
import com.lagou.edu.factory.ProxyFactory;
import com.lagou.edu.service.impl.TransferServiceImpl;
import com.lagou.edu.utils.JsonUtils;
import com.lagou.edu.pojo.Result;
import com.lagou.edu.service.TransferService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* @author 应癫
*/
@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
 // 1. 实例化service层对象
 //private TransferService transferService = new TransferServiceImpl();
 //private TransferService transferService = (TransferService)
BeanFactory.getBean("transferService");
 // 从⼯⼚获取委托对象(委托对象是增强了事务控制的功能)
 // ⾸先从BeanFactory获取到proxyFactory代理⼯⼚的实例化对象
 private ProxyFactory proxyFactory = (ProxyFactory)
BeanFactory.getBean("proxyFactory");
 private TransferService transferService = (TransferService)
proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;
 @Override
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
 doPost(req,resp);
第四部分 Spring IOC 应⽤
第1节 Spring IoC基础
 }
 @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));
 }
}

更多关于Java集合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、Java算法、数据库、Zookeeper、分布式缓存、数据结构面试解析+知识点集合等等可以去这个Github链接地址:

https://github.com/ThinkingHan/Java-note 阅读,Star一下吧,感谢支持~