Spring学习之AOP面向切面编程

Spring-AOP

概念：面向切面编程（AOP）🥇 ：利用AOP可以对业务逻辑的各个部分进行隔离，从而使业务逻辑个部分的耦合度降低，提高程序的可重用性，同时提高了开发的效率。不通过修改源代码的方式，在主干中添加功能。

1.1 AOP的底层原理

底层原理是通过动态代理实现的。

1.1.1 两种情况的动态代理

1.1.1.1 有接口

使用JDK的动态代理：创建接口实现类代理对象，增强类的方法。

使用Proxy类里面的方法创建代理对象

(1) 调用 newProxyInstance（）方法

• ClassLoader loader : 类加载器
• Class<?>[] interfaces: 增强方法所在的类，这个实现类的接口，支持多个接口
• InvocationHandler h:实现这个接口InvovationHandler,创建代理对象，写增强的方法。

（2）案例：

• 创建接口，定义方法

  public interface UserDao {
      public int add(int a,int b);
      public String update(String id);
  }
  

• 创建接口的实现类

  public class UserDaoImpl implements UserDao {
      @Override
      public int add(int a, int b) {
          return a + b;
      }
      @Override
      public String update(String id) {
          return id;
      }
  }
  

• ⚡️使用Proxy类创建增强对象

  public class JDKProxy {
      public static void main(String[] args) {
          UserDaoImpl userDao = new UserDaoImpl();
          // 创建实现类的代理对象
          Class[] interfaces = {UserDao.class};
          UserDao dao =(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
          int add = dao.add(1, 2);
          System.out.println(add);
      }
  }
  // 代理对象的代码
  class UserDaoProxy implements InvocationHandler{
      //1.把创建的是谁的代理对象，把它传递过来
      // 有参构造进行传递
      private Object obj;
      public UserDaoProxy(Object obj){
          this.obj = obj;
      }
      // 增强的逻辑
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          // 方法之前
          System.out.println("在方法之前执行....."+ method.getName()+":传递的参数"+ Arrays.toString(args));
          //被增强的方法
          Object invoke = method.invoke(obj, args);
          // 方法之后
          System.out.println("方法之后执行" + obj);
          return invoke;
      }
  }
  

  使用匿名内部类实现

  public class JDKProxyDemo {
  
      public static void main(String[] args) {
          UserDaoImpl userDao  = new UserDaoImpl();
          Class<?>[] interfaces = {UserDao.class};
          UserDao dao =(UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
              @Override
              public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  if ("add".equals(method.getName())){
                      // 方法之前
                      System.out.println("在方法之前执行....."+ method.getName()+":传递的参数"+ Arrays.toString(args));
                      //被增强的方法
                      Object invoke = method.invoke(userDao, args);
                      // 方法之后
                      System.out.println("方法之后执行" + userDao);
                      return invoke;
                  }
                  if ("update".equals(method.getName())){
                      // 方法之前
                      System.out.println("在方法之前执行....."+ method.getName()+":传递的参数"+ Arrays.toString(args));
                      //被增强的方法
                      Object invoke = method.invoke(userDao, args);
                      // 方法之后
                      System.out.println("方法之后执行" + userDao);
                      return invoke;
                  }
                  return null;
              }
          });
          int add = dao.add(1, 2);
          System.out.println(add);
      }
  }
  

1.1.1.2 没有接口

使用CGLIB动态代理：创建当前子类的代理对象，增强类里面方法的功能。

Spring5 中已经将动态代理的功能进行了封装

2.AOP中的术语

2.1 连接点

类里面的哪些方法可以被增强，这些方法被称为连接点

2.2 切入点

实际被真正增强的方法，成为切入点

2.3通知（增强）

实际增强的逻辑部分，称为通知。

• 前置通知：@Before
• 后置通知：@Afterretruning
• 环绕通知：@Around
• 异常通知：@AfterThrowing
• 最终通知：@After

2.4切面

是一个动作，把通知应用到切入点的过程。

3.AOP的操作

3.1 Spring框架基于AspectJ实现AOP操作

aspectJ不是Sprin给组成部分，独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP的操作。在Spring中一般会这么操作

3.1.2 基于AspectJ实现AOP操作

(1) 基于xml配置文件实现

现在使用的比较少。

(2) 基于注解方式实现（实际使用）

• 在项目中映入AOP相关依赖

• 切入点（实际要增强的方法）表达式

  • a.作用：知道对那个类的那个方法进行增强

  • b.语法结构：

    exection([权限修饰符][返回类型][类全路径][方法名称]([参数列表]))

• 案例一

  1.创建类，在类里面定义方法

  public class User {
      public void add(){
          System.out.println("add....");
      }
  }
  

  2.创建增强类（编写增强的逻辑）

  • 在增强类里面，创建方法，让不同的方法代表不同的通知类型

  /**
   * 增强类
   */
  public class UserProxy {
      // 前置通知
      public void before(){
          System.out.println("bfrore....");
      }
  }
  

  3.进行通知配置

  ​ （1）在配置文件中，开启注解扫描

  

  ​ （2）使用注解创建User和UserProxy对象

  /**
   被增强类
   */
  @Component
  public class User {
      public void add(){
          System.out.println("add....");
      }
  }
  //-----------------------------------------------------------------------
  @Component
  public class UserProxy {
      // 前置通知
      public void before(){
          System.out.println("bfrore....");
      }
  }
  

  ​ （3）在增强类上面添加注解@Aspect

  ​

  ​ （4）配置表中配置文件开启生成代理

  

  ​ (5)配置不同类型的通知

  ​ 在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

  ​ a.前置增强

  

结果测试

增强的注解通知

after不管有没有异常都执行，after有异常不通知。

3.细节问题

3.1 重用切入点

把相同的切入点抽取

3.2 多个增强类，对同一个方法进行增强

在增强类上添加注解@Order(数字类型值)，数字类型值，越小优先级越高