深入探索Spring AOP从原理到实战操作_Java

一、揭开 spring aop 的神秘面纱

1.1 什么是 aop

在软件编程的世界里，随着系统规模的不断扩大和复杂性的日益增加，我们常常会遇到一些问题，这些问题涉及到多个模块或类，却又不属于核心业务逻辑。比如日志记录、事务管理、权限控制等功能，它们分散在各个业务代码中，导致代码的重复和臃肿，维护起来也变得异常困难。为了解决这些问题，aop 应运而生。

aop，即 aspect-oriented programming，面向切面编程，是一种编程范式，它的核心思想是将横切关注点（cross-cutting concerns）从核心业务逻辑中分离出来，形成一个个独立的切面（aspect）。横切关注点就像是一条贯穿多个模块的 “横线”，这些功能在多个地方都需要用到，但又和具体的业务逻辑没有直接关系。通过 aop，我们可以将这些横切关注点模块化，以一种声明式的方式将它们应用到需要的地方，从而实现代码的解耦和复用，提高代码的可维护性和可扩展性。

aop 并不是要取代面向对象编程（oop），而是对 oop 的一种补充和完善。oop 主要关注的是对象的封装、继承和多态，通过类和对象来组织代码，解决的是业务逻辑的纵向划分问题；而 aop 则关注的是那些横跨多个类的行为，通过切面来模块化这些横切关注点，解决的是业务逻辑的横向抽取问题。两者相互配合，可以让我们的代码更加清晰、灵活和易于维护。

1.2 spring aop 是什么

spring aop 是 spring 框架的一个重要组成部分，它基于 aop 思想，提供了一种强大的功能，使得我们可以在 spring 应用中轻松地实现横切关注点的分离和模块化。spring aop 主要通过动态代理机制来实现，它允许我们在运行时为目标对象创建代理对象，在不修改目标对象源代码的情况下，对其方法进行增强。

在 spring aop 中，我们可以通过配置或注解的方式定义切面、切点和通知。切面是横切关注点的模块化封装，它包含了切点和通知的定义；切点用于指定在哪些连接点上应用切面的通知，连接点是程序执行过程中的一个特定点，比如方法调用、异常抛出等；通知则是切面在特定连接点上执行的代码，它可以在方法执行前、执行后、返回结果后或抛出异常时执行，从而实现对目标方法的各种增强操作。

1.3 aop 的核心术语

通知（advice）：通知是切面在特定连接点执行的操作，它定义了 “何时” 和 “做什么”。根据执行时机的不同，通知可以分为以下几种类型：
- 前置通知（before advice）：在目标方法执行之前执行，比如在方法执行前进行日志记录、权限检查等操作。
- 后置通知（after advice）：在目标方法执行之后执行，无论方法是否正常返回或抛出异常，都会执行后置通知，常用于资源清理等操作。
- 返回通知（after returning advice）：在目标方法正常返回后执行，它可以获取到目标方法的返回值，比如在方法返回后进行结果处理、缓存设置等操作。
- 异常通知（after throwing advice）：在目标方法抛出异常时执行，它可以获取到异常信息，常用于异常处理、日志记录等操作。
- 环绕通知（around advice）：环绕通知是功能最强大的通知类型，它可以在目标方法执行前后都执行操作，甚至可以决定是否执行目标方法。环绕通知需要手动调用 proceedingjoinpoint 的 proceed () 方法来执行目标方法，通过这种方式，我们可以实现对目标方法的完全控制，比如在方法执行前进行参数校验、在方法执行后进行性能统计等操作。
连接点（join point）：连接点是程序执行过程中的一个特定点，比如方法调用、字段访问、构造函数调用等。在 spring aop 中，连接点主要指方法的执行，它是通知可以插入的位置。spring aop 通过动态代理机制，在方法调用时拦截方法执行，从而在连接点处织入通知。
切点（pointcut）：切点是一组连接点的集合，它定义了哪些连接点会被切面所影响，也就是决定在哪些方法或函数上应用通知。切点通过切点表达式来定义，切点表达式可以根据方法的签名、参数、返回值、类名、包名等条件来匹配连接点。比如，我们可以定义一个切点表达式，匹配所有以 “save” 开头的方法，或者匹配所有标注了特定注解的方法。通过切点的定义，我们可以精确地控制切面的作用范围，只对需要的连接点应用通知，从而避免对不需要的方法进行不必要的增强。
切面（aspect）：切面是通知和切点的结合体，它将横切关注点封装为一个可重用的模块。一个切面可以包含多个切点和通知，通过切面的定义，我们可以将相关的横切逻辑集中管理，提高代码的模块化程度和可维护性。例如，我们可以定义一个日志切面，它包含了在方法执行前后记录日志的通知，以及匹配所有业务方法的切点，这样就可以对所有业务方法进行统一的日志记录。
引入（introduction）：引入允许我们在运行时为目标对象动态添加新的接口和实现。通过引入，我们可以为现有的类添加额外的功能，而不需要修改类的源代码。比如，我们可以为一个类引入一个新的接口，使其具备某种新的行为，这种方式在扩展现有类的功能时非常有用。
织入（weaving）：织入是将切面应用到目标对象并创建代理对象的过程。织入可以在编译时、类加载时或运行时进行。在 spring aop 中，默认采用运行时织入的方式，通过动态代理在运行时为目标对象创建代理对象，并将切面的通知织入到代理对象的方法调用中。在编译时织入需要特殊的编译器支持，类加载时织入则需要特殊的类加载器支持。
目标对象（target object）：目标对象是被切面增强的对象，也就是实际执行业务逻辑的对象。在 spring aop 中，目标对象通常是一个普通的 pojo（plain old java object），它不知道自己被代理和增强。
代理对象（proxy object）：代理对象是 spring aop 为目标对象创建的代理实例，它负责在目标对象的方法调用前后执行切面的通知。代理对象实现了与目标对象相同的接口（如果目标对象实现了接口），或者继承了目标对象（如果目标对象没有实现接口）。当我们调用代理对象的方法时，实际上是调用代理对象的方法，代理对象会在方法调用前后执行切面的通知，然后再调用目标对象的方法。根据代理方式的不同，spring aop 提供了两种代理对象：jdk 动态代理和 cglib 代理。jdk 动态代理基于 java 反射机制，只能为实现了接口的目标对象创建代理；cglib 代理基于字节码生成技术，可以为没有实现接口的目标对象创建代理。

二、spring aop 的底层基石：动态代理

2.1 jdk 动态代理

jdk 动态代理是 java 原生提供的一种动态代理机制，它基于反射机制实现，要求目标对象必须实现至少一个接口。在 jdk 动态代理中，核心的类和接口有两个：java.lang.reflect.proxy和java.lang.reflect.invocationhandler。

proxy类主要负责生成代理对象，它提供了一个静态方法newproxyinstance，通过这个方法可以创建一个代理对象。该方法接受三个参数：类加载器（classloader）、目标对象实现的接口数组（class<?>[] interfaces）以及一个实现了invocationhandler接口的处理器对象（invocationhandler h）。

invocationhandler接口则定义了代理对象的行为逻辑，它只有一个方法invoke，当我们调用代理对象的方法时，实际上会调用到这个invoke方法。在invoke方法中，我们可以在目标方法执行前后添加自定义的逻辑，比如日志记录、事务管理等，然后通过反射调用目标对象的实际方法。

下面通过一个简单的代码示例来演示 jdk 动态代理的使用：

// 定义一个接口
interface userservice {
    void adduser(string username);
}
// 实现接口的目标类
class userserviceimpl implements userservice {
    @override
    public void adduser(string username) {
        system.out.println("adding user: " + username);
    }
}
// 实现invocationhandler接口
class myinvocationhandler implements invocationhandler {
    private object target;
    public myinvocationhandler(object target) {
        this.target = target;
    }
    @override
    public object invoke(object proxy, method method, object[] args) throws throwable {
        system.out.println("before method execution");
        object result = method.invoke(target, args);
        system.out.println("after method execution");
        return result;
    }
}
public class main {
    public static void main(string[] args) {
        userservice target = new userserviceimpl();
        invocationhandler handler = new myinvocationhandler(target);
        userservice proxy = (userservice) proxy.newproxyinstance(
                target.getclass().getclassloader(),
                target.getclass().getinterfaces(),
                handler
        );
        proxy.adduser("alice");
    }
}

在上述代码中，首先定义了一个userservice接口和实现该接口的userserviceimpl类。然后创建了一个myinvocationhandler类，实现了invocationhandler接口，在invoke方法中添加了前置和后置的打印逻辑。最后在main方法中，通过proxy.newproxyinstance方法创建了代理对象，并调用代理对象的adduser方法。运行代码后，可以看到在目标方法执行前后分别打印了 “before method execution” 和 “after method execution”。

2.2 cglib 动态代理

cglib（code generation library）是一个高性能的代码生成库，它通过字节码操作技术在运行时动态生成目标类的子类，从而实现代理功能。与 jdk 动态代理不同，cglib 代理不需要目标类实现接口，因此可以代理普通的类。

cglib 动态代理的核心类是net.sf.cglib.proxy.enhancer和net.sf.cglib.proxy.methodinterceptor。enhancer类用于生成代理类，它提供了一系列方法来配置代理类的属性，比如设置父类（即目标类）、设置回调函数等。methodinterceptor接口则用于定义方法的拦截逻辑，当调用代理对象的方法时，会触发methodinterceptor的intercept方法，在这个方法中我们可以实现对目标方法的增强。

下面是一个使用 cglib 动态代理的代码示例：

import net.sf.cglib.proxy.enhancer;
import net.sf.cglib.proxy.methodinterceptor;
import net.sf.cglib.proxy.methodproxy;
import java.lang.reflect.method;
class userservice {
    public void adduser(string username) {
        system.out.println("adding user: " + username);
    }
}
class mymethodinterceptor implements methodinterceptor {
    @override
    public object intercept(object obj, method method, object[] args, methodproxy proxy) throws throwable {
        system.out.println("before method execution");
        object result = proxy.invokesuper(obj, args);
        system.out.println("after method execution");
        return result;
    }
}
public class cglibproxyexample {
    public static void main(string[] args) {
        enhancer enhancer = new enhancer();
        enhancer.setsuperclass(userservice.class);
        enhancer.setcallback(new mymethodinterceptor());
        userservice proxy = (userservice) enhancer.create();
        proxy.adduser("bob");
    }
}

在这个示例中，首先定义了一个没有实现接口的userservice类。然后创建了mymethodinterceptor类，实现了methodinterceptor接口，在intercept方法中添加了前置和后置的打印逻辑。最后在main方法中，通过enhancer类设置目标类为userservice，并设置回调函数为mymethodinterceptor，调用create方法生成代理对象，并调用代理对象的adduser方法。运行代码后，同样可以看到在目标方法执行前后打印了相应的信息。

2.3 两者对比与 spring 的选择

性能对比：
- jdk 动态代理：由于它基于反射机制，在创建代理对象和方法调用时会涉及到反射操作，因此性能相对较低。特别是在方法调用频繁的情况下，反射带来的开销会比较明显。不过，在代理对象创建较少且方法调用次数不多的场景下，其性能表现还是可以接受的。
- cglib 动态代理：cglib 通过字节码生成技术，直接在运行时生成目标类的子类，方法调用时直接调用子类的方法，避免了反射的开销，因此在性能上通常优于 jdk 动态代理，尤其是在大量创建代理对象和频繁调用方法的场景下，cglib 的优势更加明显。
适用场景对比：
- jdk 动态代理：适用于目标类已经实现了接口的情况，因为它必须依赖接口来创建代理对象。在 java 的企业级开发中，很多服务层接口都采用这种方式，所以 jdk 动态代理在 spring 的 aop 中也被广泛应用于代理有接口的服务。
- cglib 动态代理：适用于目标类没有实现接口，或者需要代理类的所有方法（包括非接口方法）的场景。例如，当我们需要对一些第三方库中的类进行增强，而这些类没有实现特定接口时，cglib 就可以发挥作用。此外，由于 cglib 的性能优势，对于一些对性能要求较高且目标类无接口的场景，也可以优先考虑使用 cglib。
spring 的选择策略：
- 在 spring aop 中，默认情况下，如果目标对象实现了接口，spring 会优先使用 jdk 动态代理来创建代理对象；如果目标对象没有实现接口，spring 则会使用 cglib 动态代理。
- 不过，spring 也提供了配置选项，允许我们手动指定使用哪种代理方式。例如，通过在配置文件中设置proxy-target-class="true"，可以强制 spring 使用 cglib 代理，即使目标对象实现了接口。这种配置在一些特殊场景下非常有用，比如当我们需要代理类的所有方法，包括那些在接口中没有定义的方法时。

三、spring aop 实战演练

3.1 环境搭建

在开始使用 spring aop 之前，我们需要搭建一个 spring 项目，并引入 spring aop 的相关依赖。如果你使用的是 maven 项目管理工具，可以在pom.xml文件中添加以下依赖：

<dependencies>
    <!-- spring core -->
    <dependency>
        <groupid>org.springframework</groupid>
        <artifactid>spring-context</artifactid>
        <version>5.3.23</version>
    </dependency>
    <!-- spring aop -->
    <dependency>
        <groupid>org.springframework</groupid>
        <artifactid>spring-aop</artifactid>
        <version>5.3.23</version>
    </dependency>
    <!-- aspectj weaver -->
    <dependency>
        <groupid>org.aspectj</groupid>
        <artifactid>aspectjweaver</artifactid>
        <version>1.9.9.1</version>
    </dependency>
</dependencies>

上述配置中，spring-context是 spring 的核心依赖，spring-aop提供了 spring aop 的支持，aspectjweaver是 aspectj 的织入器，spring aop 默认使用 aspectj 的切点表达式语言，因此需要引入这个依赖。

如果你使用的是 gradle，可以在build.gradle文件中添加以下依赖：

dependencies {
    implementation 'org.springframework:spring-context:5.3.23'
    implementation 'org.springframework:spring-aop:5.3.23'
    implementation 'org.aspectj:aspectjweaver:1.9.9.1'
}

添加完依赖后，maven 或 gradle 会自动下载并管理这些依赖。

3.2 定义切面

在 spring aop 中，我们可以使用注解或 xml 配置的方式来定义切面。下面先介绍使用注解定义切面的方法：
首先，创建一个切面类，并使用@aspect注解标记它，表明这是一个切面。同时，使用@component注解将其注册为 spring 容器中的一个 bean，这样 spring 才能管理它。例如：

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.pointcut;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    // 定义切点表达式，匹配com.example.service包下所有类的所有方法
    @pointcut("execution(* com.example.service.*.*(..))")
    public void servicemethods() {}
    // 其他通知方法将在这里定义
}

在上述代码中，@pointcut注解定义了一个切点，切点表达式execution(* com.example.service.*.*(..))表示匹配com.example.service包下所有类的所有方法。servicemethods方法本身没有实际的业务逻辑，它只是一个标识，用于在后续的通知中引用这个切点。

接下来介绍使用 xml 配置定义切面的方法：
首先，在 spring 的配置文件（如applicationcontext.xml）中，需要引入 aop 的命名空间：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
       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/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">

然后，定义切面类，并将其配置为 spring 容器中的 bean：

<bean id="loggingaspect" class="com.example.aspect.loggingaspect"/>

接着，定义切点和通知：

<aop:config>
    <aop:aspect ref="loggingaspect">
        <aop:pointcut id="servicemethods" expression="execution(* com.example.service.*.*(..))"/>
        <!-- 其他通知配置将在这里定义 -->
    </aop:aspect>
</aop:config>

在上述 xml 配置中，<aop:config>标签用于配置 aop 相关的内容，<aop:aspect>标签引用了切面类loggingaspect，<aop:pointcut>标签定义了切点，表达式与注解方式中的切点表达式相同。

3.3 通知类型详解

前置通知（before advice）：
- 执行时机：在目标方法执行之前执行。
- 使用场景：常用于权限检查、日志记录等操作。例如，在方法执行前检查用户是否有权限执行该方法，或者记录方法的调用信息。
- 注解方式示例：

import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    private static final logger logger = loggerfactory.getlogger(loggingaspect.class);
    @before("servicemethods()")
    public void logbefore(joinpoint joinpoint) {
        string methodname = joinpoint.getsignature().getname();
        object[] args = joinpoint.getargs();
        logger.info("方法 {} 开始执行，参数: {}", methodname, args);
    }
    @pointcut("execution(* com.example.service.*.*(..))")
    public void servicemethods() {}
}

在上述代码中，@before注解表示这是一个前置通知，servicemethods()是前面定义的切点，表示这个通知应用于com.example.service包下所有类的所有方法。logbefore方法中的joinpoint参数可以获取到目标方法的签名和参数等信息。
2. 后置通知（after advice）：

执行时机：在目标方法执行之后执行，无论目标方法是否正常返回或抛出异常。
使用场景：常用于资源清理等操作。例如，在方法执行后关闭数据库连接、释放文件资源等。
注解方式示例：

import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.after;
import org.aspectj.lang.annotation.aspect;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    private static final logger logger = loggerfactory.getlogger(loggingaspect.class);
    @after("servicemethods()")
    public void logafter(joinpoint joinpoint) {
        string methodname = joinpoint.getsignature().getname();
        logger.info("方法 {} 执行结束", methodname);
    }
    @pointcut("execution(* com.example.service.*.*(..))")
    public void servicemethods() {}
}

返回通知（after returning advice）：
- 执行时机：在目标方法正常返回后执行。
- 使用场景：常用于对方法返回结果进行处理。例如，对返回结果进行缓存、格式化等操作。
- 注解方式示例：

import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.afterreturning;
import org.aspectj.lang.annotation.aspect;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    private static final logger logger = loggerfactory.getlogger(loggingaspect.class);
    @afterreturning(pointcut = "servicemethods()", returning = "result")
    public void logafterreturning(joinpoint joinpoint, object result) {
        string methodname = joinpoint.getsignature().getname();
        logger.info("方法 {} 返回结果: {}", methodname, result);
    }
    @pointcut("execution(* com.example.service.*.*(..))")
    public void servicemethods() {}
}

在上述代码中，@afterreturning注解的returning属性指定了一个参数名result，这个参数名与通知方法中的参数名相对应，用于接收目标方法的返回值。
4. 异常通知（after throwing advice）：

执行时机：在目标方法抛出异常时执行。
使用场景：常用于异常处理、日志记录等操作。例如，在方法抛出异常时记录异常信息，或者进行统一的异常处理。
注解方式示例：

import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.afterthrowing;
import org.aspectj.lang.annotation.aspect;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    private static final logger logger = loggerfactory.getlogger(loggingaspect.class);
    @afterthrowing(pointcut = "servicemethods()", throwing = "ex")
    public void logafterthrowing(joinpoint joinpoint, exception ex) {
        string methodname = joinpoint.getsignature().getname();
        logger.error("方法 {} 抛出异常: {}", methodname, ex.getmessage());
    }
    @pointcut("execution(* com.example.service.*.*(..))")
    public void servicemethods() {}
}

在上述代码中，@afterthrowing注解的throwing属性指定了一个参数名ex，用于接收目标方法抛出的异常对象。
5. 环绕通知（around advice）：

执行时机：在目标方法执行前后都执行，可以完全控制目标方法的执行。
使用场景：常用于性能统计、事务管理等操作。例如，统计方法的执行时间，或者在方法执行前后开启和提交事务。
注解方式示例：

import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.around;
import org.aspectj.lang.annotation.aspect;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    private static final logger logger = loggerfactory.getlogger(loggingaspect.class);
    @around("servicemethods()")
    public object logaround(proceedingjoinpoint joinpoint) throws throwable {
        long starttime = system.currenttimemillis();
        logger.info("方法 {} 开始执行", joinpoint.getsignature().getname());
        try {
            return joinpoint.proceed();
        } finally {
            long endtime = system.currenttimemillis();
            logger.info("方法 {} 执行结束，耗时: {} ms", joinpoint.getsignature().getname(), endtime - starttime);
        }
    }
    @pointcut("execution(* com.example.service.*.*(..))")
    public void servicemethods() {}
}

在上述代码中，@around注解的通知方法接受一个proceedingjoinpoint参数，通过调用它的proceed()方法来执行目标方法。在调用proceed()方法前后添加的代码，分别在目标方法执行前和执行后执行。

3.4 切点表达式

切点表达式是 spring aop 中非常重要的一部分，它用于指定哪些方法会被切面所影响。spring aop 默认使用 aspectj 的切点表达式语言，下面详细介绍其语法规则：

基本语法结构：

execution([修饰符模式] 返回值类型模式 [类名模式]方法名模式(参数模式)[异常模式])

其中，方括号内的部分是可选的。

修饰符模式：用于匹配方法的修饰符，如public、private、protected等。可以使用通配符*匹配任意修饰符，通常情况下修饰符模式可以省略。
返回值类型模式：用于匹配方法的返回值类型，*表示匹配任意返回值类型，也可以指定具体的返回值类型，如void、int、string等。
类名模式：用于匹配类名，可以指定包名和类名相关信息。包名后若跟..表示当前包及其子包；类名用*表示匹配所有类。例如，com.example.service..*表示com.example.service包及其子包下的所有类。
方法名模式：*表示匹配所有方法名；也可指定特定方法名，如get*表示以get开头的方法。
参数模式：(..)表示匹配任意参数数量和类型；也可具体指定，如(int, string)表示方法有两个参数，分别为int类型和string类型，(int,..) 表示第一个参数是int类型，后面可以跟任意数量和类型参数。
异常模式：用于匹配方法抛出的异常类型，较少使用，通常省略。
通配符详解：
- *：匹配任意字符（除.外）。例如，com.*.service表示com包下任意子包下的service包。
- ..：匹配任意子包或多个参数。在包名中使用时，表示当前包及其子包；在参数模式中使用时，表示任意数量和类型的参数。例如，com.example..*service表示com.example包及其子包下所有以service结尾的类；(..)表示任意参数。
- +：匹配指定类型及其子类。例如，java.util.list+表示匹配java.util.list接口及其所有实现类。
常用示例：
匹配指定包下所有类的所有方法：execution(* com.example.dao..*.*(..))，表示匹配com.example.dao包及其子包下所有类的所有方法，第一个*匹配任意返回值类型，第二个*匹配所有类，第三个* 匹配所有方法名，(..)匹配任意参数。
匹配指定类的所有方法：execution(* com.example.service.userservice.*(..))，即匹配com.example.service.userservice类的所有方法。
匹配指定接口所有实现类的方法：execution(* com.example.dao.genericdao+.*(..))，+表示匹配genericdao接口的所有实现类的方法。
匹配特定方法名开头的方法：execution(* save*(..))，表示匹配所有以save开头的方法，不限定返回值类型、类和参数。
多表达式组合：
- 多个 execution 表达式之间可以通过逻辑运算符组合：
- 或（|| 或 or ）：表示满足其中一个表达式即可。例如，execution(* com.example.service.userservice.add(..)) || execution(* com.example.service.userservice.delete(..))，表示匹配userservice类中的add方法或者delete方法。
- 与（&& 或 and ）：要求同时满足多个表达式。例如，execution(* com.example.service..*.*(..)) && args(string) ，表示匹配com.example.service包及其子包下所有类的方法，且方法参数包含string类型。
- 非（! 或 not ）：对表达式取反。例如，!execution(* com.example.service.userservice.get*(..)) ，表示匹配除了userservice类中以get开头方法之外的其他方法。
其他切点指示符：
- within 表达式：主要用于根据类型（类或包）匹配连接点。它更侧重类或包的范围匹配，而execution更侧重方法签名匹配。
- 匹配指定包下的所有类：语法为within(包名..*)，其中..表示当前包及其子包。例如，within(com.example.service..*)表示匹配com.example.service包及其子包下所有类的所有方法。
- 匹配指定类：语法为within(全限定类名)。例如，within(com.example.service.userservice)表示只匹配com.example.service.userservice类的所有方法。
- @annotation 表达式：根据方法上是否存在特定注解来匹配连接点。当某方法标注指定注解，该方法执行就触发相应切面逻辑。
- 自定义注解：首先定义一个自定义注解，例如：

import java.lang.annotation.elementtype;
import java.lang.annotation.retention;
import java.lang.annotation.retentionpolicy;
import java.lang.annotation.target;
@retention(retentionpolicy.runtime)
@target(elementtype.method)
public @interface loggable {}

用 @annotation 匹配带注解的方法：语法为@annotation(注解全限定名)。例如，@annotation(com.example.annotation.loggable)表示匹配所有带有@loggable注解的方法。

import org.aspectj.lang.joinpoint;
import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    @before("@annotation(com.example.annotation.loggable)")
    public void beforeloggablemethod(joinpoint joinpoint) {
        system.out.println("before method: " + joinpoint.getsignature().getname());
    }
}

在方法上使用注解：在需要增强的方法上添加自定义注解，例如：

import com.example.annotation.loggable;
import org.springframework.stereotype.service;
@service
public class userservice {
    @loggable
    public void saveuser() {
        system.out.println("saving user...");
    }
}

当userservice#saveuser

四、spring aop 的高级特性与应用场景

4.1 引入（introduction）

引入是 spring aop 的一个高级特性，它允许我们在运行时为目标对象动态添加新的接口和实现，而不需要修改目标对象的源代码。这一特性在扩展现有类的功能时非常有用，比如我们可以为一个现有的类添加日志记录、缓存等功能，而无需对该类进行任何改动。

在 spring aop 中，使用引入功能需要定义一个切面，并在切面中使用@declareparents注解。@declareparents注解有三个属性：value指定要引入接口的目标类或类的集合，使用切点表达式来表示；defaultimpl指定接口的默认实现类；defaultannotation指定一个可选的注解，用于标记哪些目标对象应该引入该接口（通常较少使用）。

下面通过一个具体的代码示例来演示引入的使用：
首先，定义一个要引入的接口及其实现类：

// 定义要引入的接口
public interface cacheable {
    void cache();
}
// 接口的实现类
public class cacheableimpl implements cacheable {
    @override
    public void cache() {
        system.out.println("caching data...");
    }
}

然后，定义一个切面类，使用@declareparents注解将cacheable接口引入到目标类：

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.declareparents;
import org.springframework.stereotype.component;
@aspect
@component
public class cacheaspect {
    @declareparents(value = "com.example.service.*service+", defaultimpl = cacheableimpl.class)
    public static cacheable cacheable;
}

在上述代码中，@declareparents注解的value属性使用切点表达式com.example.service.*service+表示com.example.service包下所有以service结尾的类及其子类，defaultimpl属性指定了cacheable接口的默认实现类为cacheableimpl。

最后，在使用时，可以通过类型转换将目标对象转换为引入的接口类型，从而调用引入的方法：

import com.example.service.userservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.commandlinerunner;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
@springbootapplication
public class application implements commandlinerunner {
    @autowired
    private userservice userservice;
    public static void main(string[] args) {
        springapplication.run(application.class, args);
    }
    @override
    public void run(string... args) throws exception {
        cacheable cacheable = (cacheable) userservice;
        cacheable.cache();
    }
}

在上述代码中，将userservice对象转换为cacheable类型，然后调用cache方法，就可以执行引入的缓存功能。通过引入，我们可以在不修改userservice类的情况下，为其添加新的功能，这大大提高了代码的可维护性和扩展性。

4.2 多切面与切面优先级

在实际应用中，可能会存在多个切面作用于同一个目标对象的情况。当多个切面作用于同一目标对象时，它们的执行顺序是有规则的。默认情况下，spring aop 会按照切面类名的字母顺序来决定切面的执行顺序，类名靠前的切面先执行。但这种默认的顺序在很多情况下并不能满足我们的需求，因此 spring 提供了设置切面优先级的机制。

在 spring aop 中，可以通过实现ordered接口或使用@order注解来设置切面的优先级。ordered接口只有一个方法getorder，返回值越小，表示优先级越高。@order注解的使用则更加简洁，它可以直接标注在切面类上，其参数值越小，优先级越高。

下面通过代码示例来演示如何设置切面优先级：
首先，定义两个切面类：

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.springframework.core.ordered;
import org.springframework.core.annotation.order;
import org.springframework.stereotype.component;
@aspect
@component
@order(1) // 设置优先级为1，值越小优先级越高
public class highpriorityaspect {
    @before("execution(* com.example.service.*.*(..))")
    public void highprioritybefore() {
        system.out.println("高优先级切面的前置通知");
    }
}

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.springframework.core.ordered;
import org.springframework.stereotype.component;
@aspect
@component
public class lowpriorityaspect implements ordered {
    @before("execution(* com.example.service.*.*(..))")
    public void lowprioritybefore() {
        system.out.println("低优先级切面的前置通知");
    }
    @override
    public int getorder() {
        return 2; // 设置优先级为2
    }
}

在上述代码中，highpriorityaspect使用@order(1)注解设置优先级为 1，lowpriorityaspect实现ordered接口，通过getorder方法返回 2 来设置优先级为 2。因此，在目标方法执行前，highpriorityaspect的前置通知会先执行，然后才执行lowpriorityaspect的前置通知。

4.3 应用场景举例

日志记录：在企业级应用中，我们通常需要记录方法的调用情况，包括方法的入参、返回值、执行时间等信息。使用 spring aop 可以轻松实现这一需求。通过定义一个日志切面，使用切点表达式匹配所有需要记录日志的方法，然后在前置通知中记录方法的入参和开始时间，在返回通知中记录返回值和执行时间，在异常通知中记录异常信息。这样，所有被匹配的方法在执行时都会自动记录日志，避免了在每个方法中手动添加日志代码，提高了代码的可维护性和可读性。例如：

import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.around;
import org.aspectj.lang.annotation.aspect;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class loggingaspect {
    private static final logger logger = loggerfactory.getlogger(loggingaspect.class);
    @around("execution(* com.example.service.*.*(..))")
    public object logaround(proceedingjoinpoint joinpoint) throws throwable {
        long starttime = system.currenttimemillis();
        string methodname = joinpoint.getsignature().getname();
        object[] args = joinpoint.getargs();
        logger.info("开始执行方法 {}，参数: {}", methodname, args);
        try {
            object result = joinpoint.proceed();
            long endtime = system.currenttimemillis();
            logger.info("方法 {} 执行完毕，返回值: {}，执行时间: {} ms", methodname, result, endtime - starttime);
            return result;
        } catch (exception e) {
            logger.error("方法 {} 执行出错: {}", methodname, e.getmessage());
            throw e;
        }
    }
}

事务管理：在涉及数据库操作的应用中，事务管理是非常重要的。spring aop 可以将事务管理的逻辑从业务代码中分离出来，实现声明式事务管理。通过定义一个事务切面，使用切点表达式匹配需要进行事务管理的方法，然后在环绕通知中开启事务、执行业务方法、根据执行结果提交或回滚事务。这样，业务代码中就不需要显式地编写事务相关的代码，只需要在配置文件或注解中声明事务的属性，如事务的传播行为、隔离级别等，提高了代码的简洁性和事务管理的一致性。例如：

import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.around;
import org.aspectj.lang.annotation.aspect;
import org.springframework.jdbc.datasource.datasourcetransactionmanager;
import org.springframework.transaction.transactionstatus;
import org.springframework.transaction.support.defaulttransactiondefinition;
import org.springframework.stereotype.component;
@aspect
@component
public class transactionaspect {
    private final datasourcetransactionmanager transactionmanager;
    public transactionaspect(datasourcetransactionmanager transactionmanager) {
        this.transactionmanager = transactionmanager;
    }
    @around("execution(* com.example.service.*.*(..)) && @annotation(org.springframework.transaction.annotation.transactional)")
    public object transactionaround(proceedingjoinpoint joinpoint) throws throwable {
        defaulttransactiondefinition def = new defaulttransactiondefinition();
        transactionstatus status = transactionmanager.gettransaction(def);
        try {
            object result = joinpoint.proceed();
            transactionmanager.commit(status);
            return result;
        } catch (exception e) {
            transactionmanager.rollback(status);
            throw e;
        }
    }
}

权限控制：在 web 应用中，我们需要对用户的操作进行权限控制，确保只有具备相应权限的用户才能访问特定的资源或执行特定的操作。spring aop 可以将权限控制的逻辑从业务代码中分离出来，实现统一的权限管理。通过定义一个权限切面，使用切点表达式匹配需要进行权限控制的方法，然后在前置通知中检查用户的权限，根据权限检查结果决定是否允许方法执行。这样，业务代码中就不需要重复编写权限检查的代码，提高了代码的安全性和可维护性。例如：

import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.around;
import org.aspectj.lang.annotation.aspect;
import org.springframework.security.core.authentication;
import org.springframework.security.core.context.securitycontextholder;
import org.springframework.stereotype.component;
@aspect
@component
public class permissionaspect {
    @around("execution(* com.example.controller.*.*(..))")
    public object permissionaround(proceedingjoinpoint joinpoint) throws throwable {
        authentication authentication = securitycontextholder.getcontext().getauthentication();
        if (authentication != null && authentication.isauthenticated()) {
            // 检查用户权限，这里只是示例，实际应用中需要根据具体的权限模型进行检查
            string username = authentication.getname();
            if ("admin".equals(username)) {
                return joinpoint.proceed();
            }
        }
        throw new runtimeexception("没有权限访问该资源");
    }
}

性能监控：在应用性能优化过程中，我们需要了解各个方法的执行时间，找出性能瓶颈。spring aop 可以帮助我们实现方法执行时间的监控。通过定义一个性能监控切面，使用切点表达式匹配需要监控的方法，在环绕通知中记录方法的开始时间和结束时间，计算并输出方法的执行耗时。这样，我们可以方便地对系统中各个方法的性能进行分析，从而有针对性地进行优化。例如：

import org.aspectj.lang.proceedingjoinpoint;
import org.aspectj.lang.annotation.around;
import org.aspectj.lang.annotation.aspect;
import org.slf4j.logger;
import org.slf4j.loggerfactory;
import org.springframework.stereotype.component;
@aspect
@component
public class performancemonitoraspect {
    private static final logger logger = loggerfactory.getlogger(performancemonitoraspect.class);
    @around("execution(* com.example.service.*.*(..))")
    public object monitorperformance(proceedingjoinpoint joinpoint) throws throwable {
        long starttime = system.currenttimemillis();
        object result = joinpoint.proceed();
        long endtime = system.currenttimemillis();
        long executiontime = endtime - starttime;
        logger.info("方法 {} 执行耗时: {} ms", joinpoint.getsignature().getname(), executiontime);
        return result;
    }
}

五、总结与展望

5.1 知识点回顾

在本文中，我们深入探索了 spring aop 这一强大的技术领域。开篇我们阐述了 aop 的基本概念，它作为一种编程范式，将横切关注点从核心业务逻辑中分离，极大地提升了代码的可维护性与复用性。spring aop 则是基于 aop 思想在 spring 框架中的具体实现，通过动态代理机制，在运行时为目标对象创建代理，实现对方法的增强。

接着，我们详细剖析了 spring aop 底层依赖的动态代理机制，包括 jdk 动态代理和 cglib 动态代理。jdk 动态代理基于反射，要求目标对象实现接口；cglib 动态代理通过字节码生成技术，可代理普通类。spring 会根据目标对象是否实现接口来自动选择合适的代理方式。

在实战部分，我们一步步搭建 spring aop 的开发环境，通过注解和 xml 配置两种方式定义切面、切点以及各种通知类型，如前置通知、后置通知、返回通知、异常通知和环绕通知，每种通知都有其独特的执行时机和应用场景。同时，我们还深入学习了切点表达式的语法和使用，它能精准地指定哪些方法会被切面所影响。

进一步地，我们探讨了 spring aop 的高级特性，如引入功能可以在运行时为目标对象动态添加新的接口和实现；多切面的使用中，我们了解了如何通过实现ordered接口或使用@order注解来设置切面的优先级，以控制多个切面的执行顺序。最后，我们列举了 spring aop 在日志记录、事务管理、权限控制和性能监控等多个实际应用场景中的具体应用。

5.2 知识扩展

aspectj 与 spring aop：spring aop 虽然功能强大，但它与 aspectj 有着紧密的联系和一些区别。aspectj 是一个功能更为全面的 aop 框架，它不仅支持运行时织入，还支持编译时织入和类加载时织入。编译时织入可以在编译阶段就将切面逻辑织入到字节码中，这样可以获得更好的性能，因为不需要在运行时动态生成代理对象。类加载时织入则是在类加载到 jvm 时进行织入。aspectj 的切点表达式语言也更为丰富和强大，它可以匹配更多的连接点，如字段访问、构造函数调用等，而 spring aop 主要侧重于方法级别的拦截。在实际应用中，如果对性能要求极高，或者需要更细粒度的切面控制，可以考虑使用 aspectj；而 spring aop 则更适合于一般的 spring 项目，因为它与 spring 框架的集成更加紧密，使用起来更加方便。
aop 在其他框架中的应用：除了 spring 框架，aop 在其他一些框架中也有广泛的应用。例如，在 java ee 开发中，ejb（enterprise javabeans）框架就使用了 aop 的思想来实现事务管理、安全控制等功能。在 web 开发中，struts2 框架也可以通过插件的方式引入 aop，实现对 action 的增强，比如日志记录、权限检查等。在一些移动开发框架中，aop 也被用于实现一些通用的功能，如性能监控、错误处理等，以提高应用的质量和可维护性。了解 aop 在不同框架中的应用，可以帮助我们更好地理解 aop 的通用性和重要性，以及如何在不同的技术栈中灵活运用 aop 来解决实际问题。

5.3 阅读资料推荐

spring 官方文档：spring 官方文档是学习 spring aop 最权威的资料，它详细介绍了 spring aop 的各种功能、配置方式以及使用场景，并且会随着 spring 版本的更新而及时更新，能够让我们了解到 spring aop 的最新特性和最佳实践。可以访问 spring 官方网站（https://spring.io/projects/spring-framework）获取相关文档。
《spring 实战》：这本书是学习 spring 框架的经典书籍，其中有专门的章节深入讲解 spring aop 的原理和实践，通过大量的代码示例和实际案例，帮助读者更好地理解和掌握 spring aop 的使用方法，对于想要深入学习 spring aop 的开发者来说是一本不可多得的好书。
相关技术博客：在技术博客平台上，有许多技术专家和开发者分享了他们在使用 spring aop 过程中的经验和心得，如 infoq、开源中国等。通过阅读这些博客，可以了解到 spring aop 在实际项目中的应用案例、遇到的问题及解决方案，拓宽我们的技术视野，学习到一些实用的技巧和方法。

5.4 问题探讨与互动

在使用 spring aop 的过程中，大家是否遇到过性能瓶颈的问题呢？例如，当切面数量较多或者切点表达式过于复杂时，可能会影响系统的性能。那么如何优化 aop 的性能，减少对系统性能的影响呢？另外，在多切面的场景下，如何更好地处理切面之间的冲突和依赖关系，确保切面的执行顺序符合预期呢？欢迎大家在评论区留言讨论，分享自己的经验和见解。

到此这篇关于深入探索spring aop：从原理到实战的文章就介绍到这了,更多相关spring aop原理内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

深入探索Spring AOP从原理到实战操作

2025年12月01日 • Java •我要评论