一、银行转账案例
先使用原始 servlet 方式模拟一个银行转账的功能，关键代码如下：
- 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 接口及实现类
public interface TransferService { void transfer(String fromCardNo,String toCardNo,int money) throws Exception; }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(to); accountDao.updateAccountByCardNo(from); } } - AccountDao 层接口及基于 JDBC 的实现类
public interface AccountDao { Account queryAccountByCardNo(String cardNo) throws Exception; int updateAccountByCardNo(Account account) throws Exception; }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; } } - 单例模式获取阿里巴巴德鲁伊数据源
public class DruidUtils { private DruidUtils(){} private static DruidDataSource druidDataSource = new DruidDataSource(); static { druidDataSource.setDriverClassName("com.mysql.jdbc.Driver"); druidDataSource.setUrl("jdbc:mysql://localhost:3306/bank"); druidDataSource.setUsername("root"); druidDataSource.setPassword("123456"); } public static DruidDataSource getInstance() { return druidDataSource; } }
二、银行转账功能问题分析
- 在上述案例实现中，service 层实现类在使用 dao 层对象时，直接在 TransferServiceImpl 中通过
AccountDao accountDao = new JdbcAccountDaoImpl()获得了 dao 层对象，然而?个 new 关键字却将 TransferServiceImpl 和 dao 层具体的?个实现类 JdbcAccountDaoImpl 耦合在了?起，如果说技术架构发生?些变动，dao 层的实现要使用其它技术，比如 Mybatis，那么每?个 new 的地方都需要修改源代码，重新编译，面向接口开发的意义将大打折扣 - service 层代码没有进行事务控制 ，如果转账过程中出现异常，将可能导致
数据库数据错乱，后果可能会很严重，尤其在金融业务中
三、问题解决思路，并进行代码改造
3.1 实例化对象的方式除了 new 之外，还有什么技术？
答案：反射Class.forName("全限定类名")；但是这个全限定类名不能写在 Java 代码中，不然还是会造成耦合，所以我们可以把类的全限定类名配置在 xml 中
另外项目中往往有很多对象需要实例化，那就使用工厂模式通过反射技术来生产对象
3.2 根据上述思路开始进行初步的代码改造
- 自定义一个 beans.xml
<?xml version="1.0" encoding="UTF-8" ?> <!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置--> <beans> <!--id标识对象，class是类的全限定类名--> <bean id="accountDao" class="com.wujun.edu.dao.impl.JdbcTemplateDaoImpl"></bean> <bean id="transferService" class="com.wujun.edu.service.impl.TransferServiceImpl"></bean> </beans> - 引入 dom4j 用来解析 xml，自定义一个工厂类，使用反射技术生产对象
<!--dom4j依赖--> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> <!--xpath表达式依赖--> <dependency> <groupId>jaxen</groupId> <artifactId>jaxen</artifactId> <version>1.1.6</version> </dependency>public 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("http://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.wujun.edu.dao.impl.JdbcAccountDaoImpl // 通过反射技术实例化对象 Class<?> aClass = Class.forName(clazz); Object o = aClass.newInstance(); // 实例化之后的对象 // 存储到map中待用 map.put(id,o); } } catch (DocumentException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } } // 任务二：对外提供获取实例对象的接口（根据id获取） public static Object getBean(String id) { return map.get(id); } } - 相关业务代码改造
//private AccountDao accountDao = new JdbcAccountDaoImpl(); private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao"); // 1. 实例化service层对象 //private TransferService transferService = new TransferServiceImpl(); private TransferService transferService = (TransferService) BeanFactory.getBean("transferService"); -
可以看到，new 关键字已经被干掉，但代码还不是最佳状态，因为干掉了 new 关键字实现了松耦合，但是代码上又重复出现了 BeanFactory 这个工厂类，而最佳状态是，业务层只是申明一个接口，别的什么都没有，继续改造
<!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置--> <beans> <!--id标识对象，class是类的全限定类名--> <bean id="accountDao" class="com.wujun.edu.dao.impl.JdbcTemplateDaoImpl"></bean> <bean id="transferService" class="com.wujun.edu.service.impl.TransferServiceImpl"> <!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值--> <property name="AccountDao" ref="accountDao"></property> </bean> </beans>public 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("http://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.wujun.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("http://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); } }//private AccountDao accountDao = new JdbcAccountDaoImpl(); // private AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao"); // 最佳状态 private AccountDao accountDao; // 构造函数传值/set方法传值 public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; }
四、事务控制问题分析
-
数据库事务归根结底其实是 Connection 的事务
- 提交事务：
connection.commit(); - 回滚事务：
connection.rollback(); - 自动提交：
connection.setAutoCommit()- 参数传入 true 或者 false
- 代码中没有进行相关设置，但是这个 autoCommit 默认为 true，所以事务就默认为自动提交
- 提交事务：
-
按照现有的银行转账代码，如果两次 update 之间发生异常的话，那么就会发生数据错乱，原因如下：
- 两次 update 使用了两个数据库 connection 链接，这样的话肯定是不属于一个事务控制了
- 事务控制目前在 Dao 层进行，没有控制在 service 层
-
解决思路：
- 让两次 update 使用同一个 connection 链接，我们可以给当前线程绑定一个 connection，和当前线程有关系的数据库操作，都去使用这个 connection（从当前线程中去拿）
- 把事务控制添加在 service 层
五、事务代码代码改造
-
当前线程绑定唯一 connection
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; } }//从连接池获取连接 // Connection con = DruidUtils.getInstance().getConnection(); Connection con = connectionUtils.getInstance().getCurrentThreadConn(); -
自定义一个 TransactionManager，将事务控制添加在 service 层
public class TransactionManager { private ConnectionUtils connectionUtils; public void setConnectionUtils(ConnectionUtils connectionUtils) { this.connectionUtils = connectionUtils; } 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(); } }@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; } }
六、使用动态代理再次改造 service 层事务控制
当前代码中，每个 service 方法中都得添加 try catch 手动控制事务的代码逻辑，方法一多，我们的代码修改维护就会显得非常麻烦，代码层次也显得臃肿不堪，而这些事务控制的代码其实并不是业务代码，属于横切逻辑代码，所以使用动态代理去做这件事情，较为合理
6.1 改造思路
- 使用工厂模式来统一生成代理对象
- 使用动态代理技术生成 TransferServiceImpl 的代理对象
- TransferServlet 不再调用 TransferServiceImpl，而是调用 TransferServiceImpl 的代理对象
6.2 最终代码改造
优化 beans.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置-->
<beans>
<!--id标识对象，class是类的全限定类名-->
<bean id="accountDao" class="com.wujun.edu.dao.impl.JdbcTemplateDaoImpl">
<property name="ConnectionUtils" ref="connectionUtils"/>
</bean>
<bean id="transferService" class="com.wujun.edu.service.impl.TransferServiceImpl">
<!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值-->
<property name="AccountDao" ref="accountDao"></property>
</bean>
<!--配置新增的三个Bean-->
<bean id="connectionUtils" class="com.wujun.edu.utils.ConnectionUtils"></bean>
<!--事务管理器-->
<bean id="transactionManager" class="com.wujun.edu.utils.TransactionManager">
<property name="ConnectionUtils" ref="connectionUtils"/>
</bean>
<!--代理对象工厂-->
<bean id="proxyFactory" class="com.wujun.edu.factory.ProxyFactory">
<property name="TransactionManager" ref="transactionManager"/>
</bean>
</beans>
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连接
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();
return account;
}
@Override
public int updateAccountByCardNo(Account account) throws Exception {
// 从当前线程当中获取绑定的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();
return i;
}
}
TransferServiceImpl
public class TransferServiceImpl implements TransferService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@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(to);
int c = 1 / 0;
accountDao.updateAccountByCardNo(from);
}
}
ConnectionUtils
public class 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 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
public class ProxyFactory {
private TransactionManager transactionManager;
public void setTransactionManager(TransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
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;
}
});
}
}
BeanFactory
public 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("http://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.wujun.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("http://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);
}
}
TransferServlet 最终调用代码
private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
private TransferService transferService = (TransferService) proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;
