1 介绍

1.1 什么是AOP

  • AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。

    1.2 为什么需要AOP

    想象下面的场景，开发中在多个模块间有某段重复的代码，我们通常是怎么处理的？显然，没有人会靠“复制粘贴”吧。在传统的面向过程编程中，我们也会将这段代码，抽象成一个方法，然后在需要的地方分别调用这个方法，这样当这段代码需要修改时，我们只需要改变这个方法就可以了。然而需求总是变化的，有一天，新增了一个需求，需要再多出做修改，我们需要再抽象出一个方法，然后再在需要的地方分别调用这个方法，又或者我们不需要这个方法了，我们还是得删除掉每一处调用该方法的地方。实际上涉及到多个地方具有相同的修改的问题我们都可以通过 AOP 来解决。

    2 API说明

    2.1 AOP术语

  • 通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。

  • 连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用、异常的抛出。在 Spring AOP 中，连接点总是方法的调用。
  • 切点（PointCut）: 可以插入增强处理的连接点。
  • 切面（Aspect）: 切面是通知和切点的结合。
  • 引入（Introduction）：引入允许我们向现有的类添加新的方法或者属性。
  • 织入（Weaving）: 将增强处理添加到目标对象中，并创建一个被增强的对象，这个过程就是织入。

    2.2 AspectJ 切点指示器

    | AspectJ切点指示器 | 描述 | | —- | —- | | arg() | 限制连接点匹配参数为指定类型的执行方法 | | @args() | 限制连接点匹配参数由指定注解标注的执行方法 | | execution() | 用于匹配是连接点的执行方法 | | this() | 限制连接点匹配AOP代理的Bean引用为指定类型的类 | | target() | 限制连接点匹配目标对象为指定类型的类 | | @target() | 限制连接点匹配特定的执行对象，这些对象对应的类药具备指定类型的注解 | | within() | 限制连接点匹配指定的类型 | | @within() | 限制连接点匹配指定注解锁标注的类型 | | @annotation | 限制匹配带有指定注解连接点 |

2.3 通知类型

注解 通知
@Before 通知方法会在目标方法调用之前执行
@After 通知方法会在目标方法返回或异常后调用
@AfterReturning 通知方法会在目标方法返回后调用
@AfterThrowing 通知方法会在目标方法抛出异常后调用
@Around 通知方法会将目标方法封装起来

3 AOP底层原理

3.1 概述

  • AOP的底层原理：

    • ①使用JDK的动态代理。

    • ②使用CGLIB的动态代理。

      3.2 应用示例

      3.2.1 自定义AOP-JDK动态代理

      3.2.1.1 创建用户增加和修改方法

      ```java public interface UserDao {

      int add(int a ,int b);

      String update(String id);

}

  1. <a name="du4gy"></a>
  2. ### 3.2.1.2 实现用户接口
  3. ```java
  4. public class UserDaoImpl implements UserDao {
  5.     @Override
  6.     public int add(int a, int b) {
  8.         System.out.println("add...执行了");
  10.         return a + b;
  11.     }
  13.     @Override
  14.     public String update(String id) {
  16.         System.out.println("update...执行了");
  18.         return id;
  19.     }
  20. }

3.2.1.3 JDK动态代理测试

  1. public class SpringTest {
  2.     public static void main(String[] args) {
  4.         UserDaoImpl userDao = new UserDaoImpl();
  6.         // 代理用户类，
  7.         UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), new InvocationHandler() {
  8.             // 每次执行方法前后调用提示内容
  9.             @Override
  10.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  11.                 // 方法执行前的提示内容
  12.                 System.out.println("在" + method.getName() + "之前执行");
  13.                 // 主方法调用
  14.                 Object result = method.invoke(userDao, args);
  15.                 // 方法执行后的提示内容
  16.                 System.out.println("在" + method.getName() + "之后执行");
  17.                 return result;
  18.             }
  19.         });
  21.         // 调用代理后的方法
  22.         int result = proxy.add(1, 2);
  23.         System.out.println("result = " + result);
  25.         String id = proxy.update("1");
  26.         System.out.println("id = " + id);
  28.     }
  29. }

3.2.1.4 结果

  1. 在add之前执行
  2. add...执行了
  3. 在add之后执行
  4. result = 3
  5. 在update之前执行
  6. update...执行了
  7. 在update之后执行
  8. id = 1

4 入门案例

4.1 注解方式

4.1.1 依赖引入

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>org.springframework</groupId>
  4.     <artifactId>spring-context</artifactId>
  5.     <version>5.2.7.RELEASE</version>
  6.   </dependency>
  7.   <dependency>
  8.     <groupId>org.springframework</groupId>
  9.     <artifactId>spring-aop</artifactId>
  10.     <version>5.2.7.RELEASE</version>
  11.   </dependency>
  12.   <dependency>
  13.     <groupId>org.springframework</groupId>
  14.     <artifactId>spring-aspects</artifactId>
  15.     <version>5.2.7.RELEASE</version>
  16.   </dependency>
  17.   <dependency>
  18.     <groupId>com.alibaba</groupId>
  19.     <artifactId>druid</artifactId>
  20.     <version>1.1.23</version>
  21.   </dependency>
  22.   <dependency>
  23.     <groupId>junit</groupId>
  24.     <artifactId>junit</artifactId>
  25.     <version>RELEASE</version>
  26.     <scope>test</scope>
  27.   </dependency>
  28. </dependencies>

4.1.2 创建用户的增加方法

  1. package com.hikktn.service;
  3. public interface User {
  5.     void add();
  6. }

4.1.3 实现用户的增加方法

  1. package com.hikktn.service.impl;
  3. import com.hikktn.service.User;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class UserImpl implements User {
  9.     @Override
  10.     public void add() {
  11.         System.out.println("add");
  12.     }
  13. }

4.1.4 切面类实现

  1. package com.hikktn.config;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.*;
  5. import org.springframework.context.annotation.ComponentScan;
  6. import org.springframework.context.annotation.EnableAspectJAutoProxy;
  7. import org.springframework.core.annotation.Order;
  8. import org.springframework.stereotype.Component;
  10. /**
  11.  * 增强的类
  12.  */
  13. @Component
  14. @Aspect //生成代理对象
  15. @Order(1) //在多个增强类对同一个方法进行增强，设置增强类的优先级，@Order中的value属性值越小优先级越高
  16. public class UserAspect {
  17.     /**
  18.      * 切入点表达式
  19.      */
  20.     @Pointcut("execution(* com.hikktn.service.impl.UserImpl.add(..))")
  21.     public void pointcut() {
  22.     }
  24.     /**
  25.      * 前置通知
  26.      */
  27.     @Before(value = "pointcut()")
  28.     public void beforeAdd() {
  29.         System.out.println("before add ...");
  30.     }
  32.     /**
  33.      * 后置通知
  34.      */
  35.     @AfterReturning(value = "pointcut()", returning = "obj")
  36.     public void afterReturningAdd(Object obj) {
  37.         System.out.println("afterReturning add ..." + obj);
  38.     }
  41.     /**
  42.      * 环绕通知
  43.      */
  44.     @Around(value = "pointcut()")
  45.     public void aroundAdd(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  46.         System.out.println("环绕之前");
  47.         proceedingJoinPoint.proceed();
  48.         System.out.println("环绕之后");
  49.     }
  51.     /**
  52.      * 异常通知
  53.      */
  54.     @AfterThrowing(value = "pointcut()", throwing = "ex")
  55.     public void afterThrowingAdd(Exception ex) {
  56.         System.out.println("afterThrowing add ..." + ex);
  57.     }
  59.     /**
  60.      * 最终通知
  61.      */
  62.     @After(value = "pointcut()")
  63.     public void afterAdd() {
  64.         System.out.println("after add ...");
  65.     }
  66. }

4.1.5 XML配置

applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns:aop="http://www.springframework.org/schema/aop"
  5.        xmlns="http://www.springframework.org/schema/beans"
  6.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         http://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         http://www.springframework.org/schema/context/spring-context.xsd
  10.         http://www.springframework.org/schema/aop
  11.         http://www.springframework.org/schema/aop/spring-aop.xsd">
  13.     <!-- 开启组件扫描 -->
  14.     <context:component-scan base-package="com.hikktn"></context:component-scan>
  17.     <!-- 开启aspectj生成代理对象 -->
  18.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  19. </beans>

4.1.6 测试

  1. public class SpringTest {
  3.     public static void main(String[] args) {
  4.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  5.         User user = context.getBean(User.class);
  6.         user.add();
  7.     }
  9. }

4.1.7 结果

  1. 环绕之前
  2. before add ...
  3. add
  4. afterReturning add ...null
  5. after add ...
  6. 环绕之后

4.1.8 全注解方式

  1. package com.hikktn.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
  7. @Configuration
  8. @ComponentScan(value = "com.hikktn")
  9. @EnableAspectJAutoProxy(proxyTargetClass = true)
  10. public class AppConfig {
  11. }

4.1.9 测试

  1. public class SpringTest {
  3.     public static void main(String[] args) {
  4. //        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  5.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
  6.         User user = context.getBean(User.class);
  7.         user.add();
  8.     }
  10. }

4.1.10 结果

  1. 环绕之前
  2. before add ...
  3. add
  4. afterReturning add ...null
  5. after add ...
  6. 环绕之后

4.2 XML方式

4.2.1 依赖引入

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>org.springframework</groupId>
  4.     <artifactId>spring-context</artifactId>
  5.     <version>5.2.7.RELEASE</version>
  6.   </dependency>
  7.   <dependency>
  8.     <groupId>org.springframework</groupId>
  9.     <artifactId>spring-aop</artifactId>
  10.     <version>5.2.7.RELEASE</version>
  11.   </dependency>
  12.   <dependency>
  13.     <groupId>org.springframework</groupId>
  14.     <artifactId>spring-aspects</artifactId>
  15.     <version>5.2.7.RELEASE</version>
  16.   </dependency>
  17.   <dependency>
  18.     <groupId>com.alibaba</groupId>
  19.     <artifactId>druid</artifactId>
  20.     <version>1.1.23</version>
  21.   </dependency>
  22.   <dependency>
  23.     <groupId>junit</groupId>
  24.     <artifactId>junit</artifactId>
  25.     <version>RELEASE</version>
  26.     <scope>test</scope>
  27.   </dependency>
  28. </dependencies>

4.2.2 创建用户的增加方法

  1. package com.hikktn.service;
  3. public interface User {
  5.     void add();
  6. }

4.2.3 实现用户的增加方法

  1. package com.hikktn.service;
  3. public interface User {
  5.     void add();
  6. }

4.2.4 切面类

  1. package com.hikktn.config;
  3. /**
  4.  * 增强的类
  5.  */
  6. public class UserAspect {
  8.     /**
  9.      * 前置通知
  10.      */
  11.     public void beforeAdd() {
  12.         System.out.println("before add ...");
  13.     }
  14. }

4.2.5 XML配置

  • applicationContext.xml ```xml <?xml version=”1.0” encoding=”UTF-8”?>

    1.   <!-- 配置切入点 -->
    2.   <aop:pointcut id="pointcut" expression="execution(* com.hikktn.service.User.add(..)))"/>
    3.   <!-- 配置切面 -->
    4.   <aop:aspect ref="userAspect">
    5.       <!-- 配置增强作用在具体的方法上 -->
    6.       <aop:before method="beforeAdd" pointcut-ref="pointcut"></aop:before>
    7.   </aop:aspect>

  1. <a name="gsFH9"></a>
  2. ### 4.2.6 测试
  3. ```java
  4. import com.hikktn.service.User;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  8. public class SpringTest {
  9.     public static void main(String[] args) {
  10.         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
  12.         User user = context.getBean(User.class);
  14.         user.add();
  15.     }
  16. }

4.2.7 结果

  1. before add ...
  2. add

4.3 注解多参数方式

4.3.1 依赖引入

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>org.springframework</groupId>
  4.     <artifactId>spring-context</artifactId>
  5.     <version>5.2.7.RELEASE</version>
  6.   </dependency>
  7.   <dependency>
  8.     <groupId>org.springframework</groupId>
  9.     <artifactId>spring-aop</artifactId>
  10.     <version>5.2.7.RELEASE</version>
  11.   </dependency>
  12.   <dependency>
  13.     <groupId>org.springframework</groupId>
  14.     <artifactId>spring-aspects</artifactId>
  15.     <version>5.2.7.RELEASE</version>
  16.   </dependency>
  17.   <dependency>
  18.     <groupId>com.alibaba</groupId>
  19.     <artifactId>druid</artifactId>
  20.     <version>1.1.23</version>
  21.   </dependency>
  22.   <dependency>
  23.     <groupId>junit</groupId>
  24.     <artifactId>junit</artifactId>
  25.     <version>RELEASE</version>
  26.     <scope>test</scope>
  27.   </dependency>
  28. </dependencies>

4.3.2 创建购买接口方法

  1. package com.hikktn.service;
  3. public interface IBuy {
  4.     String buy(double price);
  5. }

4.3.3 实现购买方法-男孩

  1. package com.hikktn.service.impl;
  3. import com.hikktn.service.IBuy;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class Boy implements IBuy {
  8.     @Override
  9.     public String buy(double price) {
  10.         System.out.println(String.format("男孩花了%s元买了一个游戏机", price));
  11.         return "游戏机";
  12.     }
  13. }

4.3.4 实现购买方法-女孩

  1. package com.hikktn.service.impl;
  3. import com.hikktn.service.IBuy;
  4. import org.springframework.stereotype.Component;
  6. @Component
  7. public class Girl implements IBuy {
  9.     @Override
  10.     public String buy(double price) {
  11.         System.out.println(String.format("女孩花了%s元买了一件漂亮的衣服", price));
  12.         return "衣服";
  13.     }
  15. }

4.3.5 切面类

  1. package com.hikktn.config;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.Around;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Before;
  7. import org.aspectj.lang.annotation.Pointcut;
  8. import org.springframework.stereotype.Component;
  10. @Aspect
  11. @Component
  12. public class BuyAspectJ {
  14.     /**
  15.      * 该切面方法只会在Girl类调用起作用
  16.      */
  17.     @Before("execution(* com.hikktn.service.IBuy.buy(..)) && within(com.hikktn.service.impl.*) && bean(girl)")
  18.     public void hehe(){
  19.         System.out.println("女孩超级喜欢的东西");
  20.     }
  22.     @Pointcut("execution(String com.hikktn.service.IBuy.buy(double)) && args(price) && bean(girl)")
  23.     public void gif(double price) {
  24.     }
  26.     @Around("gif(price)")
  27.     public String hehe(ProceedingJoinPoint pj, double price){
  28.         try {
  29.             pj.proceed();
  30.             if (price > 68) {
  31.                 System.out.println("女孩买衣服超过了68元，赠送一双袜子");
  32.                 return "衣服和袜子";
  33.             }
  34.         } catch (Throwable throwable) {
  35.             throwable.printStackTrace();
  36.         }
  37.         return "衣服";
  38.     }
  39. }

4.3.6 配置类

  1. package com.hikktn.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
  7. @Configuration
  8. @ComponentScan(basePackages = "com.hikktn")
  9. // 选用CGLib代理
  10. @EnableAspectJAutoProxy(proxyTargetClass = true)
  11. public class AppConfig {
  12. }

4.3.7 测试

  1. import com.hikktn.config.AppConfig;
  2. import com.hikktn.service.impl.Boy;
  3. import com.hikktn.service.impl.Girl;
  4. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  6. public class AppTest {
  7.     public static void main(String[] args) {
  8.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
  9.         Boy boy = context.getBean("boy", Boy.class);
  10.         Girl girl = (Girl) context.getBean("girl");
  11.         String boyBought = boy.buy(35);
  12.         String girlBought = girl.buy(99.8);
  14.         System.out.println("男孩买到了：" + boyBought);
  15.         System.out.println("女孩买到了：" + girlBought);
  16.     }
  17. }

4.3.8 结果

  1. 男孩花了35.0元买了一个游戏机
  2. 女孩超级喜欢的东西
  3. 女孩花了99.8元买了一件漂亮的衣服
  4. 女孩买衣服超过了68元，赠送一双袜子
  5. 男孩买到了：游戏机
  6. 女孩买到了：衣服和袜子