18：面向切面编程-Java Spring

18.1 AOP是什么

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在解决软件系统中跨越多个组件的横切关注点（cross-cutting concerns）。这些关注点是系统中分散但又相互关联的功能，如日志记录、事务管理、安全认证（如JWT）、性能监控等，它们往往贯穿于多个业务模块，如果按照传统的面向对象编程（OOP）方式实现，会导致代码重复和模块间的紧耦合。AOP通过提供一种新的结构化方法，允许开发者将这些横切关注点从主业务逻辑中分离出来，并集中到专门的“切面”（Aspects）中进行管理和维护，从而提高代码的可读性、可重用性和可维护性。

18.2 Spring 的 AOP 实现机制

Spring AOP 实现基于动态代理技术，具体分为以下步骤：

1. 切面（Aspect）：切面是包含通知（Advice）和切点（Pointcut）定义的模块化单元。通知是实际在特定连接点（Join Point）上执行的代码片段，如前置通知（Before Advice）、后置通知（After Advice）、环绕通知（Around Advice）、异常通知（AfterThrowing Advice）等。切点则是定义了哪些连接点（通常是方法调用）应该受到通知的影响。
   
2. 连接点（Join Point）：在Spring AOP中，连接点通常指代方法执行、方法调用这样的执行点。理论上，任何在程序执行过程中明确的点都可以作为连接点，但Spring仅支持方法级别的连接点。
   
3. 通知（Advice）：通知定义了在切点上执行的额外行为。如：

• 前置通知（Before Advice）：在切点方法执行前执行。
• 后置通知（After Advice）：在切点方法正常完成后执行（无论方法是否抛出异常）。
• 环绕通知（Around Advice）：包围切点方法执行，可以控制何时执行切点方法、何时返回结果以及是否抛出异常。
• 异常通知（AfterThrowing Advice）：在切点方法抛出异常后执行。
• 最终通知（After (finally) Advice）：无论切点方法是否正常结束、是否抛出异常，都会执行的通知。

4. 切点（Pointcut）：切点是一个或一组连接点的集合，通过切点表达式（Pointcut Expression）来定义。Spring使用AspectJ Pointcut Expression Language (AJDT/AspectJ PEP)来描述切点，如方法名、参数类型、注解等条件，以便精确匹配需要进行增强的方法。
   
5. 代理（Proxy）：Spring AOP通过生成代理对象来实现切面的织入。对于使用接口的代理对象，Spring默认使用JDK动态代理；对于没有接口的类，Spring使用CGLIB库来创建子类代理。代理对象在方法调用时，会根据切面的定义执行相应的通知逻辑。
   

Spring AOP 的实现机制涉及到多个组件和类的协作，以下是一个简化版的示例代码，展示如何使用 Spring AOP 实现一个简单的日志切面。这个例子仅作为理解Spring AOP实现机制的入门参考，实际应用中可能需要考虑更多细节和配置。

首先，定义一个简单的业务接口和实现：

// 业务接口
public interface BusinessService {
    void doBusiness();
}
// 业务实现
@Service
public class BusinessServiceImpl implements BusinessService {
    @Override
    public void doBusiness() {
        System.out.println("Doing business...");
    }
}

然后，创建一个切面（Aspect），包含切点（Pointcut）定义和通知（Advice）：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LoggingAspect {
    private static final Logger log = LoggerFactory.getLogger(LoggingAspect.class);
    /**
     * 定义切点，匹配所有BusinessService接口下的doBusiness方法
     */
    @Pointcut("execution(* com.example.BusinessService.doBusiness(..))")
    public void businessMethodExecution() {
        // 这里无需编写代码，仅用于定义切点
    }
    /**
     * 定义环绕通知，将在切点方法执行前后执行
     */
    @Around("businessMethodExecution()")
    public void logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        // 前置通知：方法执行前记录开始日志
        log.info("Starting method: {}", joinPoint.getSignature().getName());
        // 继续执行原方法
        Object result = joinPoint.proceed();
        // 后置通知：方法执行后记录结束日志
        log.info("Finished method: {}, result: {}", joinPoint.getSignature().getName(), result);
    }
}

在这个示例中：

• LoggingAspect类使用@Aspect和@Component注解，表明它是一个Spring托管的切面组件。
• @Pointcut注解定义了切点businessMethodExecution，它匹配BusinessService接口的doBusiness方法。
• @Around注解定义了一个环绕通知logAround，当切点方法被调用时，这个通知方法会被执行。它记录了方法执行前后的日志，并通过joinPoint.proceed()调用继续执行原方法。

确保Spring配置正确启用AOP支持。在Spring Boot项目中，通常只需添加对spring-boot-starter-aop依赖即可自动启用AOP。在XML配置文件中，可以使用<aop:aspectj-autoproxy/>标签开启AOP自动代理。

运行应用程序，调用BusinessServiceImpl的doBusiness方法时，你会看到对应的日志输出，这正是通过Spring AOP切面实现的。这个例子展示了Spring AOP如何利用代理模式和切点表达式语言，将日志记录这一横切关注点与业务逻辑分离，实现了非侵入式的日志增强。实际使用时可能还需要配置Spring扫描切面所在的包，确保Spring能够识别并应用这些切面。

18.3 定义 Pointcut

在Spring中，切点定义通常使用AspectJ切点表达式语言编写，该语言提供了丰富的语法来匹配方法签名、类层次、注解等。一个简单的切点定义示例：

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayerMethods() {}

在这个例子中，@Pointcut注解定义了一个名为serviceLayerMethods的切点，其表达式为execution(* com.example.service.*.*(..))。该表达式的含义是匹配com.example.service包及其子包下所有类的所有方法（方法名任意，参数任意）。

18.4 定义 Aspect

在Spring中，切面（Aspect）通常表现为一个带有@Aspect注解的Java类，它包含了切点定义（Pointcut）和通知（Advice）。下面是一个结合JWT认证的简单示例：

@Aspect
@Component
public class JwtAuthenticationAspect {
    @Autowired
    private JwtTokenService jwtTokenService;
    @Pointcut("execution(* com.example.controller.*.*(..)) && @annotation(com.example.security.JwtRequired)")
    public void authenticatedApiMethods() {}
    @Around("authenticatedApiMethods()")
    public Object validateTokenAndProceed(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取请求头中的JWT令牌
        String token = extractTokenFromRequest(joinPoint);
        // 验证令牌有效性
        if (!jwtTokenService.validateToken(token)) {
            throw new UnauthorizedException("Invalid or expired JWT token");
        }
        // 令牌有效，继续执行原方法
        return joinPoint.proceed();
    }
    // ... 其他辅助方法，如extractTokenFromRequest()
}

在这个示例中：

• 类JwtAuthenticationAspect使用@Aspect和@Component注解，表明它是一个Spring托管的切面。
• 定义了切点authenticatedApiMethods，匹配所有标注了@JwtRequired注解的com.example.controller包及其子包下的方法。
• 定义了一个环绕通知validateTokenAndProceed，当匹配的切点方法被调用时，首先提取并验证请求头中的JWT令牌，若无效则抛出异常，否则继续执行原方法。

18.5 AOP 的例子：JWT 认证

上述代码展示了如何使用Spring AOP来处理JWT认证这一横切关注点。当控制器中的某个方法被标记为@JwtRequired时，Spring AOP会自动拦截该方法的调用，通过切面JwtAuthenticationAspect执行JWT令牌的验证逻辑。如果令牌有效，请求才会被允许继续执行至目标方法；否则，抛出异常拒绝访问。

通过这种方式，JWT认证逻辑被集中封装在切面中，与业务逻辑分离，使得代码更易于理解和维护，同时避免了在每个需要保护的控制器方法中手动添加重复的验证代码。