深度解析切入点表达式及详细代码展示

csdn_tom_168

于 2025-06-30 08:25:39 发布

阅读量553

点赞数 13

CC 4.0 BY-SA版权

分类专栏： Spring 文章标签： spring java 学习

本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148921168

Spring 专栏收录该内容

23 篇文章

订阅专栏

Spring AOP 的切入点表达式（Pointcut Expression）是定义“哪些方法会被拦截”的核心规则，其语法简洁但功能强大，支持静态匹配（编译时确定）和动态匹配（运行时确定）。本文将从语法细节、底层解析机制、代码示例三个维度深度解析，并结合实际场景展示其用法。

一、切入点表达式的核心语法与分类

1. 语法基础：匹配模式的组成

切入点表达式的核心是匹配模式，用于描述目标方法的特征。其语法格式可简化为：

[modifier] [return-type] [declaring-type] . [method-name] ( [parameter-types] ) [throws-clause]

各部分含义：

modifier：方法修饰符（如 public、protected，* 表示任意）。
return-type：返回类型（如 void、java.lang.String，* 表示任意）。
declaring-type：方法所属类（如 com.example.UserService，* 表示任意类）。
method-name：方法名（如 createUser，* 表示任意方法名，.. 表示任意子包）。
parameter-types：参数类型（如 (String, int)，.. 表示任意数量/类型的参数）。
throws-clause：抛出的异常（如 throws java.lang.Exception，* 表示任意异常）。

2. 常用切点表达式类型与代码示例

Spring AOP 支持以下几类核心切点表达式（基于 AspectJ 语法简化），结合代码示例说明其用法：

（1）`execution`：精确匹配方法执行（最常用）

语法：execution([modifier] returnType declaringType.methodName(parameterTypes) throwsClause)
作用：匹配指定包、类、方法名的方法执行。

代码示例：

// 匹配 com.example.service 包下所有类的所有方法（任意返回类型、参数、异常）
@Pointcut("execution(* com.example.service.*.*(..))")
public void servicePointcut() {}

// 匹配 com.example.service.UserService 类的 createUser 方法（参数为 String, int，返回 User）
@Pointcut("execution(User com.example.service.UserService.createUser(String, int))")
public void createUserPointcut() {}

// 匹配所有 public 方法（返回类型任意，类名任意，方法名任意，参数任意）
@Pointcut("execution(public * *(..))")
public void publicMethodPointcut() {}

（2）`within`：匹配类或包内的所有方法

语法：within(declaringType)
作用：匹配指定类（或其子类）的所有方法。

代码示例：

// 匹配 com.example.service.UserService 类的所有方法
@Pointcut("within(com.example.service.UserService)")
public void userServicePointcut() {}

// 匹配 com.example.service 包下所有类的所有方法（包括子包）
@Pointcut("within(com.example.service..*)")
public void servicePackagePointcut() {}

（3）`annotation`：匹配被指定注解标记的方法

语法：annotation(annotationType)
作用：匹配被指定注解（如 @Loggable）标记的方法。

代码示例：

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

// 匹配被 @Loggable 注解标记的方法
@Pointcut("annotation(com.example.annotation.Loggable)")
public void loggableMethodPointcut() {}

（4）`this`：匹配目标对象是指定类型的实例（JDK 代理）

语法：this(targetType)
作用：当目标对象（被代理对象）是 targetType 或其子类的实例时，匹配其方法（仅适用于 JDK 动态代理）。

代码示例：

// 匹配目标对象是 UserService 实例的方法（JDK 代理时有效）
@Pointcut("this(com.example.service.UserService)")
public void userServiceInstancePointcut() {}

（5）`target`：匹配目标对象是指定类型的实例（CGLIB 代理）

语法：target(targetType)
作用：当目标对象（被代理对象）是 targetType 或其子类的实例时，匹配其方法（仅适用于 CGLIB 代理）。

代码示例：

// 匹配目标对象是 UserService 实例的方法（CGLIB 代理时有效）
@Pointcut("target(com.example.service.UserService)")
public void userServiceInstancePointcut() {}

（6）`args`：匹配参数类型符合要求的方法

语法：args(parameterTypes)
作用：匹配参数类型完全匹配 parameterTypes 的方法。

代码示例：

// 匹配参数为 String 类型的方法（任意返回类型、类名、方法名）
@Pointcut("args(String)")
public void stringArgPointcut() {}

// 匹配参数为 String 和 int 的方法（顺序和类型必须一致）
@Pointcut("args(String, int)")
public void stringIntArgPointcut() {}

（7）`@within`：匹配类上有指定注解的所有方法

语法：@within(annotationType)
作用：匹配被 annotationType 注解标记的类中的所有方法（与 within 类似，但仅匹配注解存在的方法）。

代码示例：

// 匹配被 @Transactional 注解标记的类中的所有方法
@Pointcut("@within(org.springframework.transaction.annotation.Transactional)")
public void transactionalClassPointcut() {}

二、切入点表达式的底层解析机制

1. 核心解析类：`AspectJExpressionPointcut`

Spring 通过 AspectJExpressionPointcut 类解析和执行切入点表达式。其核心流程如下：

表达式编译：将切点表达式字符串编译为 PointcutExpression 对象（基于 AspectJ 的表达式解析器）。
匹配判断：在运行时，通过 matches(Method, Class) 方法判断目标方法是否匹配表达式。

2. 源码解析：`AspectJExpressionPointcut` 的关键方法

（1）`compileExpression`：编译表达式

AspectJExpressionPointcut 在初始化时（或首次使用时）会编译切点表达式，生成可执行的匹配逻辑。

源码片段（简化自 AspectJExpressionPointcut）：

public class AspectJExpressionPointcut implements Pointcut, Serializable {

    private PointcutExpression pointcutExpression; // 编译后的表达式

    public void setExpression(String expression) {
        this.pointcutExpression = compileExpression(expression);
    }

    private PointcutExpression compileExpression(String expression) {
        // 使用 AspectJ 的 ExpressionParser 解析表达式
        AspectJExpressionParser parser = new AspectJExpressionParser();
        return parser.parse(expression);
    }
}

（2）`matches`：判断方法是否匹配

matches 方法通过编译后的 PointcutExpression 判断目标方法是否属于当前切点。

源码片段：

public boolean matches(Method method, Class<?> targetClass) {
    // 调用 AspectJ 的 PointcutExpression 匹配方法
    return pointcutExpression.matchesMethodExecution(method, targetClass);
}

3. 表达式匹配的底层实现

AspectJ 的表达式解析器（AspectJExpressionParser）会将自然语言式的切点表达式转换为抽象语法树（AST），并在 matches 时遍历 AST 进行匹配。例如，对于 execution(* com.example.service.UserService.createUser(String, int))，解析器会：

提取包路径 com.example.service。
提取类名 UserService。
提取方法名 createUser。
提取参数类型 String 和 int。
在运行时检查目标方法的包、类、方法名、参数类型是否完全匹配。

三、代码示例：实际场景中的切点表达式应用

场景 1：日志记录（拦截所有 Service 方法）

通过 execution 表达式匹配所有 Service 类的方法，记录方法执行时间。

代码实现：

@Aspect
@Component
public class LogAspect {

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

    // 前置通知：记录方法开始执行
    @Before("serviceMethodPointcut()")
    public void beforeServiceMethod(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        System.out.println("[LOG] 方法 " + methodName + " 开始执行，参数：" + Arrays.toString(args));
    }

    // 环绕通知：记录方法执行耗时
    @Around("serviceMethodPointcut()")
    public Object aroundServiceMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed(); // 执行目标方法
        long duration = System.currentTimeMillis() - startTime;
        System.out.println("[LOG] 方法 " + joinPoint.getSignature().getName() + " 执行完成，耗时：" + duration + "ms");
        return result;
    }
}

场景 2：权限校验（拦截被 @Admin 注解标记的方法）

通过 annotation 表达式匹配被 @Admin 注解标记的方法，校验用户权限。

代码实现：

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

// 权限校验切面
@Aspect
@Component
public class SecurityAspect {

    // 定义切点：匹配被 @Admin 注解标记的方法
    @Pointcut("annotation(com.example.annotation.Admin)")
    public void adminMethodPointcut() {}

    // 前置通知：校验管理员权限
    @Before("adminMethodPointcut()")
    public void checkAdminPermission(JoinPoint joinPoint) {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("Authorization");
        User user = userService.getUserByToken(token); // 假设 userService 已注入
        if (user == null || !user.isAdmin()) {
            throw new AccessDeniedException("无管理员权限");
        }
    }
}

场景 3：事务管理（拦截被 @Transactional 注解标记的方法）

通过 @within 表达式匹配被 @Transactional 注解标记的类中的所有方法，实现事务管理。

代码实现：

@Aspect
@Component
public class TransactionAspect {

    // 定义切点：匹配被 @Transactional 注解标记的类中的所有方法
    @Pointcut("@within(org.springframework.transaction.annotation.Transactional)")
    public void transactionalClassPointcut() {}

    // 环绕通知：控制事务提交与回滚
    @Around("transactionalClassPointcut()")
    public Object manageTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def); // 获取事务状态

        try {
            Object result = joinPoint.proceed(); // 执行目标方法
            transactionManager.commit(status); // 提交事务
            return result;
        } catch (Throwable e) {
            transactionManager.rollback(status); // 回滚事务
            throw e;
        }
    }
}

四、高级特性：自定义切点表达式

1. 自定义 `Pointcut` 实现

通过实现 org.springframework.aop.Pointcut 接口，自定义匹配逻辑。例如，匹配方法名以 delete 开头的方法。

代码实现：

// 自定义 Pointcut：匹配方法名以 "delete" 开头的方法
public class DeleteMethodPointcut implements Pointcut {

    @Override
    public ClassFilter getClassFilter() {
        return ClassFilter.TRUE; // 匹配所有类
    }

    @Override
    public MethodMatcher getMethodMatcher() {
        return new MethodMatcher() {
            @Override
            public boolean matches(Method method, Class<?> targetClass) {
                // 匹配方法名以 "delete" 开头
                return method.getName().startsWith("delete");
            }

            @Override
            public boolean isRuntime() {
                return false; // 静态匹配（编译时确定）
            }

            @Override
            public boolean matches(Method method, Class<?> targetClass, Object... args) {
                return false; // 不需要运行时参数
            }
        };
    }
}

// 使用自定义 Pointcut 的切面
@Aspect
@Component
public class DeleteLogAspect {

    @Pointcut(new DeleteMethodPointcut()) // 使用自定义 Pointcut
    public void deleteMethodPointcut() {}

    @Before("deleteMethodPointcut()")
    public void beforeDelete(JoinPoint joinPoint) {
        System.out.println("[LOG] 即将删除：" + joinPoint.getSignature().getName());
    }
}

2. 扩展 AspectJ 表达式语法

通过自定义 AspectJExpressionPointcut 的表达式解析器，扩展切点表达式的语法规则。例如，添加 @delete 关键字匹配方法名以 delete 开头的方法。

代码实现（简化）：

// 自定义表达式解析器
public class CustomAspectJExpressionParser extends AspectJExpressionParser {

    @Override
    public PointcutExpression parse(String expression) {
        // 识别 @delete 关键字
        if (expression.startsWith("@delete")) {
            String methodNamePattern = extractMethodNamePattern(expression);
            return new CustomPointcutExpression(methodNamePattern);
        }
        return super.parse(expression);
    }

    private String extractMethodNamePattern(String expression) {
        return expression.substring("@delete".length()).trim();
    }
}

// 自定义 PointcutExpression 实现
class CustomPointcutExpression implements PointcutExpression {
    private final String methodNamePattern;

    public CustomPointcutExpression(String methodNamePattern) {
        this.methodNamePattern = methodNamePattern;
    }

    @Override
    public boolean matchesMethodExecution(Method method, Class<?> targetClass) {
        return method.getName().startsWith(methodNamePattern);
    }
}

// 使用自定义表达式的切面
@Aspect
@Component
public class DeleteLogAspect {

    @Pointcut("@delete(delete)") // 自定义表达式
    public void deleteMethodPointcut() {}

    @Before("deleteMethodPointcut()")
    public void beforeDelete(JoinPoint joinPoint) {
        System.out.println("[LOG] 即将删除：" + joinPoint.getSignature().getName());
    }
}

五、常见问题与最佳实践

1. 切点表达式的性能问题

静态切点 vs 动态切点：execution、within 等静态切点在编译时确定匹配规则，性能较高；args、this 等动态切点在运行时匹配，可能影响性能。
优化建议：尽量使用静态切点（如 execution），避免在高频方法中使用动态切点。

2. 切点表达式的冲突与优先级

多个切点匹配同一方法：Spring 会按照切点在切面中的定义顺序执行通知（可通过 @Order 注解控制切面优先级）。
避免循环匹配：确保切点表达式不会意外匹配到自身（如 execution(* *(..)) 会匹配所有方法，包括切面自身的方法）。

3. 注解切点的局限性

annotation 切点仅匹配被注解标记的方法，无法匹配注解的继承关系（如父类注解不会被子类方法继承）。

4. 自定义切点的测试

使用 @SpringBootTest 启动测试上下文，通过 AopUtils 验证切点是否正确匹配目标方法：

@SpringBootTest
public class PointcutTest {

    @Autowired
    private UserService userService;

    @Test
    public void testPointcut() {
        assertTrue(AopUtils.isAopProxy(userService)); // 验证是否生成代理
        userService.createUser("test", 18); // 调用被切点拦截的方法，验证通知是否触发
    }
}

总结

切入点表达式是 Spring AOP 的核心规则定义语言，通过语法糖（如 execution、within）简化了 AspectJ 的复杂语法。其底层通过 AspectJExpressionPointcut 解析和匹配表达式，结合 AnnotationAwareAspectJAutoProxyCreator 生成代理对象。理解其源码（如表达式编译、匹配逻辑）和扩展机制（自定义 Pointcut、扩展解析器），有助于开发者编写更灵活、高效的 AOP 逻辑。实际应用中，需根据场景选择合适的切点表达式，并注意性能与匹配准确性。