面向切面编程 AOP

🎯学习目标

• 理解 AOP 的基本概念，掌握 AOP 与 OOP 的关系和互补性；
• 掌握 AOP 的五大核心概念：切面、连接点、通知、切点、织入；
• 了解 AOP 的三种实现方式：编译时织入、类加载时织入、运行时织入；
• 掌握 Spring AOP 的注解配置和 XML 配置方式；
• 能够运用 AOP 解决日志记录、事务管理、权限控制等实际问题。

1AOP 概述

什么是 AOP？

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在将横切关注点（Cross-Cutting Concerns）从业务逻辑中分离出来，实现关注点的模块化。

为什么需要 AOP？

AOP 与 OOP 的关系

2AOP 核心概念

五种通知类型详解

3AOP 实现方式

根据织入时机的不同，AOP 有三种主要实现方式：

4Spring AOP ⭐

Spring AOP 是 Spring 框架的核心模块之一，通过动态代理技术实现 AOP 功能。

Spring AOP 的代理机制

注解配置方式（推荐）⭐

// 1. 定义切面
@Aspect
@Component
public class LoggingAspect {

    // 定义切点：匹配 service 包下所有类的所有方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceLayer() {}

    // 前置通知：方法执行前
    @Before("serviceLayer()")
    public void beforeAdvice(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("调用方法: " + methodName + "，参数: " + Arrays.toString(args));
    }

    // 后置通知：方法执行后（无论是否异常）
    @After("serviceLayer()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("方法执行完毕: " + joinPoint.getSignature().getName());
    }

    // 返回通知：方法正常返回后
    @AfterReturning(pointcut = "serviceLayer()", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.out.println("方法返回值: " + result);
    }

    // 异常通知：方法抛出异常后
    @AfterThrowing(pointcut = "serviceLayer()", throwing = "ex")
    public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {
        System.out.println("方法异常: " + ex.getMessage());
    }

    // 环绕通知：包裹方法执行
    @Around("serviceLayer()")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = pjp.proceed();  // 执行目标方法
        long time = System.currentTimeMillis() - start;
        System.out.println("方法耗时: " + time + "ms");
        return result;
    }
}

切入点表达式

XML 配置方式

<beans xmlns="http://www.springframework.org/schema/beans"
       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">

    <!-- 定义切面 Bean -->
    <bean id="loggingAspect" class="com.example.aspect.LoggingAspect"/>

    <!-- AOP 配置 -->
    <aop:config>
        <!-- 定义切点 -->
        <aop:pointcut id="servicePointcut"
            expression="execution(* com.example.service.*.*(..))"/>

        <!-- 定义切面 -->
        <aop:aspect ref="loggingAspect">
            <aop:before method="beforeAdvice" pointcut-ref="servicePointcut"/>
            <aop:after method="afterAdvice" pointcut-ref="servicePointcut"/>
            <aop:around method="aroundAdvice" pointcut-ref="servicePointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

启用 AOP 支持

// 方式1：注解启用
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
}

// 方式2：XML 启用
<aop:aspectj-autoproxy/>

5AOP 应用场景

完整示例：日志切面

@Aspect
@Component
@Slf4j
public class LogAspect {

    @Pointcut("execution(* com.example.controller.*.*(..))")
    public void controllerLayer() {}

    @Around("controllerLayer()")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        String className = pjp.getTarget().getClass().getSimpleName();
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();

        log.info("[{}] 方法开始执行，参数: {}", className + "." + methodName, args);

        long start = System.currentTimeMillis();
        try {
            Object result = pjp.proceed();
            long time = System.currentTimeMillis() - start;
            log.info("[{}] 方法执行成功，耗时: {}ms，返回: {}",
                     className + "." + methodName, time, result);
            return result;
        } catch (Exception e) {
            long time = System.currentTimeMillis() - start;
            log.error("[{}] 方法执行异常，耗时: {}ms，异常: {}",
                      className + "." + methodName, time, e.getMessage());
            throw e;
        }
    }
}

完整示例：权限校验切面

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequireRole {
    String value();
}

// 权限切面
@Aspect
@Component
public class AuthAspect {

    @Around("@annotation(requireRole)")
    public Object checkAuth(ProceedingJoinPoint pjp, RequireRole requireRole) throws Throwable {
        // 获取当前用户
        User currentUser = SecurityContext.getCurrentUser();
        if (currentUser == null) {
            throw new UnauthorizedException("用户未登录");
        }

        // 检查角色
        String requiredRole = requireRole.value();
        if (!currentUser.hasRole(requiredRole)) {
            throw new ForbiddenException("权限不足，需要角色: " + requiredRole);
        }

        return pjp.proceed();
    }
}

// 使用方式
@Service
public class UserService {
    @RequireRole("ADMIN")
    public void deleteUser(Long userId) {
        // 只有管理员才能执行
    }
}

6AOP 最佳实践

最佳实践清单

切面执行顺序

@Aspect
@Component
@Order(1)  // 数字越小，优先级越高
public class SecurityAspect {
    // 安全校验（先执行）
}

@Aspect
@Component
@Order(2)
public class LoggingAspect {
    // 日志记录（后执行）
}

// 方案1：注入自身
@Service
public class UserService {
    @Autowired
    private UserService self;  // 注入代理对象

    public void methodA() {
        self.methodB();  // 通过代理调用，触发 AOP
    }

    @Transactional
    public void methodB() { }
}

// 方案2：启用 exposeProxy
@EnableAspectJAutoProxy(exposeProxy = true)
public class AppConfig { }

// 使用方式
public void methodA() {
    ((UserService) AopContext.currentProxy()).methodB();
}

⭐重点例题

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

🎯自测（点击展开）

📝强化题库

选择题点选即时判分；填空题输入后"检查"或"显示答案"。