深度理解Spring AOP：面向切面编程的精髓与应用

程序员小胖胖

已于 2024-04-03 18:10:54 修改

阅读量1k

点赞数 39

分类专栏： Spring 文章标签：后端 java spring

于 2024-04-03 17:51:12 首次发布

本文链接：https://blog.csdn.net/weixin_42326548/article/details/137353388

版权

Spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

关注微信公众号 “程序员小胖” 每日技术干货，第一时间送达！

引言

在软件开发的实践中，我们经常会遇到一些跨越多个模块或对象的共通问题，例如日志记录、事务处理、权限校验等。这些问题往往与业务逻辑紧密相关，但又不完全属于业务逻辑的一部分。这时候，Spring AOP（面向切面编程）就显得尤为重要。本文将带您深入了解Spring AOP的精髓，探索其在实际开发中的应用。

什么是Spring AOP？

Spring AOP是Spring框架提供的一个强大的面向切面编程实现。它允许开发者将那些与业务逻辑无关，但却影响多个类或对象的横切关注点（cross-cutting concerns）封装起来，从而提高模块化，减少代码冗余。

Spring AOP的工作原理

Spring AOP 基于代理模式，通过创建目标对象的代理来实现对目标对象的增强。当代理对象的方法被调用时，AOP 框架会在方法执行前后或出现异常时，执行我们定义的增强逻辑。

Spring AOP 两种代理类型：

基于 JDK 动态代理： 当目标对象实现的接口数量较少时，Spring AOP 会使用 JDK 动态代理来创建代理对象。

基于 CGLIB 的代理： 当目标对象没有实现接口或存在多个实现类时，Spring AOP 会使用 CGLIB 来创建代理对象。

Spring AOP的核心概念

要深入理解Spring AOP，我们需要掌握以下几个核心概念：

切面（Aspect）：切面是封装横切关注点的模块，它定义了何时何地以及如何应用增强。


@Aspect
@Component
public class LoggingAspect {
    // ... 定义增强方法
}

连接点（Join Point）：指在程序执行的某个特定位置，这通常是方法的调用点。在AOP术语中，连接点是切面（Aspect）可以应用的地方。通过定义切入点（Pointcut），我们可以指定在哪些连接点上执行特定的增强（Advice）。

首先，我们定义一个简单的业务接口和它的实现，这个实现将成为我们的目标对象：


public interface BankService {
    void transferMoney(String fromAccount, String toAccount, double amount);
}

@Service
public class BankServiceImpl implements BankService {

    @Override
    public void transferMoney(String fromAccount, String toAccount, double amount) {
        // 业务逻辑代码，例如账户间转账操作
        System.out.println("Transferring money from " + fromAccount + " to " + toAccount + " in the amount of " + amount);
    }
}

接下来，我们定义一个切面类，并在其中创建一个切入点和一个前置通知：


@Aspect
@Component
public class TransactionAspect {

    // 定义切入点，匹配BankService接口中的所有方法调用
    @Pointcut("execution(* com.example.service.BankService.*(..))")
    public void bankTransaction() {}

    // 前置通知：在银行服务的方法执行之前执行
    @Before("bankTransaction()")
    public void logTransaction(JoinPoint joinPoint) {
        // JoinPoint对象提供了连接点的信息，例如方法名和参数
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("Before transaction: " + methodName + " with arguments " + Arrays.toString(args));
    }
}

在这个例子中，@Pointcut注解定义了一个名为bankTransaction的切入点，它匹配com.example.service.BankService接口中的所有方法。@Before注解指定了logTransaction方法作为前置通知，它将在bankTransaction切入点匹配的方法执行之前运行。

为了使AOP代理和切入点生效，我们需要在Spring配置中启用AOP代理：


@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 目标对象的定义
    @Bean
    public BankService bankService() {
        return new BankServiceImpl();
    }
}

现在，当我们在应用程序中调用BankServiceImpl的transferMoney方法时，Spring AOP会自动应用TransactionAspect中定义的前置通知：


public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        BankService bankService = context.getBean(BankService.class);
        bankService.transferMoney("123", "456", 1000.00);
    }
}

在这个例子中，ApplicationContext会返回BankService的一个代理对象。当我们调用transferMoney方法时，logTransaction方法将作为前置通知被执行，输出方法名和参数，这就是连接点的应用示例。

通过这个代码示例，我们可以看到如何在Spring AOP中定义连接点，并通过切入点将增强应用到这些连接点上。这种机制使得开发者能够轻松地在方法调用的不同阶段插入额外的行为，增强了代码的灵活性和可维护性。

增强（Advice）：增强是切面对连接点的具体处理逻辑，分为前置增强（Before）、后置增强（After）、环绕增强（Around）和异常增强（After Throwing）。


//前置增强（Before Advice
@Before("execution(* com.example.service.*.*(..))")
public void logBefore(JoinPoint joinPoint) {
    System.out.println("Before method: " + joinPoint.getSignature().getName());
}

//后置增强（After Advice）
@After("execution(* com.example.service.*.*(..))")
public void logAfter(JoinPoint joinPoint) {
    System.out.println("After method: " + joinPoint.getSignature().getName());
}

//环绕增强（Around Advice）
@Around("execution(* com.example.service.*.*(..))")
public Object logAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("Before method execution");
    Object result = proceedingJoinPoint.proceed();
    System.out.println("After method execution");
    return result;
}

//异常增强（After Throwing Advice）
@AfterThrowing(pointcut = "@annotation(com.example.annotation.Loggable)",
                throwing = "exception")
public void logAfterThrowing(JoinPoint joinPoint, Throwable exception) {
    System.out.println("After method threw exception: " + exception.getMessage());
}

切入点（Pointcut）：用于指定增强应该作用的连接点，可以通过表达式来匹配。


@Pointcut("execution(* com.example.service.*.*(..))")
public void servicePointcut() {
    // 该方法本身不执行任何操作，只是声明一个切入点
}

通知（Advice）：与增强类似，是AOP中的一个通用术语，指代在特定连接点执行的代码。


//前置通知（Before Advice）：目标方法执行之前执行。
@Pointcut("execution(* com.example.service.*.*(..))")
public void servicePointcut() {}

@Before("servicePointcut()")
public void beforeAdvice(JoinPoint joinPoint) {
    System.out.println("Before method: " + joinPoint.getSignature().getName());
}

// 后置通知（After Advice）：后置通知在目标方法执行之后执行，无论方法是否成功执行。
@After("servicePointcut()")
public void afterAdvice(JoinPoint joinPoint) {
    System.out.println("After method: " + joinPoint.getSignature().getName());
}

//环绕通知（Around Advice）：环绕通知在目标方法执行前后都能执行，并且可以控制目标方法的执行和返回值。
@Around("servicePointcut()")
public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    System.out.println("Before method execution");
    Object result = proceedingJoinPoint.proceed(); // 执行目标方法
    System.out.println("After method execution");
    return result;
}

//异常通知（After Throwing Advice）：异常通知在目标方法抛出异常时执行。

@AfterThrowing(pointcut = "servicePointcut()", throwing = "exception")
public void afterThrowingAdvice(JoinPoint joinPoint, Throwable exception) {
    System.out.println("After method threw exception: " + exception.getMessage());
}

//返回通知（After Returning Advice）：返回通知在目标方法成功返回后执行。

@AfterReturning(pointcut = "servicePointcut()", returning = "retVal")
public void afterReturningAdvice(JoinPoint joinPoint, Object retVal) {
    System.out.println("After method returned: " + retVal);
}
注意：@Pointcut注解用于定义一个切入点，它指定了通知应该应用到哪些连接点上。servicePointcut()是一个切入点的引用名称，它匹配com.example.service包下的所有方法。
@Before、@After、@Around、@AfterThrowing和@AfterReturning注解分别用于定义不同类型的通知。在这些通知中，JoinPoint对象提供了关于连接点的信息，例如方法名称和参数。ProceedingJoinPoint对象在环绕通知中使用，它允许调用继续执行目标方法。
要使这些通知生效，你需要在Spring配置中启用AOP，并通过@EnableAspectJAutoProxy注解来启用自动代理：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // ...
}

目标对象（Target Object）：指那些被一个或多个切面（Aspect）所通知的对象。目标对象通常是业务逻辑的实现，而切面则是对这些业务逻辑的横切关注点的封装。在AOP代理中，目标对象的方法执行会被切面的增强（Advice）所包围。

首先，我们定义一个业务接口和它的实现，这个实现将成为我们的目标对象：


public interface BusinessService {
    void performTask();
}

@Service
public class BusinessServiceImpl implements BusinessService {
    @Override
    public void performTask() {
        // 业务逻辑代码
        System.out.println("执行业务任务...");
    }
}

接下来，我们定义一个切面类，它将包含对BusinessServiceImpl的增强：


@Aspect
@Component
public class AuditAspect {

    // 定义切入点，这里表示任何BusinessServiceImpl的任何公共方法
    @Pointcut("execution(public * com.example.service.BusinessServiceImpl.*(..))")
    public void anyPublicOperation() {}

    // 前置通知：在目标对象的任何公共方法执行之前执行
    @Before("anyPublicOperation()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("前置通知：方法 " + joinPoint.getSignature().getName() + " 即将执行。");
    }

    // 后置通知：在目标对象的方法执行之后执行
    @After("anyPublicOperation()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("后置通知：方法 " + joinPoint.getSignature().getName() + " 已执行。");
    }

    // 环绕通知：在目标对象的方法执行之前和之后执行
    @Around("anyPublicOperation()")
    public Object audit(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知：方法 " + proceedingJoinPoint.getSignature().getName() + " 开始执行。");
        Object result = proceedingJoinPoint.proceed(); // 执行目标方法
        System.out.println("环绕通知：方法 " + proceedingJoinPoint.getSignature().getName() + " 执行完毕。");
        return result;
    }
}

在这个例子中，BusinessServiceImpl是目标对象，它实现了BusinessService接口。AuditAspect是切面类，它定义了三个不同类型的增强：前置通知、后置通知和环绕通知。这些增强都会作用于BusinessServiceImpl的公共方法上。

当我们在应用程序中调用BusinessServiceImpl的performTask方法时，Spring AOP会自动应用定义在AuditAspect中的增强。这就是Spring AOP中目标对象和切面如何协同工作的一个基本示例。通过这种方式，我们可以将横切关注点（如日志记录、安全检查等）与业务逻辑分离，从而提高代码的模块化和可维护性

代理（Proxy）：代理对象是AOP框架创建的，它包装了目标对象（Target Object），并在目标对象的方法执行前后应用切面的增强（Advice）。代理对象使得开发者能够在不修改目标对象代码的情况下，为其添加额外的行为。

首先，我们定义一个简单的业务接口和它的实现，这个实现将成为我们的目标对象：

public interface BusinessService {
    void performBusinessTask();
}

@Service
public class BusinessServiceImpl implements BusinessService {
    @Override
    public void performBusinessTask() {
        // 业务逻辑代码
        System.out.println("执行业务任务...");
    }
}

接下来，我们定义一个切面类，它将包含对BusinessServiceImpl的增强：

@Aspect
@Component
public class LoggingAspect {

    // 定义切入点，这里表示任何BusinessServiceImpl的方法执行
    @Pointcut("execution(* com.example.service.BusinessServiceImpl.*(..))")
    public void businessServiceOperation() {}

    // 前置通知：在目标对象的方法执行之前执行
    @Before("businessServiceOperation()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("前置通知：方法 " + joinPoint.getSignature().getName() + " 即将执行。");
    }

    // 后置通知：在目标对象的方法执行之后执行
    @After("businessServiceOperation()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("后置通知：方法 " + joinPoint.getSignature().getName() + " 已执行。");
    }
}

为了使AOP代理生效，我们需要在Spring配置中启用AOP代理：

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true) // 指定使用CGLIB代理
public class AppConfig {
    // 目标对象的定义
    @Bean
    public BusinessService businessService() {
        return new BusinessServiceImpl();
    }
}

现在，当我们在应用程序中调用BusinessServiceImpl的performBusinessTask方法时，Spring AOP会自动应用LoggingAspect中定义的增强：


public class Application {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        BusinessService businessService = context.getBean(BusinessService.class);
        businessService.performBusinessTask();
    }
}

在这个例子中，ApplicationContext会返回BusinessService的一个代理对象。当我们调用performBusinessTask方法时，logBefore和logAfter方法将分别作为前置通知和后置通知被执行。

通过这个代码示例，我们可以看到Spring AOP如何创建代理对象，并在目标对象的方法执行前后应用增强逻辑。这种机制使得开发者能够轻松地将横切关注点（如日志记录、事务管理等）与业务逻辑分离，从而提高代码的可维护性和灵活性。

Spring AOP的应用场景

日志记录：在方法调用前后记录日志信息，便于跟踪和调试。
事务管理：自动管理数据库事务的开启、提交和回滚。
权限校验：在方法执行前检查用户权限，确保数据访问的安全性。
性能监控：统计方法执行时间，分析性能瓶颈。
5. 异常处理：统一处理不同层抛出的异常，提供错误信息和恢复机制。

如何深入学习Spring AOP？

理解代理机制：学习Java的代理机制，了解动态代理和CGLIB代理的区别。
掌握切入点表达式：熟悉切入点表达式的语法和用法，能够精确匹配目标连接点。
实践应用：通过实际项目应用Spring AOP，解决具体的横切关注点问题。
阅读源码：深入Spring AOP的源码，理解其内部实现原理。

结语

通过深度理解Spring AOP，我们可以更好地将关注点分离，提高代码的可维护性和可扩展性。Spring AOP不仅仅是一个技术实现，更是一种编程思想，它引导我们思考如何更优雅地解决问题。让我们一起掌握Spring AOP，提升我们的编程技艺，构建更加健壮和高效的软件系统。

程序员小胖胖

关注

39
点赞
踩
26

收藏

觉得还不错? 一键收藏
1
评论
深度理解Spring AOP：面向切面编程的精髓与应用

在软件开发的实践中，我们经常会遇到一些跨越多个模块或对象的共通问题，例如日志记录、事务处理、权限校验等。这些问题往往与业务逻辑紧密相关，但又不完全属于业务逻辑的一部分。这时候，Spring AOP（面向切面编程）就显得尤为重要。
复制链接

扫一扫