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" />

<!-- 开启aspectj框架注解支持-->
<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;
    }
}

5.5 切面优先级设定

比如我们有一个日志增强,一个事务增强,如何确定两个增强的优先级呢?

可以通过**@Order()注解**

里边的数值越小,优先级越高,前置增强先执行,后置增强后执行

反之越低。

事务增强 @Order(10) 日志增强 @Order(20)

结果:

相关推荐
qq_441996056 分钟前
Mybatis官方生成器使用示例
java·mybatis
巨大八爪鱼13 分钟前
XP系统下用mod_jk 1.2.40整合apache2.2.16和tomcat 6.0.29,让apache可以同时访问php和jsp页面
java·tomcat·apache·mod_jk
码上一元2 小时前
SpringBoot自动装配原理解析
java·spring boot·后端
计算机-秋大田2 小时前
基于微信小程序的养老院管理系统的设计与实现,LW+源码+讲解
java·spring boot·微信小程序·小程序·vue
魔道不误砍柴功4 小时前
简单叙述 Spring Boot 启动过程
java·数据库·spring boot
失落的香蕉4 小时前
C语言串讲-2之指针和结构体
java·c语言·开发语言
枫叶_v4 小时前
【SpringBoot】22 Txt、Csv文件的读取和写入
java·spring boot·后端
wclass-zhengge4 小时前
SpringCloud篇(配置中心 - Nacos)
java·spring·spring cloud
路在脚下@4 小时前
Springboot 的Servlet Web 应用、响应式 Web 应用(Reactive)以及非 Web 应用(None)的特点和适用场景
java·spring boot·servlet
黑马师兄4 小时前
SpringBoot
java·spring