JAVA：使用 Spring AOP 实现面向切面编程

拾荒的小海螺

已于 2024-04-16 17:18:39 修改

阅读量1.1k

点赞数 23

分类专栏： JAVA 文章标签： java spring servlet

于 2024-04-12 16:15:31 首次发布

本文链接：https://blog.csdn.net/lishangke/article/details/137568268

版权

JAVA 专栏收录该内容

41 篇文章 1 订阅

订阅专栏

请关注微信公众号：拾荒的小海螺

1、简述

在现代的软件开发中，面向切面编程（AOP）是一种重要的编程范式，它允许我们将横切关注点（如日志记录、性能监控、事务管理等）从应用程序的核心业务逻辑中分离出来，以提高代码的模块化和可维护性。Spring 框架提供了强大的 AOP 支持，使得我们可以轻松地实现面向切面编程。本文将介绍 Spring AOP 的基本概念、工作原理，并列举常见的应用场景样例。
在这里插入图片描述

2、工作原理

Spring AOP 基于代理模式实现，它使用代理对象包装目标对象，然后根据切点（pointcut）和通知（advice）来确定在何时、何地执行横切逻辑。以下是 Spring AOP 中的关键概念：

切点（Pointcut）：切点是一个表达式，它定义了在应用程序中哪些地方应该应用通知。通常使用 AspectJ 切点表达式来描述切点。
通知（Advice）：通知是在切点上执行的具体操作，它定义了在目标方法执行前、执行后或抛出异常时应该执行的逻辑。
切面（Aspect）：切面是通知和切点的结合，它是面向切面编程的核心单元。一个切面定义了何时、何地应用哪种通知。
连接点（Join Point）：连接点是在应用程序执行过程中能够应用通知的点，例如方法调用、方法执行、异常处理等。
引入（Introduction）：引入允许我们向现有的类添加新的方法和属性。
目标对象（Target Object）：目标对象是被代理的真实对象，它包含核心业务逻辑。
代理对象（Proxy Object）：代理对象是 Spring AOP 创建的对象，它包装了目标对象并应用了通知。

3、应用场景

Spring AOP（Aspect-Oriented Programming）是 Spring 框架的一个模块，它提供了一种将横切关注点（cross-cutting concerns）模块化的方式。横切关注点是那些影响应用程序的多个部分的功能，例如日志记录、事务管理等。AOP 的核心思想是通过在程序运行期间动态地将这些横切关注点与核心业务逻辑织入（weave）到一起，而不是在代码编写阶段硬编码它们。

3.1 日志记录

记录方法的入参、出参以及执行时间，以便进行系统运行状态监控和故障定位：

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logMethodCall(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Calling method: " + methodName);
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
    public void logMethodReturn(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Method " + methodName + " returned: " + result);
    }
}

3.2 性能监控

记录方法的执行时间，分析系统性能瓶颈和优化空间：

@Aspect
@Component
public class PerformanceMonitoringAspect {

    @Around("execution(* com.example.service.*.*(..))")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        System.out.println("Method execution time: " + (endTime - startTime) + " ms");
        return result;
    }
}

3.3 事务管理

在方法执行前开启事务，在方法执行后根据执行结果决定提交或回滚事务：

@Aspect
@Component
public class TransactionAspect {

    @Autowired
    private PlatformTransactionManager transactionManager;

    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object manageTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            Object result = joinPoint.proceed();
            transactionManager.commit(status);
            return result;
        } catch (Exception ex) {
            transactionManager.rollback(status);
            throw ex;
        }
    }
}

3.4 权限控制

根据用户权限控制方法的访问权限，防止未授权操作：

@Aspect
@Component
public class SecurityAspect {

    @Autowired
    private SecurityService securityService;

    @Before("@annotation(org.springframework.security.access.annotation.Secured) && execution(* com.example.controller.*.*(..))")
    public void checkPermission(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String[] rolesAllowed = signature.getMethod().getAnnotation(Secured.class).value();
        if (!securityService.hasPermission(rolesAllowed)) {
            throw new AccessDeniedException("Access Denied");
        }
    }
}