【Spring】AOP底层原理(动态代理)-》 AOP概念及术语 -》 AOP实现

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: 【Spring】AOP底层原理(动态代理)-》 AOP概念及术语 -》 AOP实现


一、简述AOP


AOP —— 面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

AOP的作用:

  • 简化代码:把方法中固定位置的重复的代码抽取出来,让被抽取的方法更专注于自己的核心功能,提高内聚性。
  • 代码增强:把特定的功能封装到切面类中,看哪里有需要,就往上套,被套用了切面逻辑的方法就被切面给增强了。



二、AOP底层原理


AOP面向切面编程,在底层使用动态代理实现,其中分为两种情况:

  • 有接口时,使用JDK动态代理
  • 无接口时,使用CGLIB动态代理

JDK动态代理:创建接口实现类代理对象,增强类的方法;

CGLIB动态代理:创建子类的代理对象,增强类的方法;



三、实现动态代理(案例)


使用的相关Maven依赖:
<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后,表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>


① 声明计算器接口Calculator,包含加减乘除的抽象方法

/**
 * @author .29.
 * @create 2023-02-04 15:01
 */
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);
}


② 创建接口实现类,实现加减乘除等方法

import org.springframework.stereotype.Component;
/**
 * @author .29.
 * @create 2023-02-04 15:02
 */
//简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}


③ 编写被代理对象的工厂类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
 * @author .29.
 * @create 2023-02-04 22:05
 */
public class ProxyFactory {
    //目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    //返回代理对象
    public Object getProxy(){
        //动态代理返回对象
        //调用Proxy类中的newProxyInstance(),获取动态代理对象
        /*
        * newProxyInstance()中需要传入三个参数
        * ① ClassLoader:加载动态生成代理类的 类加载器
        * ② Class[] interfaces: 目标对象实现的所有接口
        * ③ InvocationHandler: 设置代理对象实现目标对象方法的过程
        * */
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler(){
            //参数一:代理对象
            //参数二:需要重写目标对象的方法
            //参数三:method方法(参数二)中的参数
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法调用前输出的日志
                System.out.println("[动态代理][日志]"+method.getName()+",参数:"+ Arrays.toString(args));
                //调用目标方法
                Object result = method.invoke(target, args);
                //方法调用后输出的日志
                System.out.println("[动态代理][日志]"+method.getName()+",结果:"+ result);
                return result;
            }
        };
        //调用Proxy类中的newProxyInstance(),获取动态代理对象
         return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}


④ 测试

/**
 * @author .29.
 * @create 2023-02-04 22:24
 */
public class TestCalculator {
    public static void main(String[] args) {
        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        //通过代理对象获取目标对象
        Calculator proxy = (Calculator) proxyFactory.getProxy();
        //调用目标对象方法
        proxy.add(1,1);
        System.out.println();
        proxy.div(1,1);
        System.out.println();
        proxy.mul(1,1);
        System.out.println();
        proxy.sub(1,1);
        System.out.println();
    }
}



四、AOP术语


1.横切关注点

分散在每个各个模块中解决同一样的问题,如用户验证、日志管理、事务处理、数据缓存都属于横切关注点。

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

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


2.通知

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

  • 前置通知:使用@Before注解标识,在被代理的目标方法执行
  • 返回通知:使用@AfterReturning注解标识,在被代理的目标方法成功结束后执行(寿终正寝
  • 异常通知:使用@AfterThrowing注解标识,在被代理的目标方法异常结束后执行(死于非命
  • 后置通知:使用@After注解标识,在被代理的目标方法最终结束后执行(盖棺定论
  • 环绕通知:使用@Around注解标识,使用try…catch…finally结构围绕整个被代理的目标方法,包括上面四种通知对应的所有位置

各种通知的执行顺序:

  • Spring版本5.3.x以前:
  • 前置通知
  • 目标操作
  • 后置通知
  • 返回通知或异常通知
  • Spring版本5.3.x以后:
  • 前置通知
  • 目标操作
  • 返回通知或异常通知
  • 后置通知

3.切面

即:封装通知方法的类。


4.目标

即:被代理的目标对象。


5.代理

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


6.连接点

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

把方法排成一排,每一个横切位置看成x轴方向,把方法从上到下执行的顺序看成y轴,x轴和y轴的交叉点就是连接点。通俗说,就是spring允许你使用通知的地方


7.切入点

定位连接点的方式。

每个类的方法中都包含多个连接点,所以连接点是类中客观存在的事物(从逻辑上来说)。

如果把连接点看作数据库中的记录,那么切入点就是查询记录的 SQL 语句。

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。通俗说,要实际去增强的方法

切点通过 org.springframework.aop.Pointcut 接口进行描述,它使用类和方法作为连接点的查询条件。



五、AOP的注解方式实现


须知:

切入点表达式语法:

execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))


1.导入Maven依赖

<dependencies>
        <!--spring context依赖-->
        <!--当你引入Spring Context依赖之后,表示将Spring的基础依赖引入了-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aop依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--spring aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>
        <!--junit5测试-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.3.1</version>
        </dependency>
    </dependencies>


2.准备被代理的 接口+实现类

/**
 * @author .29.
 * @create 2023-02-04 15:01
 */
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);
}
import org.springframework.stereotype.Component;
/**
 * @author .29.
 * @create 2023-02-04 15:02
 */
//简单功能的实现类
@Component
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}


※ 3.创建并配置切面类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
 * @author .29.
 * @create 2023-02-04 22:47
 */
//切面类
//@Aspect代表这是一个切面类
//@Component代表将此类交给Spring处理,能够放入IOC容器中去
@Aspect
@Component
public class LogAspect {
    //设置切入点 和 通知类型
    //切入点表达式:execution(权限修饰符 增强方法返回类型 增强方法所在类全路径.方法名称(方法参数))
    //重用切入点表达式:使用@Pointcut注解,设置需要重复使用的切入点表达式
    @Pointcut(value = "execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    public void pointCut(){}
    //之后,在使用通知时,将切入点表达式用 方法名 替换,即pointCut()(同一个切面)
    //若在不同的切面,需要加上重用切入点表达式方法的全类名:com.haojin.spring.aop.annoaop.LogAspect.pointCut()(不同的切面)
    //通知类型:
    // @Before("切入点表达式配置切入点") 前置
    @Before(value = "pointCut()")   //重用切入点表达式,使用方法名替换
    public void beforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        Object[] args = joinPoint.getArgs();             //获取增强方法的参数数组
        System.out.println("Logger-->前置通知,增强方法为:"+name+",参数:"+ Arrays.toString(args));
    }
    // @AfterReturning() 返回
    //返回通知 可以获取到返回值,在切入表达式中增加返回值属性:returning = ""
    @AfterReturning(value = "pointCut()",returning = "result")
    //增强方法中需要添加 返回值参数result,参数名与切入点表达式保持一致(result)
    public void afterReturningMethod(JoinPoint joinPoint,Object result){//可以存在参数JoinPoint,以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->返回通知,增强方法为:"+name+",返回结果:"+result);
    }
    // @AfterThrowing() 异常
    //目标方法出现异常时,此通知会执行,在切入表达式中增加属性:
    @AfterThrowing(value = "pointCut()",throwing = "exception")
    //增加 Throwable类型参数,参数名必须与切入点表达式保持一致(exception)
    public void aAfterThrowingMethod(JoinPoint joinPoint,Throwable exception){//可以存在参数JoinPoint,以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->异常通知,增强方法为:"+name+"异常信息:"+exception);
    }
    // @After() 后置
    @After(value = "execution(* com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint){//可以存在参数JoinPoint,以此来获取信息
        String name = joinPoint.getSignature().getName();//获取增强方法的名字
        System.out.println("Logger-->后置通知,增强方法为:"+name);
    }
    // @Around() 环绕通知,可以通过try-catch-finally,使得增强方法在所有阶段执行(增强方法可设置返回值)
    @Around("execution(public int com.haojin.spring.aop.annoaop.CalculatorImpl.*(..))")
    //可设置 ProceedingJoinPoint属性参数,以此调用增强方法(JoinPoint的子接口,JoinPoint没有调用目标方法的功能)
    public Object aroundMethod(ProceedingJoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();//通过ProceedingJoinPoint参数获取增强方法名
        Object[] args = joinPoint.getArgs();             //获取增强方法参数数组
        String argStr = Arrays.toString(args);           //参数数组转字符串
        Object result = null;
        try{
            System.out.println("环绕通知 == 增强方法执行前执行");
            //通过ProceedingJoinPoint类型参数调用增强方法
            result = joinPoint.proceed();
            System.out.println("环绕通知 = 增强方法返回值之后执行");
        }catch(Throwable throwable){//捕捉Throwable类型异常
            throwable.printStackTrace();
            System.out.println("环绕通知 = 增强方法异常时执行");
        }finally {
            System.out.println("环绕方法 = 增强方法执行完毕执行");
        }
        return result;
    }

切面优先级:

切面的优先级控制切面的 内外嵌套 顺序

外层切面:优先级高

内层切面:优先级低

可使用@Order()注解设置优先级

@Order(较小的数) 优先级较高

@Order(较大的数) 优先级较低


4.配置Spring配置文件(这里命名为 bean.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
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--
        基于注解的AOP的实现:
        1、将目标对象和切面交给IOC容器管理(注解+扫描)
        2、开启AspectJ的自动代理,为目标对象自动生成代理
        3、将切面类通过注解@Aspect标识
    -->
    <context:component-scan base-package="com.haojin.spring.aop.annoaop"></context:component-scan>
    <!--开启AspectJ的自动代理-->
    <aop:aspectj-autoproxy />
</beans>


5.测试

import com.haojin.spring.aop.annoaop.Calculator;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author .29.
 * @create 2023-02-06 9:34
 */
public class TestAop {
    //以实现类中的加法功能为例
    @Test
    public void testAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Calculator bean = context.getBean(Calculator.class);
        bean.add(3,13);
    }
}

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
目录
相关文章
|
11天前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识,包括静态代理和动态代理(JDK动态代理和CGLIB),以及AOP(面向切面编程)的概念和在Spring框架中的应用。文章还提供了详细的示例代码,演示了如何使用Spring AOP进行方法增强和代理对象的创建。
spring复习04,静态代理动态代理,AOP
|
2天前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
23 9
|
25天前
|
Java 数据库连接 数据库
Spring基础3——AOP,事务管理
AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
Spring基础3——AOP,事务管理
|
2月前
|
缓存 Java 开发者
Spring高手之路22——AOP切面类的封装与解析
本篇文章深入解析了Spring AOP的工作机制,包括Advisor和TargetSource的构建与作用。通过详尽的源码分析和实际案例,帮助开发者全面理解AOP的核心技术,提升在实际项目中的应用能力。
24 0
Spring高手之路22——AOP切面类的封装与解析
|
2月前
|
Java Spring XML
掌握面向切面编程的秘密武器:Spring AOP 让你的代码优雅转身,横切关注点再也不是难题!
【8月更文挑战第31天】面向切面编程(AOP)通过切面封装横切关注点,如日志记录、事务管理等,使业务逻辑更清晰。Spring AOP提供强大工具,无需在业务代码中硬编码这些功能。本文将深入探讨Spring AOP的概念、工作原理及实际应用,展示如何通过基于注解的配置创建切面,优化代码结构并提高可维护性。通过示例说明如何定义切面类、通知方法及其应用时机,实现方法调用前后的日志记录,展示AOP在分离关注点和添加新功能方面的优势。
40 0
|
2月前
|
缓存 安全 Java
Spring AOP 中两种代理类型的限制
【8月更文挑战第22天】
16 0
|
11天前
|
SQL 监控 druid
springboot-druid数据源的配置方式及配置后台监控-自定义和导入stater(推荐-简单方便使用)两种方式配置druid数据源
这篇文章介绍了如何在Spring Boot项目中配置和监控Druid数据源,包括自定义配置和使用Spring Boot Starter两种方法。
|
2月前
|
缓存 Java Maven
Java本地高性能缓存实践问题之SpringBoot中引入Caffeine作为缓存库的问题如何解决
Java本地高性能缓存实践问题之SpringBoot中引入Caffeine作为缓存库的问题如何解决
|
3月前
|
Java 测试技术 数据库
Spring Boot中的项目属性配置
本节课主要讲解了 Spring Boot 中如何在业务代码中读取相关配置,包括单一配置和多个配置项,在微服务中,这种情况非常常见,往往会有很多其他微服务需要调用,所以封装一个配置类来接收这些配置是个很好的处理方式。除此之外,例如数据库相关的连接参数等等,也可以放到一个配置类中,其他遇到类似的场景,都可以这么处理。最后介绍了开发环境和生产环境配置的快速切换方式,省去了项目部署时,诸多配置信息的修改。
|
3月前
|
Java 应用服务中间件 开发者
Java面试题:解释Spring Boot的优势及其自动配置原理
Java面试题:解释Spring Boot的优势及其自动配置原理
102 0
下一篇
无影云桌面