切入点表达式说明

匹配方法的执行(常用)

execution(表达式)

表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))

写法说明：

  • 全匹配方式：
    public void org.cjw.service.impl.CustomerServiceImpl.saveCustomer()
  • 访问修饰符可以省略
    void org.cjw.service.impl.CustomerServiceImpl.saveCustomer()
  • 返回值可以使用号，表示任意返回值
    `     org.cjw.service.impl.CustomerServiceImpl.saveCustomer()`
  • 包名可以使用号，表示任意包，但是有几级包，需要写几个:
    * *.*.*.*.CustomerServiceImpl.saveCustomer()
  • 使用..来表示当前包，及其子包
    * org..CustomerServiceImpl.saveCustomer()
  • 类名可以使用号，表示任意类
    `     org..*.saveCustomer()`
  • 方法名可以使用号，表示任意方法
    `     org...()`
  • 参数列表可以使用，表示参数可以是任意数据类型，但是必须有参数
    `     org...(*)`
  • 参数列表可以使用..表示有无参数均可，有参数可以是任意类型
    * org..*.*(..)
  • 全通配方式：
    * *..*.*(..)

更多匹配规则请参考这里

基于XML配置AOP

首先介绍通过XML的方式配置AOP。

搭建环境

第一步：创建一个Java项目

需求：编写一个切面类，在执行insert，update方法，分别在方法执行前、执行后、异常出现后、调用编写统一处理的代码。

—创建一个Java项目，加入Spring框架的基础支持包。

Spring AOP使用 - 图1

第二步：编写业务层类和接口

UserService 接口

  1. public interface UserService {
  3.     void insert();
  5.     void update();
  6. }

业务层UserServiceImpl 实现类

  1. public class UserServiceImpl implements UserService {
  3.     @Override
  4.     public void insert() {
  5.         System.out.println("执行了service层的insert方法");
  6.     }
  8.     @Override
  9.     public void update() {
  10.         System.out.println("执行了service层的update方法");
  11.     }
  12. }

第三步：编写Spring配置文件

引入aop的命名空间

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd 
  7.        http://www.springframework.org/schema/aop 
  8.        http://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!-- 配置UserService -->
  11.     <bean id="userService" class="org.cjw.service.impl.UserServiceImpl" />
  12. </beans>

第四步：测试

—测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class UserServiceTest {
  5.     @Resource(name = "userService")
  6.     private UserService userService;
  8.     @Test
  9.     public void testInsert() {
  10.         userService.insert();
  11.     }
  13.     @Test
  14.     public void testUpdate() {
  15.         userService.update();
  16.     }
  17. }

—测试结果

Spring AOP使用 - 图2

配置AOP

第一步：加入AOP的支持包

AOP 思想必须使用AspectJ语法，而AOP思想不是Spring框架设计出来的，而是叫一个AOP联盟组织提出这种思想，所以开发者需要导入AOP联盟提供的 aspectj.weaver.jar（aspectweaver织入包）。

Spring AOP使用 - 图3

第二步：编写一个切面类

  1. public class TransactionMangerHandler {
  3.     // 前置增强
  4.     public void begin() {
  5.         System.out.println("开启事务");
  6.     }
  8.     // 后置增强
  9.     public void commit() {
  10.         System.out.println("提交事务");
  11.     }
  13.     // 异常增强
  14.     public void rollback() {
  15.         System.out.println("回滚事务");
  16.     }
  18.     // 最终增强
  19.     public void closeSession() {
  20.         System.out.println("关闭session");
  21.     }
  22. }

第三步：配置AOP配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/aop
  8.        http://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!-- 配置UserService -->
  11.     <bean id="userService" class="org.cjw.service.impl.UserServiceImpl" />
  13.     <!-- 配置事务管理器 -->
  14.     <bean id="txManger" class="org.cjw.proxyHandler.TransactionMangerHandler" />
  16.     <!-- 配置aop -->
  17.     <aop:config>
  18.         <!-- 配置切面 -->
  19.         <aop:aspect ref="txManger">
  20.             <!-- 配置切入点：哪些类中的哪些方法需要做增强（where） -->
  21.             <aop:pointcut id="pt" expression="execution(* org.cjw.service..*.*(..))" />
  22.             <!-- 前置增强 -->
  23.             <aop:before method="begin" pointcut-ref="pt" />
  24.             <!-- 后置增强 -->
  25.             <aop:after-returning method="commit" pointcut-ref="pt" />
  26.             <!-- 异常增强 -->
  27.             <aop:after-throwing method="rollback" pointcut-ref="pt" />
  28.             <!-- 最终增强 -->
  29.             <aop:after method="closeSession" pointcut-ref="pt" />
  30.         </aop:aspect>
  31.         <!-- 织入（Weaving）：把切面加入到对象，并创建出代理对象的过程。（该过程由Spring来完成）-->
  32.     </aop:config>
  33. </beans>

第四步：测试

测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration("classpath:applicationContext.xml")
  3. public class UserServiceTest {
  5.     @Resource(name = "userService")
  6.     private UserService userService;
  8.     @Test
  9.     public void testInsert() {
  10.         userService.insert();
  11.     }
  13.     @Test
  14.     public void testUpdate() {
  15.         userService.update();
  16.     }
  17. }

测试结果

Spring AOP使用 - 图4

思考

问题：编写一个切面需要分别编写前置增强、后置增强、异常增强、最终增强，需要使用到4个标签，有没有办法只用一个标签就完成这4种增强呢？

答：使用环绕增强<aop:aorund>

改写切面类

  1. public class TransactionMangerHandler {
  3.     // 环绕增强
  4.     public void allInOne(ProceedingJoinPoint pjp) {
  5.         try {
  6.             begin(); // 前置增强
  7.             pjp.proceed(); // 执行被调用的方法
  8.             commit(); // 后置增强
  9.         } catch (Throwable e) {
  10.             e.printStackTrace();
  11.             rollback(); // 异常增强
  12.         } finally {
  13.             closeSession(); // 最终增强
  14.         }
  15.     }
  17.     // 前置增强
  18.     public void begin() {
  19.         System.out.println("开启事务");
  20.     }
  22.     // 后置增强
  23.     public void commit() {
  24.         System.out.println("提交事务");
  25.     }
  27.     // 异常增强
  28.     public void rollback() {
  29.         System.out.println("回滚事务");
  30.     }
  32.     // 最终增强
  33.     public void closeSession() {
  34.         System.out.println("关闭session");
  35.     }
  36. }

—aop配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans.xsd
  7.        http://www.springframework.org/schema/aop
  8.        http://www.springframework.org/schema/aop/spring-aop.xsd">
  10.     <!-- 配置UserService -->
  11.     <bean id="userService" class="org.cjw.service.impl.UserServiceImpl" />
  13.     <!-- 配置事务管理器 -->
  14.     <bean id="txManger" class="org.cjw.proxyHandler.TransactionMangerHandler" />
  16.     <!-- 配置aop -->
  17.     <aop:config>
  18.         <!-- 配置切面 -->
  19.         <aop:aspect ref="txManger">
  20.             <!-- 配置切入点：哪些类中的哪些方法需要做增强（where） -->
  21.             <aop:pointcut id="pt" expression="execution(* org.cjw.service..*.*(..))" />
  22.             <!-- 环绕增强 -->
  23.             <aop:around method="allInOne" pointcut-ref="pt" />
  24.         </aop:aspect>
  25.         <!-- 织入（Weaving）：把切面加入到对象，并创建出代理对象的过程。（该过程由Spring来完成）-->
  26.     </aop:config>
  27. </beans>

测试代码

同上

测试结果

Spring AOP使用 - 图5

常用标签说明

  • 2.4.1. **<aop:config>**

作用：用于声明aop配置

  • 2.4.2. **<aop:aspect>**

作用： 用于配置切面。

属性：

  1. - id：给切面一个唯一标识。
  2. - ref：引用配置好的切面类bean的id。
  • 2.4.3.<aop:pointcut>

作用：用于配置切入点表达式

属性：

  1. - id：用于给切入点表达式一个唯一标识。
  2. - expression：用于定义切入点表达式。
  • 2.4.4. <aop:before>

作用：用于配置前置通知

属性：

  1. - method：指定通知中方法的名称。
  2. - pointct：定义切入点表达式
  3. - pointcut-ref：指定切入点表达式的引用
  • 2.4.5. <aop:after-returning>

作用：用于配置后置通知，如果出了异常就一定不会调用切面的方法

属性：

  1.  - method：指定通知中方法的名称。
  2. - pointct：定义切入点表达式
  3. - pointcut-ref：指定切入点表达式的引用
  • 2.4.6. <aop:after-throwing>

作用： 用于配置异常通知，只有出了异常才会调用切面对应的方法

属性：

  1. - method：指定通知中方法的名称。
  2. - pointct：定义切入点表达式
  3. - pointcut-ref：指定切入点表达式的引用
  • 2.4.7. <aop:after>

作用：用于配置最终通知，不管出不出异常，都调用切面的方法

属性：

  1. - method：指定通知中方法的名称。
  2. - pointct：定义切入点表达式
  3. - pointcut-ref：指定切入点表达式的引用
  • 2.4.8. <aop:around>

作用：用于配置环绕通知

属性：

  1. - method：指定通知中方法的名称。
  2. - pointct：定义切入点表达式
  3. - pointcut-ref：指定切入点表达式的引用

基于注解配置AOP

接下来介绍基于注解的方式配置AOP。

搭建环境

第一步：创建一个Java项目

同上。

第二步：创建UserService接口及其实现类

  1. public interface UserService {
  3.     void insert();
  5.     void update();
  6. }
  7. @Service
  8. public class UserServiceImpl implements UserService {
  10.     @Override
  11.     public void insert() {
  12.         System.out.println("执行了service层的insert方法");
  13.     }
  14. }

第三步：编写Spring配置类

  1. @Configuration
  2. @ComponentScan(basePackages = "org.cjw")
  3. public class SpringConfig {
  5. }

第四步：测试

测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = SpringConfig.class)
  3. public class UserServiceTest {
  5.     @Autowired
  6.     @Qualifier("userService")
  7.     private UserService userService;
  9.     @Test
  10.     public void testInsert() {
  11.         userService.insert();
  12.     }
  13. }

测试结果

Spring AOP使用 - 图6

配置AOP

第一步：加入AOP的支持包

—注意：必须要导入加入支持AOP的包。

Spring的AOP包基于AspectJ框架，所以必须加入AspectJ—>aspectjweaver.jar。

第二步：编写一个切面类

  1. @Component
  2. @Aspect
  3. public class TransactionMangerHandler {
  5.     // 环绕增强
  6.     @Around("pointcut()")
  7.     public void allInOne(ProceedingJoinPoint pjp) {
  8.         try {
  9.             begin(); // 前置增强
  10.             pjp.proceed(); // 执行被调用的方法
  11.             commit(); // 后置增强
  12.         } catch (Throwable e) {
  13.             e.printStackTrace();
  14.             rollback(); // 异常增强
  15.         } finally {
  16.             closeSession(); // 最终增强
  17.         }
  18.     }
  20.     @Pointcut("execution(* org.cjw..*.*(..))") // 等价于<aop:pointcut id="等价于方法名" expression="execution(* org.cjw..*.*(..))">
  21.     public void pointcut() {}
  23.     // 前置增强
  24.     @Before("pointcut()") // 等价于<aop:before method="begin" pointcut-ref="pt" />
  25.     public void begin() {
  26.         System.out.println("开启事务");
  27.     }
  29.     // 后置增强
  30.     @AfterReturning("pointcut()") // 等价于<aop:after-returning method="commit" pointcut-ref="pt" />
  31.     public void commit() {
  32.         System.out.println("提交事务");
  33.     }
  35.     // 异常增强
  36.     @AfterThrowing("pointcut()") // 等价于<aop:after-throwing method="rollback" pointcut-ref="pt" />
  37.     public void rollback() {
  38.         System.out.println("回滚事务");
  39.     }
  41.     // 最终增强
  42.     @After("pointcut()") // 等价于<aop:after method="closeSession" pointcut-ref="pt" />
  43.     public void closeSession() {
  44.         System.out.println("关闭session");
  45.     }
  46. }

第三步：配置AOP配置

  1. @Configuration
  2. @ComponentScan(basePackages = "org.cjw")
  3. @EnableAspectJAutoProxy // 开启注解配置AOP
  4. public class SpringConfig {
  6. }

第四步：测试

—测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = SpringConfig.class)
  3. public class UserServiceTest {
  5.     @Autowired
  6.     @Qualifier("userService")
  7.     private UserService userService;
  9.     @Test
  10.     public void testInsert() {
  11.         userService.insert();
  12.     }
  13. }

测试结果

Spring AOP使用 - 图7

常用注解

  • @Aspect

作用：把当前类声明为切面类。

  • @Before

作用：把当前方法看成是前置通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

  • @AfterReturning

作用：把当前方法看成是最终通知。报异常，就不执行。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

  • @AfterThrowing

作用：把当前方法看成是异常通知。只有报异常才执行

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

例子：

Spring AOP使用 - 图8

  • @After

作用：把当前方法看成是后置通知。不管报不报异常都执行

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

  • @Around

作用：把当前方法看成是环绕通知。

属性：

value：用于指定切入点表达式，还可以指定切入点表达式的引用。

  • @Pointcut

作用：指定切入点表达式

属性：

value：指定表达式的内容

综合例子

  1. @Aspect
  2. @Component
  3. public class NotVeryUsefulAspect {
  4.     @AfterReturning(value="execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(..))")
  5.     private void logReceiver(){
  6.         System.out.println("切入点logReceiver...");
  7.     }
  9.     @Pointcut(value="execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(..)) && args(param)")
  10.     private void pointcut(String param){ 
  11.         System.out.println("切入点pointcut()"+param);
  12.     }
  14.     //方法体将不执行
  15.     @Pointcut("within(com.cn.spring.aspectj.*)")
  16.     public String inWebLayer() {
  17.         System.out.println("切入点inWebLayer()");
  18.         return "返回值加载";
  19.     }
  21.     @Before(value="inWebLayer()")
  22.         private void beforeinWebLayer(){ 
  23.         System.out.println("beforeinWebLayer~~");
  24.     }
  26.     @Before(value="pointcut(param)")
  27.         private void beforePointcut(String param){ 
  28.         System.out.println("beforePointcut:"+param);
  29.     }
  32.     @AfterReturning(pointcut="inWebLayer()",returning="retVal")
  33.         public void doAccessCheck(Object retVal) {
  34.         System.out.println("doAccessCheck:"+retVal);
  35.     }
  37.     @Around(value="execution(* com.cn.spring.aspectj.NotVeryUsefulAspectService.*(..))")
  38.     private Object aroundLayer(ProceedingJoinPoint pjp) throws Throwable{ 
  39.         // start stopwatch
  40.         Object retVal = pjp.proceed();
  41.         // stop stopwatch
  42.         System.out.println("aroundLayer~~");
  43.         return retVal;
  44.     }
  45. }

Spring AOP使用小结

Spring AOP xml配置

(1) 在xml配置文件中引入新的aop命名空间。

(2) Springaop XML配置标签

<aop:config> 开启aop配置，aop所有配置都在此标签内部配置

  1. <aop:ponitcut exepression=”切入点语法” id=””>配置切入点

  2. <aop:apect ref=”引入要增强的bean（事务管理器）” > 配置切面

    a.<aop:before>前置通知
    b.<aop:aftereturning>后置通知
    c.<aop:afterthrowing>异常通知
    d.<aop:after>最终通知
    e.<aop:around>环绕通知

Spring AOP 注解配置

(1) 在配置文件/配置类开启注解配置。

  1. ① xml：`<aop:aspectj-autoproxy/>`<br />    ② annotation：在java配置类中贴上`@EnableAspectJAutoProxt`注解，作用等同于在xml配置文件中编写`<aop:aspectj-autoproxy>`

(2) @Aspect 在类贴上这个注解，把对应的类当前切面配置类。

(3) @Pointcut 切入点注解

(4)@Before前置通知注解

(5)@After 后置通知注解

(6)@Aftertrhowing异常通知注解

(7)@Afterreturing 最终通知注解

(8) @Around环绕通知注解