SpringAOP(面向切面
代理模式
简单转账功能
创建目录
创建数据库并准备好数据
# 删除spring_aop数据库
drop database if exists spring_aop;
# 创建spring_aop数据库
create database spring_aop;
# 使用spring_aop数据库
use spring_aop;
# 创建account表
create table account (
id int(11) auto_increment primary key,
accountNum varchar(20) default NULL,
money int(8) default 0
);
# 新增数据
insert into account (accountNum, money) values
("622200001",1000),("622200002",1000);
导包
- 导入Spring基础包
- 导入操作数据库、连接数据库、测试需要的包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.13.RELEASE</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-dbutils/commons-dbutils -->
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.7</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
核心配置文件
创建applicationContext.xml文件
配置自动扫包
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
https://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
">
<!-- bean definitions here -->
<context:component-scan base-package="dao"/>
<context:component-scan base-package="services"/>
<context:component-scan base-package="utils"/>
</beans>
配置数据源
<!--连接数据库的必备信息-->
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/javaweb"></property>
<property name="user" value="root"></property>
<property name="password" value="362522"></property>
</bean>
代码编写
创建数据库连接工具类：ConnectionUtils.java
package utils;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.Connection;
import java.sql.SQLException;
@Component
public class ConnectionUtils {
private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
@Autowired
private ComboPooledDataSource dataSource;
/**
* 获得当前线程绑定的连接
*
* @return
*/
public Connection getThreadConnection() {
try {
// 看线程是否绑了连接
Connection conn = tl.get();
if (conn == null) {
// 从数据源获取一个连接
conn = dataSource.getConnection();
// 和线程局部变量 绑定
tl.set(conn);
}
// 返回线程连接
return tl.get();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 把连接和当前线程进行解绑
*/
public void remove() {
tl.remove();
}
}
创建Account模块实体类：Account.java
package entity;
public class Account {
private Integer id;
private String accountNum;
private Integer money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getAccountNum() {
return accountNum;
}
public void setAccountNum(String accountNum) {
this.accountNum = accountNum;
}
public Integer getMoney() {
return money;
}
public void setMoney(Integer money) {
this.money = money;
}
}
创建Account模块Dao层：UserDao.java
package dao;
import entity.Account;
public interface UserDao {
/**
* 更新
*
* @param account
*/
void updateAccount(Account account);
/**
* 根据编号查询账户
*
* @param accountNum
* @return 如果没有结果就返回null，如果结果集超过一个就抛异常，如果有唯一的一个结果就返回
*/
Account findAccountByNum(String accountNum);
}
创建Account模块Dao层实现类：UserDaoImpl.java
package dao.impl;
import dao.UserDao;
import entity.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import utils.ConnectionUtils;
import java.sql.SQLException;
import java.util.List;
@Repository("userDao")
public class UserDaoImpl implements UserDao {
// 数据库查询工具类
@Autowired
private QueryRunner runner;
// 数据库连接工具类
@Autowired
private ConnectionUtils connectionUtils;
/**
* 更新
*
* @param account
*/
public void updateAccount(Account account) {
try {
runner.update(connectionUtils.getThreadConnection(),
"update account set accountNum=?,money=? where id=?",
account.getAccountNum(), account.getMoney(), account.getId());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* 根据编号查询账户
*
* @param accountNum
* @return 如果没有结果就返回null，如果结果集超过一个就抛异常，如果有唯一的一个结果就返回
*/
public Account findAccountByNum(String accountNum) {
List<Account> accounts = null;
try {
accounts = runner.query(connectionUtils.getThreadConnection(),
"select * from account where accountNum = ? ",
new BeanListHandler<Account>(Account.class),
accountNum);
} catch (SQLException e) {
throw new RuntimeException(e);
}
if (accounts == null || accounts.size() == 0) {
// 如果没有结果就返回null
return null;
} else if (accounts.size() > 1) {
// 如果结果集超过一个就抛异常
throw new RuntimeException("结果集不唯一，数据有问题");
} else {
// 如果有唯一的一个结果就返回
return accounts.get(0);
}
}
}
创建Account模块Service层：UserService.java
package services;
public interface UserService {
/**
* 转账
*
* @param sourceAccount 转出账户
* @param targetAccount 转入账户
* @param money 转账金额
*/
void transfer(String sourceAccount, String targetAccount, Integer money);
}
创建Account模块Service层实现类：UserServiceImpl.java
package services.impl;
import dao.UserDao;
import entity.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import services.UserService;
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
/**
* 转账
*
* @param sourceAccount 转出账户
* @param targetAccount 转入账户
* @param money 转账金额
*/
public void transfer(String sourceAccount, String targetAccount, Integer money) {
// 查询原始账户
Account source = userDao.findAccountByNum(sourceAccount);
// 查询目标账户
Account target = userDao.findAccountByNum(targetAccount);
// 原始账号减钱
source.setMoney(source.getMoney() - money);
// 目标账号加钱
target.setMoney(target.getMoney() + money);
// 更新原始账号
userDao.updateAccount(source);
// 更新目标账号
userDao.updateAccount(target);
System.out.println("转账完毕");
}
}
创建Account模块测试类：AccountTest.java
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import services.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountTest {
@Autowired
private UserService userService;
@Test
public void testTransfer() {
userService.transfer("622200001", "622200002", 100);
}
}
执行结果
缺点分析
在UserServiceImpl.java模拟创建一个代码异常
package services.impl;
import dao.UserDao;
import entity.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import services.UserService;
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
/**
* 转账
*
* @param sourceAccount 转出账户
* @param targetAccount 转入账户
* @param money 转账金额
*/
public void transfer(String sourceAccount, String targetAccount, Integer money) {
// 查询原始账户
Account source = userDao.findAccountByNum(sourceAccount);
// 查询目标账户
Account target = userDao.findAccountByNum(targetAccount);
// 原始账号减钱
source.setMoney(source.getMoney() - money);
// 目标账号加钱
target.setMoney(target.getMoney() + money);
// 更新原始账号
userDao.updateAccount(source);
//模拟创建一个异常
int i = 1/0;
// 更新目标账号
userDao.updateAccount(target);
System.out.println("转账完毕");
}
}
//模拟创建一个异常
int i = 1/0;
异常代码加在了出账账户金额修改之后，入账账户金额修改之前
执行报ArithmeticException错，查看数据库中数据发现出账账户money的列值，转账账户钱减少，收账账户数值却未增加，这就出现了数据的事务问题，破坏了数据的原子性和一致性
引入代理模式解决事务
实现思路介绍
- 创建一个工具类，目的是用于管理数据库的事务，提供事务的开启，提交，回滚等操作；
- 创建一个代理处理器类，目的是生成转账实现类的代理对象，对转账的业务方法提供增强，主要是在数据操作之前，和操作之后干点事，嘿嘿嘿；
- 在 Spring 的配置文件中，通过 xml 文件的标签实例化管理事务的工具类和生成代理对象的处理器类。
代码实现
创建TransactionManager.java
package transaction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import utils.ConnectionUtils;
import java.sql.SQLException;
@Component
public class TransactionManager {
// 数据库连接工具类
@Autowired
private ConnectionUtils connectionUtils;
/**
* 开启事务
*/
public void beginTransaction() {
try {
System.out.println("开启事务");
connectionUtils.getThreadConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 提交事务
*/
public void commit() {
try {
System.out.println("提交事务");
connectionUtils.getThreadConnection().commit();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 回滚事务
*/
public void rollback() {
try {
System.out.println("回滚事务");
connectionUtils.getThreadConnection().rollback();
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 释放连接
*/
public void release() {
try {
System.out.println("释放连接");
connectionUtils.getThreadConnection().close();
} catch (SQLException e) {
e.printStackTrace();
}
connectionUtils.remove();
}
}
创建事务代理工具类：TransactionProxyUtils
此类的核心代码是getAccountService方法，该方法返回代理业务类示例
在代理对象的invoke方法内部，实现对原始被代理对象的增强
package utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import services.UserService;
import transaction.TransactionManager;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
@Component
public class TransactionProxyUtils {
//被代理的业务类接口
@Autowired
private UserService userService;
//提供事务管理的工具类
@Autowired
private TransactionManager transactionManager;
/**
* 获取userService代理对象
*
* @return
*/
public UserService getuserService() {
return (UserService) Proxy.newProxyInstance(
userService.getClass().getClassLoader(),
userService.getClass().getInterfaces(),
new InvocationHandler() {
/**
* 添加事务的支持
*
* @param proxy 被代理的对象实例本身
* @param method 被代理对象正在执行的方法对象
* @param args 正在访问的方法参数对象
* @return
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//
Object rtValue = null;
try {
// 执行操作前开启事务
transactionManager.beginTransaction();
// 执行操作
rtValue = method.invoke(userService, args);
// 执行操作后提交事务
transactionManager.commit();
// 返回结果
return rtValue;
} catch (Exception e) {
// 捕捉到异常执行回滚操作
transactionManager.rollback();
throw new RuntimeException(e);
} finally {
// 最终释放连接
transactionManager.release();
}
}
});
}
}
核心配置文件：applicationContext.xml
添加事务管理bean
<context:component-scan base-package="transaction"/>
配置代理Service
<!--配置代理的service-->
<bean id="transactionProxyAccountService" factory-bean="transactionProxyUtils" factory-method="getuserService"/>
Account模块测试类：AccountTest.java
将原本引入的AccountService实例改为AccountService的事务代理对象
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import services.UserService;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountTest {
@Qualifier("transactionProxyAccountService")
@Autowired
private UserService userService;
@Test
public void testTransfer() {
userService.transfer("622200001", "622200002", 100);
}
}
@Qualifier("transactionProxyAccountService")
运行结果
查看数据库中数据发现并没有改变，说明引入代理模式解决了事务问题，保证了数据的原子性和一致性
缺点分析
- 自定义代理模式代码编写过于臃肿
- 侵入性比较强，代码不够优雅
- 控制事务的实现过于繁琐
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
