經過一個銀行轉帳的案例，手寫實現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 在摩拜單車在線數據業務的應用和實踐
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
