Spring-AOP 讲解

1、为什么会出现AOP思维

我们知道，在我们的项目中，会出现核心代码和非核心代码，对于非核心代码，在各个方法中可能是冗余的，此时为了解决这种非核心代码的冗余以及不方便管理的问题，就出现了AOP思维。

2、AOP思维是什么？

AOP：Aspect Oriented Programming面向切面编程。它是面向对象编程OOP的完善与补充。

面向对象编程是垂直性的，我们可以继承父类的方法，但是如果我们想添加一些其他东西，就需要完全重写该方法。

而AOP是切面性质的，我们需要做的就是解耦，将冗余代码取出来，然后再动态的添加到每个业务方法中。

此时我们就需要一些技术，来完成我们的AOP思维，该技术就是代理技术。

3、代理技术

代理模式是二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

无代理类时：我们是直接调用业务方法。

当出现代理类时：

我们首先调用代理类，之后代理类再去调用我们的目标方法。最后将两者填充在一起，返回给最初的调用者。这样做的好处是：我们可以将那些冗余代码写在代理类中，进行统一管理，通过代理类来调用目标方法。可以让目标方法专注于去完成它自己的业务逻辑。

代理在开发中有两种模式：一种是静态代理，一种是动态代理(jdk,cblib)

静态代理需要我们为每个目标类都编写一个目标类，这样虽然实现了解耦，但是还是需要大量代码，并没有实现统一管理。

动态代理包括jdk动态代理和cglib

jdk动态代理与cglib的区别：

jdk动态代理：其目标类必须有一个接口，目标类实现该接口，他会根据目标类的接口动态生成一个代理对象！代理对象和目标对象有相同的接口！（拜把子）。

cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口！（认干爹）

4、Spring aop框架

不论是静态代理还是动态代理技术，都需要编写大量代码，并没有简化操作。所以提出了Spring AOP框架，该框架底层用的仍然是代理技术，但是由于封装了起来，对程序员来说就很方便。

4.1 AOP主要应用场景（了解）

只要记住对于那些非核心的冗余代码，我们可以使用AOP即可。

AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景：

1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。
2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。
3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。
4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。
5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。
6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。
7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。

综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。

4.2 AOP术语

1-横切关注点

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。

这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点。

AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

2-通知(增强)

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。

- 前置通知：在被代理的目标方法前执行
- 返回通知：在被代理的目标方法成功结束后执行（**寿终正寝**）
- 异常通知：在被代理的目标方法异常结束后执行（**死于非命**）
- 后置通知：在被代理的目标方法最终结束后执行（**盖棺定论**）
- 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

3-连接点 joinpoint

这也是一个纯逻辑概念，不是语法定义的。

指那些被拦截到的点。在 Spring 中，可以被动态代理拦截目标类的方法

4-切入点 pointcut

定位连接点的方式，或者可以理解成被选中的连接点！

是一个表达式，比如execution(* com.spring.service.impl.*.*(..))。符合条件的每个方法都是一个具体的连接点。

5-切面 aspect

切入点和通知的结合。是一个类。

6-目标 target

被代理的目标对象。

7-代理 proxy

向目标对象应用通知之后创建的代理对象。

8-织入 weave

指把通知应用到目标上，生成代理对象的过程。可以在编译期织入，也可以在运行期织入，Spring采用后者。

5、Spring-AOP基于注解方式实现和细节

5.1 Spring AOP底层实现技术

- 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
- cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口。
- AspectJ：早期的AOP实现的框架，SpringAOP借用了AspectJ中的AOP注解。

AspectJ 是AOP早期实现框架，Spring AOP继承了该注解方式，但是底层实现技术仍然是代理技术。

依赖：

我们需要导入的依赖有 spring-aop，spring-aspects，AspectJ

但是我们使用spring容器导入的有Spring-context，其带有Spring-AOP依赖，而AspectJ依赖也不用手动导入，只需要导入Spring-aspects依赖即可，其带有Aspectj依赖。

导入依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.6</version>
</dependency>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>6.0.6</version>
</dependency>

编写Springaop流程：首先我们先正常写我们的核心代码，①导入依赖，②编写核心代码，③配置ioc，④测试，之后再来管理aop流程，我们的核心是来⑤编写增强代码，编写一个类来写增强代码，增强类方法具体有几个，是要看我们的非核心代码的位置，不同位置增强方法不同。接下来是⑥增强类的配置（插入切点的位置，切点指定，切面配置等），最后是⑦开启AOP配置。

①导入依赖

②编写核心代码

接口

package demo05.aop;

public interface Calculator {
    
    int add(int i, int j);
    
    int sub(int i, int j);
    
    int mul(int i, int j);
    
    int div(int i, int j);
    
}

具体实现类

package demo05.aop.Impl;


import demo05.aop.Calculator;
import org.springframework.stereotype.Component;

/**
 * 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!
 */
@Component
public class CalculatorPureImpl implements Calculator {
    
    @Override
    public int add(int i, int j) {
    
        int result = i + j;
    
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
    
        int result = i - j;
    
        return result;
    }
    
    @Override
    public int mul(int i, int j) {
    
        int result = i * j;
    
        return result;
    }
    
    @Override
    public int div(int i, int j) {


        int result = i / j;

        return result;
    }
}

③配置类

package demo05.aop.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = {"demo05.aop.Impl","demo05.aop.proxy"})
@EnableAspectJAutoProxy
public class Myconfig {
}

④测试

⑤编写增强类

在这里我们在方法开始之前输出以及方法结束和方法异常输出，所以需要写三个增强类方法。

package demo05.aop.proxy;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
// @Aspect表示这个类是一个切面类
@Component
// @Component注解保证这个切面类能够放入IOC容器
public class Myproxy {
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    //第一个*表示 不考虑返回值类型，我们要插入哪一个包下的哪个类，第三个参数*表示该类下的所有方法
    //第四个参数*（..）表示不考虑其参数类型以及有无参数。
    @Before("execution(* demo05.aop.Impl.*.*(..))")
    public void start(){
   System.out.println("方法开始");
    }
    @AfterReturning("execution(* demo05.aop.Impl.*.*(..))")
    public void after(){
        System.out.println("方法结束");
    }
    @AfterThrowing("execution(* demo05.aop.Impl.*.*(..))")
    public void error(){
        System.out.println("方法错误");
    }}

⑥增强配置

在前面的代码中，我们已经将其写过了，包括切点配置，切面配置等

我们也需要将增强类加上ioc组件注解，因为代理也需要在ioc容器中，才能操作我们的核心代码类。最后返回的其实也是我们的代理类

⑦开启aop配置

我们可以在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:context="http://www.springframework.org/schema/context"
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/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">


<context:component-scan base-package="com.atguigu" />

<aop:aspectj-autoproxy />
</beans>

也可以在配置类中开启

package demo05.aop.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = {"demo05.aop.Impl","demo05.aop.proxy"})
@EnableAspectJAutoProxy
public class Myconfig {
}

⑧测试

@Test
public void test_06(){
    AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Myconfig.class);
  //有接口时，使用的时jdk代理，这里要用接口类接收，因为返回的是代理类，是目标类的一个兄弟，不能用目标类接收
//如果没有接口，就可以用目标类接收，因为用cglib，返回的是目标类的一个继承代理类。
    Calculator calculator=context.getBean(Calculator.class);
    System.out.println(calculator.add(1,1));
    context.close();
}

结果：

5.2获取切点详细信息

有时候，我们需要我们目标方法的具体信息，比如参数，方法名，方法类的信息，返回值等。

这时候我们就需要一些方法来实现该需求。

如果我们需要获取切点的详细信息，比如方法名，方法类的信息，参数信息等

我们需要在增强类的参数中添加上 JoinPoint joinPoint

如果要获取返回值或者异常信息就要在参数以及注解中添加上额外信息，见下面代码

package demo05.aop.proxy;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.lang.reflect.Modifier;

@Aspect
@Component
/**编写增强方法
 * 配置增强方法的位置
 * 配置切点信息
 * 配置切面以及ioc
 * 开启aspectj注解支持
 */
 public class Myadvice {
     @Before("execution(* demo05.aop.Impl.*.*(..))")
  public void before(JoinPoint joinPoint){
         //获取方法名
         String name = joinPoint.getSignature().getName();
          //获取类型修饰符
         int modifiers = joinPoint.getSignature().getModifiers();
         String s = Modifier.toString(modifiers);
         //获取类信息
         String simpleName = joinPoint.getTarget().getClass().getSimpleName();
         //获取参数列表
         Object[] args = joinPoint.getArgs();

     }
     //只有正常返回 才能获取返回值
    //获取返回值 1.在形参中添加要接受返回值的名字
    //2. 在 @AfterReturning（）中添加是用哪个形参名来接受的返回值
     @AfterReturning(value = "execution(* demo05.aop.Impl.*.*(..))",returning ="returning" )
     public void  afterreturning(JoinPoint joinPoint,Object returning){

     }
     //只有异常返回 才能接收异常信息
     //获取异常信息 1.在形参中添加要接受异常信息的名字
     //2. 在 @AfterThrowing（）中添加是用哪个形参名来接受的异常信息
     @AfterThrowing(value = "execution(* demo05.aop.Impl.*.*(..))",throwing ="throwable")
     public void afterthrowing(JoinPoint joinPoint,Throwable throwable){

     }
}

5.3 切点表达式

5.3.1 语法细节

固定语法：execution(1 2 3.4.5(6))

1:方法修饰符

2：方法返回值

如果两者都不考虑统一用*代替，注意：要考虑都不考虑不能只考虑一个

3 包

固定的包: com.atguigu.api | service | dao

单层的任意命名: com.atguigu.* = com.atguigu.api com.atguigu.dao * = 任意一层的任意命名任意层任意命名: com.. = com.atguigu.api.erdaye com.a.a.a.a.a.a.a ..任意层,任意命名用在包上!

注意: ..不能用作包开头 public int ..

错误语法 com..

找到任何包下: *..

4.类名

固定名称: UserService
任意类名: *
部分任意: com..service.impl.*Impl
任意包任意类: *..*

5.方法名

语法和类名一致
任意访问修饰符,任意类的任意方法: * *..*.*

6.方法参数

第七位: 方法的参数描述
具体值: (String,int) != (int,String) 没有参数 ()
模糊值: 任意参数有或者没有 (..) ..任意参数的意识
部分具体和模糊:
第一个参数是字符串的方法 (String..)
最后一个参数是字符串 (..String)
字符串开头,int结尾 (String..int)
包含int类型(..int..)

小练习

1.查询某包某类下，访问修饰符是公有，返回值是int的全部方法
2.查询某包下类中第一个参数是String的方法
3.查询全部包下，无参数的方法！
4.查询com包下，以int参数类型结尾的方法
5.查询指定包下，Service开头类的私有返回值int的无参数方法

5.4 切点的统一管理

我们发现在增强类中切点表达式是一样的，我们可以将其提取出来，然后复用

方法1：提取到当前类中（不推荐，每个类都需要提取）

写一个空方法 public void xxx(){}

添加注解PointCut

增强注解中直接引用方法名即可

package demo05.aop.proxy;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
// @Aspect表示这个类是一个切面类
@Component
// @Component注解保证这个切面类能够放入IOC容器
public class Myproxy {
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    //第一个*表示 不考虑返回值类型，我们要插入哪一个包下的哪个类，第三个参数*表示该类下的所有方法
    //第四个参数*（..）表示不考虑其参数类型以及有无参数。
    @Pointcut("execution(* demo05.aop.Impl.*.*(..))")
    public void pc(){}
    @Before("pc()")
    public void start(){
   System.out.println("方法开始");
    }
    @AfterReturning("pc()")
    public void after(){
        System.out.println("方法结束");
    }
    @AfterThrowing("pc()")
    public void error(){
        System.out.println("方法错误");
    }}

方法2:创建一个存储切点的类

该类记得放在ioc容器中

单独维护切点表达式

增强方法使用该切点表达式：类的全限定符.方法名

切点类：

package demo05.aop.pointcut;

import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
public class Mypointcut {
    @Pointcut("execution(* demo05.aop.Impl.*.*(..))")
    public void pc(){

    }
}d

代理类:

package demo05.aop.proxy;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
// @Aspect表示这个类是一个切面类
@Component
// @Component注解保证这个切面类能够放入IOC容器
public class Myproxy {
    // @Before注解：声明当前方法是前置通知方法
    // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
    //第一个*表示 不考虑返回值类型，我们要插入哪一个包下的哪个类，第三个参数*表示该类下的所有方法
    //第四个参数*（..）表示不考虑其参数类型以及有无参数。
    @Pointcut("execution(* demo05.aop.Impl.*.*(..))")
    public void pc(){}
    @Before("demo05.aop.pointcut.Mypointcut.pc()")
    public void start(){
   System.out.println("方法开始");
    }
    @AfterReturning("demo05.aop.pointcut.Mypointcut.pc()")
    public void after(){
        System.out.println("方法结束");
    }
    @AfterThrowing("demo05.aop.pointcut.Mypointcut.pc()")
    public void error(){
        System.out.println("方法错误");
    }}

5.5 环绕通知

环绕通知可以包含brfore，after等这些通知。可以通过下面的例子来演示。

package demo05.aop.proxy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class Advicearound {
    //ProceedingJoinPoint 比JoinPoint 多了一个可执行目标函数的方法
    @Around("demo05.aop.pointcut.Mypointcut.pc()")  //配置切点和位置
    public Object aroundSet(ProceedingJoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        Object result=null;
        try {
            System.out.println("开启事务");  //相当于Before
            result = joinPoint.proceed(args);
            System.out.println("事务结束"); //相当于AfterReturning
        }
        catch (Throwable e){
            System.out.println("事务异常");//相当于Afterthrowing
            throw new RuntimeException(e);//一定要抛出异常，不然外部无论如何都接收不到异常
        }
        return result;
    }
}