Spring基于XML的AOP配置
以转账业务为例，利用spring提供的强大的aop配置切面！
大致原理就不在这里阐述了，如果需要，请先移步Spring中的AOP【面向切面编程】,数据库配置，案例演示都是基于上一篇演示的案例三、使用动态代理阐述spring的AOP功能；然后再阅读此篇文章，整个思路就清晰了。
一、AOP配置详解
对每一步aop配置进行详解，配置文件为核心配置文件
applicationContext.xml，项目的完整代码请阅读【二、项目完整代码】
1). 导入相关约束
可以在spring的官网去拷贝；比如，访问spring-core
ctrl + f,搜索xmlns:aop, 拷贝对应的约束即可
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 2)... -->
2). 配置spring的ioc
<!-- 配置spring的ioc -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
<property name="queryRunner" ref="queryRunner"></property>
<property name="connectionUtils" ref="connectionUtils"></property>
</bean>
<!-- 配置 queryRunner,
为了使用事务，不需要独立给queryRunner注入dataSource
由于不需要提供独立的数据源，连接对象都是从容器中取，所以，不需要设置scope="prototype"-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner"></bean>
<!-- 配置connectionUtils 提供与线程绑定的连接对象 -->
<bean id="connectionUtils" class="com.itheima.utils.ConnectionUtils">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_01"></property>
<property name="user" value="root"></property>
<property name="password" value="abc123"></property>
</bean>
<!-- 3). -->
3). 配置通知Bean【代理对象执行增强的逻辑的相关方法集合类】
<!-- 配置TransactionManager 进行事务操作的通知类 -->
<bean id="transactionManager" class="com.itheima.utils.TransactionManager">
<property name="connectionUtils" ref="connectionUtils"></property>
</bean>
<!-- 4)... -->
4). 使用aop:config表明开始AOP的配置
<!-- 配置AOP -->
<aop:config>
<!-- 5)... -->
</aop:config>
5). 使用aop:aspect标签配置切面【相当于一个代理类的配置】
- aop:aspect标签有两个属性
- id属性：给切面提供一个唯一标志
- ref属性：指定通知类Bean的id
<!-- 配置AOP -->
<aop:config>
<!-- 配置切入点表达式，全局作用 -->
<!-- 配置切面 -->
<aop:aspect
id="transferAdvice" -- 给切面提供一个唯一标志
ref="transactionManager"> -- 指定通知类Bean的id
<!-- 配置切入点表达式，局部作用 -->
<!-- 配置各种通知类型 -->
</aop:aspect>
</aop:config>
6). 配置通知类型
通知类型就是在切入点（被代理方法）前后对应的一些增强方法，分为【前置通知】、【后置通知】、【异常通知】、【最终通知】、【环绕通知】如下图
通知的类型.jpg
其中的【环绕通知】相当于代理对象的invoke方法，可以完全替代前置、后置、异常、最终通知
1.几种通知对应的标签
| 通知类型 | 对应的标签 |
|---|---|
| 前置通知 | <aop:before ... |
| 后置通知 | <aop:after-returning ... |
| 异常通知 | <aop:after-throwing ... |
| 最终通知 | <aop:after ... |
| 环绕通知 | <aop:around ... |
2.通知标签中的属性
-
method属性：指定通知类中对应的增强方法(本例中上面
3). 配置通知Bean【代理对象执行增强的逻辑的相关方法集合类】) -
pointcut属性：指定【切入点表达式】(下一小结
7). pointcut切入点表达式详解介绍)，该表达式的含义是指对业务层中那些方法进行增强（被代理的方法）。 - pointcut-ref属性：指定抽离的的切入点表达式。
3.提示
介绍了下面的【切入点表达式】之后再提供代码
7). pointcut切入点表达式详解
【切入点】为被代理对象执行的方法，【切入点表达式】是为了匹配被代理对象的方法而创建的一种规则，方便匹配切入点； 可以将切入点表达式抽取出来，简化使用，避免配置冗余。
1. 切入点表达式的一些写法
格式：
execution(表达式);其中的【表达式】格式为返回值 包名.包名...类名.方法名(参数列表)
-
标准的表达式写法：
public void com.itheima.service.impl.AccountServiceImpl.transfer()
-
省略修饰符：
void com.itheima.service.impl.AccountServiceImpl.transfer()
-
返回值可以使用通配符：
* com.itheima.service.impl.AccountServiceImpl.transfer()
-
包名可以使用通配符，表示任意包。有几个包，就需要些集合
*.* *.*.*.*.AccountServiceImpl.transfer()
-
包名可以使用..表示当前包及其子包
* *..AccountServiceImpl.transfer()
-
类名和方法名都可以使用*来实现统配
* *..*.*()
-
参数类型
- 直接写数据类型
- 基本类型直接写名称
* *..AccountServiceImpl.transfer(int)
- 引用类型要写全限定类名
* *..AccountServiceImpl.transfer(java.lang.Integer, java.lang.Integer,java.lang.Float)
- 使用
*表示任意参数类型，个数要与匹配的参数一致* *..AccountServiceImpl.transfer(*,*,*)
- 可以使用
..表示有无参数均可，有参数是任意类型* *..AccountServiceImpl.transfer(..)
- 基本类型直接写名称
- 直接写数据类型
-
全统配写法【不建议】
* *..*.*(..)
-
【实际开发中常用的写法】：切到业务层实现类下的所有方法
* com.itheima.service.impl.*.*(..)
2.配置公共切入点表达式
将切入点表达式抽离出来，以便复用；此标签写在aop:aspect标签内部只能当前切面使用。它还可以写在aop:aspect标签外部，此时所有切面都可以使用【根据约束的要求，要写到外上面】
- 对应的标签：
<aop:pointcut ...属性如下- id:用于制定表达式的唯一标识
- expression：表达式内容
execution(表达式)
<aop:config>
-- 全局的切入点表达式
<aop:pointcut id="pt1" expression="execution(
* *..AccountServiceImpl.transfer(java.lang.Integer, java.lang.Integer,java.lang.Float)
)"></aop:pointcut>
<aop:aspect id="transferAdvice" ref="transactionManager">
-- 局部的切入点表达式
<aop:pointcut id="pt1" expression="execution(
* *..AccountServiceImpl.transfer(java.lang.Integer, java.lang.Integer,java.lang.Float)
)"></aop:pointcut>
</aop:aspect>
</aop:config>
6)+7). 配置展示
1.配置前置、后置、异常、最终通知
<!-- 配置AOP -->
<aop:config>
<!-- 配置切面 -->
<aop:aspect id="transferAdvice" ref="transactionManager">
<!--此标签写在aop:aspect标签内部只能当前切面使用。
它还可以写在aop:aspect标签外部，此时所有切面都
可以使用【根据约束的要求，要写到外上面】-->
<aop:pointcut -- 配置切入点表达式 给切入点表达式去一个别名
id="pt1" -- 用于制定表达式的唯一标识
expression="execution( -- 制定表达式内容
* *..AccountServiceImpl.transfer(java.lang.Integer, java.lang.Integer,java.lang.Float)
)"></aop:pointcut>
<aop:before -- “try 前置通知 invoke” ：在切入点方法执行之前执行
method="beginTransaction" -- 指定通知的对应增强方法
pointcut="execution( -- 直接使用切入点表达式
* *..AccountServiceImpl.transfer(*,*,*)
)"></aop:before>
<aop:after-returning -- “try invoke 后置通知” 在切入点方法【成功】执行之后执行，否则不执行
method="commit"
pointcut-ref="pt1" -- 使用抽离的切入点表达式
></aop:after-returning>
<aop:after-throwing -- “catch 异常通知” 在切入点方法【异常】抛出后执行，否则不执行,与后置通知互斥
method="rollback"
pointcut-ref="pt1"></aop:after-throwing>
<aop:after -- “finally 最终通知”
method="release"
pointcut-ref="pt1"></aop:after>
</aop:aspect>
</aop:config>
2.配置环绕通知【如果配置环绕通知，就不要配置前置、后置、异常、最终通知】
当配置了环绕通知后，切入点方法没有执行，而通知方法执行了;如果要配置环绕通知，就不需要配置其他的通知了，环绕通知的形式就是把动态代理的实现方式交给开发者，而不是在核心配置文件中进行配置！
<!-- 配置AOP -->
<aop:config>
<!-- 配置切面 -->
<aop:aspect id="transferAdvice" ref="transactionManager">
<aop:pointcut -- 配置切入点表达式 给切入点表达式去一个别名
id="pt1" -- 用于制定表达式的唯一标识
expression="execution( -- 制定表达式内容
* *..AccountServiceImpl.transfer(java.lang.Integer, java.lang.Integer,java.lang.Float)
)"></aop:pointcut>
-- @=)@环绕通知@(=@, 完全替代上面用配置的方式实现的增强通知
-- 相当于代理对象的invoke方法 详细的注释在TransactionManager类中 ，如下
<aop:around method="around" pointcut-ref="pt1"></aop:around>
</aop:aspect>
</aop:config>
【*】环绕通知配置TransactionManager
Spring框架为我们提供了一个接口：
ProceedingJoinPoint该接口有一个方法proceed(),此方法就相当于明确调用切入点方法。该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。【spring中环绕通知】是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式
package com.itheima.utils;
import org.aspectj.lang.ProceedingJoinPoint;
import java.sql.SQLException;
/** 和事务相关的工具类，包含了开启事务、提交事务、回滚事务和释放连接 */
public class TransactionManager {
private ConnectionUtils connectionUtils;
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
/** @=)@环绕通知对应的方法 -- 核心配置 @(=@ */
public Object around(ProceedingJoinPoint pjp) {
Object rtValue = null;
try {
// 得到方法执行所需的参数
Object[] args = pjp.getArgs();
// 前置通知
this.beginTransaction();
// 明确调用业务层方法（切入点方法）
rtValue = pjp.proceed(args);
// 后置通知
this.commit();
return rtValue;
} catch (Throwable e) {
// 异常通知
this.rollback();
throw new RuntimeException(e);
} finally {
// 最终通知
this.release();
}
}
/** 开启事务 前置通知 */
public void beginTransaction(){
try {
connectionUtils.getThreadConnection().setAutoCommit(false);
System.out.println("事务已经开启");
} catch (SQLException e) { e.printStackTrace(); }
}
/** 提交事务 后置通知 */
public void commit(){
try {
connectionUtils.getThreadConnection().commit();
System.out.println("事务已经提交");
} catch (SQLException e) { e.printStackTrace(); }
}
/** 回滚事务 异常通知 */
public void rollback(){
try {
connectionUtils.getThreadConnection().rollback();
System.out.println("事务执行过程出现异常，已经回滚");
} catch (SQLException e) { e.printStackTrace(); }
}
/** 释放资源 最终通知 */
public void release(){
try {
// 首先:归还连接对象到连接池
connectionUtils.getThreadConnection().close();
System.out.println("连接对象已归还连接池");
// 然后:将当前的连接和当前线程解绑
connectionUtils.removeConnection();
System.out.println("连接对象已与当前线程解绑");
} catch (SQLException e) { e.printStackTrace(); }
}
}
二、项目完整代码
1). 项目结构
Spring基于XML的AOP配置项目结构.png
2). maven坐标 pom.xml
<dependencies>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.41</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>5.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>5.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
<scope>test</scope>
</dependency>
<!-- 切入点表达式解析的jar包 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.7</version>
</dependency>
</dependencies>
3). javaBean/pojo 代码
此处省略get/set/toString方法,可以通过工具自动生成！
package com.itheima.domain;
public class Account {
private Integer id;
private String name;
private Float money;
...
}
4). utils工具
1. ConnectionUtils
获取与当前线程绑定的数据库连接对象
package com.itheima.utils;
import javax.sql.DataSource;
import java.sql.Connection;
public class ConnectionUtils {
/**
ThreadLocal对象内维护了一个键值对，类似于Map集合，但是
不是Map,key为当前访问线程，value为自定义泛型，每个不同的
线程拿到的value对象是不同的，同一个线程拿到的value对象是相同的
这个机制很好的满足的事务对Connection对应唯一的要求！
*/
private ThreadLocal<Connection> threadLocal = new ThreadLocal();
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public Connection getThreadConnection(){
try {
// 从本地线程中获取连接对象并返回
Connection connection = threadLocal.get();
if(connection == null){
//第一次调用该方法时当前线程中并未有connection对象
//从连接池获取一个连接
connection = dataSource.getConnection();
//将从连接池获取的连接和当前的线程绑定
threadLocal.set(connection);
}
// 返回当前线程的连接
return connection;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void removeConnection(){
//将连接对象和当前线程解绑
threadLocal.remove();
}
}
2.TransactionManager
代码在上面
【*】环绕通知配置TransactionManager
5). dao持久层代码
package com.itheima.dao;
import com.itheima.domain.Account;
import java.sql.SQLException;
public interface AccountDao {
/** 根据id查询账户的余额 */
public Account queryMoney(Integer id) throws SQLException;
/** 根据id更新账户的余额 */
public int updateMoney(Integer id, Float money) throws SQLException;
}
package com.itheima.dao.impl;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import java.sql.SQLException;
public class AccountDaoImpl implements AccountDao {
private QueryRunner queryRunner;
private ConnectionUtils connectionUtils;
public void setQueryRunner(QueryRunner queryRunner) {
this.queryRunner = queryRunner;
}
public void setConnectionUtils(ConnectionUtils connectionUtils) {
this.connectionUtils = connectionUtils;
}
/** @事务
* 根据id查询账户的余额，将异常显示抛出 */
@Override
public Account queryMoney(Integer id) throws SQLException {
return queryRunner.query(connectionUtils.getThreadConnection(),"select money from account where id = ?",
new BeanHandler<Account>(Account.class), id);
}
/** @事务
* 根据id更新账户的余额, 将异常显示抛出 */
@Override
public int updateMoney(Integer id, Float money) throws SQLException {
return queryRunner.update(connectionUtils.getThreadConnection(),"update account set money = ? where id = ?", money, id);
}
}
6). service业务层代码
package com.itheima.service;
public interface AccountService {
/** 转账业务 */
public boolean transfer(Integer fromId, Integer toId, Float money) throws Exception;
}
package com.itheima.service.impl;
import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
/** @事务
* 转账业务 */
@Override
public boolean transfer(Integer fromId, Integer toId, Float money) throws Exception {
// 1. 查询原账户余额
Account fromMoney = accountDao.queryMoney(fromId);
if (fromMoney.getMoney() < money) {
throw new RuntimeException("账户余额不足，无法完成转账");
}
// 2. 查询被转入账户的余额
Account toMoney = accountDao.queryMoney(toId);
// 3. 扣除原账户的money
accountDao.updateMoney(fromId, fromMoney.getMoney() - money);
// 显示抛出一个异常。
//int a = 8 / 0;
// 4. 添加被转入账户的余额
accountDao.updateMoney(toId, toMoney.getMoney() + money);
return true;
}
}
7). 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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
<property name="queryRunner" ref="queryRunner"></property>
<property name="connectionUtils" ref="connectionUtils"></property>
</bean>
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner"></bean>
<bean id="connectionUtils" class="com.itheima.utils.ConnectionUtils">
<property name="dataSource" ref="dataSource"></property>
</bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_01"></property>
<property name="user" value="root"></property>
<property name="password" value="abc123"></property>
</bean>
<bean id="transactionManager" class="com.itheima.utils.TransactionManager">
<property name="connectionUtils" ref="connectionUtils"></property>
</bean>
<aop:config>
<aop:aspect id="transferAdvice" ref="transactionManager">
<aop:pointcut id="pt1" expression="execution(
* *..AccountServiceImpl.transfer(java.lang.Integer, java.lang.Integer,java.lang.Float)
)"></aop:pointcut>
<aop:before method="beginTransaction" pointcut="execution(
* *..AccountServiceImpl.transfer(*,*,*)
)"></aop:before>
<aop:after-returning method="commit" pointcut-ref="pt1"></aop:after-returning>
<aop:after-throwing method="rollback" pointcut-ref="pt1"></aop:after-throwing>
<aop:after method="release" pointcut-ref="pt1"></aop:after>
<!-- <aop:around method="around" pointcut-ref="pt1"></aop:around> -->
</aop:aspect>
</aop:config>
</beans>
8). test测试代码
package com.itheima.service;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class MyTest {
@Autowired
private ApplicationContext ac;
/** 转账测试 */
@Test
public void testTransfer() throws Exception {
AccountService service = (AccountService)ac.getBean("accountService");
boolean res = service.transfer(4, 2, 10F);
System.out.println(res);
}
}
