1.业务场景与问题分析
业务场景流程如下,一个简单的银行转账业务,当前未使用IOC与aop
image.png
这样会用什么问题呢?
问题(1)service 层实现类在使⽤ dao 层对象时，直接在
TransferServiceImpl 中通过 AccountDao accountDao = new JdbcAccountDaoImpl() 获得了 dao层对
象，然⽽⼀个 new 关键字却将 TransferServiceImpl 和 dao 层具体的⼀个实现类
JdbcAccountDaoImpl 耦合在了⼀起，如果说技术架构发⽣⼀些变动，dao 层的实现要使⽤其它技术，
⽐如 Mybatis，思考切换起来的成本？每⼀个 new 的地⽅都需要修改源代码，重新编译，⾯向接⼝开发
的意义将⼤打折扣
问题(2)service 层代码没有竟然还没有进⾏事务控制 ,如果转账过程中出现异常，将可能导致
数据库数据错乱，后果可能会很严重，尤其在⾦融业务
2.问题一解决思路与实现
解决思路:
(1)除了new方式能够实例化对象外,还可以反射 Class.forName("全限定类名")实例化对象,此方法需要把类的全限定类名配置在xml中
(2)使用工厂来通过反射技术生产对象,工厂模式是一种非常好的解耦合方式
(3)使用工厂后,private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");,这样获取accountDao时会出现工厂,能否不出现工厂呢?
声明⼀个变量并提供 set ⽅法，在反射的时候将所需要的对象注⼊进去
image.png
BeanFactory
任务一：读取解析xml，通过反射技术实例化对象,并且存储待用（map集合）
任务二：对外提供获取实例对象的接口（根据id获取）,id对应xml文件中id
任务三:实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
class BeanFactory {
/**
* 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
* 任务二：对外提供获取实例对象的接口（根据id获取）
*/
private static Map<String,Object> 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<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.lagou.edu.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获取）
public static Object getBean(String id) {
return map.get(id);
}
}
beans.xml
由于TransferServiceImpl里需要获取dao层对象,因此,设置ref的值为com.lagou.edu.dao.impl.JdbcAccountDaoImpl全限定名所对应的id="acocountDao",
<bean id="accountDao" class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl">
</bean>
<bean id="transferService" class="com.lagou.edu.service.impl.TransferServiceImpl">
<!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值-->
<property name="AccountDao" ref="accountDao"></property>
</bean>
TransferServiceImpl
如图,通过反射调用到setAccount()方法,获得了所需Dao对象
image.png
3.问题二分析与实现
TransferServiceImpl如下
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);
}
分析得知
(1)由于用的原生jdbc,数据库事务归根结底是Connection的事务,而Connection的提交默认是自动提交 setAutoCommit默认为true的,目前事务是在dao层进行,需要控制到service层
void setAutoCommit(boolean autoCommit) throws SQLException;
/**
* Retrieves the current auto-commit mode for this <code>Connection</code>
* object.
*
* @return the current state of this <code>Connection</code> object's
* auto-commit mode
* @exception SQLException if a database access error occurs
* or this method is called on a closed connection
* @see #setAutoCommit
*/
(2)两次update使用两个庫连接connection,这样就肯定不是一个事务了,所以需要使用同一个connection,由于两个update属于一个线程内的调用,所以可以给该线程绑定上一个connection
改造如下:
(1).增加 ConnectionUtils,给线程绑定一个connection,注意使用connectionUtils对象时需要是同一个,所以connectionUtils需要保持单例
- 可以使用如下代码中注释掉的代码,使用饿汉式的单例模式来保证
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 ,同样使用饿汉单例模式
public class TransactionManager {
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();
}
TransferServiceImpl中transfer改造,在service层添加事务管理
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;
}
4.动态代理改造service事务控制
思考:用上述方式是实现了事务控制,但是只是针对一个方法,如果是很多方法很多类都需要进行事务控制,那用之前的方式非常麻烦与繁琐,怎么去简化?
解决方式:事务即aop思想中的横切逻辑,可以使用动态代理技术改造service层事务控制
image.png
- ProxyFactory 代理对象工厂
public class ProxyFactory {
private TransactionManager transactionManager;
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
/*private ProxyFactory(){
}
private static ProxyFactory proxyFactory = new ProxyFactory();
public static ProxyFactory getInstance() {
return proxyFactory;
}*/
/**
* 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;
}
});
}
}
TransferServiceImpl 中transfer方法中事务相关代码不再需要,保持原来业务代码即可
TransferServlet中需要首先获得代理工厂的实例对象,而不是拿TransferServiceImpl对象
// 首先从BeanFactory获取到proxyFactory代理工厂的实例化对象
private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
private TransferService transferService = (TransferService) proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;
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>
