Spring学习通过AspectJ注解方式实现AOP操作

Sure! 让我们详细讲解如何通过AspectJ注解方式实现AOP操作。

什么是AOP

AOP（Aspect-Oriented Programming）是一种编程范型，它可将应用程序中横切关注点（如日志记录、性能统计、安全控制、业务流程等等）从业务逻辑中剥离出来，实现代码分离，提高代码的模块化和可维护性。

在Spring框架中，AOP是一个核心特性，可以方便地将AOP应用于应用程序中，通过独立定义切面（Aspect），并将其针对于目标对象进行切入操作，实现横切关注点（Cross-cutting Concerns）的编程。

AspectJ注解方式实现AOP

AspectJ注解方式是Spring AOP的一个强大特性，它可通过注解方式，直接在Java类中定义切面（Aspect），在切面中定义切入点（Pointcut）和通知（Advice），并将其应用于目标对象上。

以下是通过AspectJ注解方式实现AOP的步骤：

1. 引入AspectJ相关依赖库

在pom.xml文件中，引入Spring AOP和AspectJ相关依赖库：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.2.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
</dependencies>

2. 定义切面（Aspect）

在Java类上加上@Aspect注解，将其定义为一个切面，并在切面中定义切入点（Pointcut）和通知（Advice）。

@Aspect
@Component
public class LoggingAspect {

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

    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Logging before " + joinPoint.getSignature().getName() + " method");
    }

    @After("serviceMethods()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("Logging after " + joinPoint.getSignature().getName() + " method");
    }
}

上述代码说明：

@Aspect注解表示这是一个切面类，在Spring应用程序启动时，会自动扫描@Component注解标识的类，并将其转换为切面类。
@Pointcut注解定义了一个切入点，表示匹配com.example.demo.service包下所有类的所有方法。
@Before和@After注解定义了前置通知（Before advice）和后置通知（After advice），分别在目标方法执行前和执行后触发。

3. 在目标对象上应用切面（Aspect）

在需要应用切面的目标对象上，添加@Aspect注解，并在Bean上定义AspectJ代理。

@Service
@Aspect
public class UserServiceImpl implements UserService {

    @Override
    public void addUser(User user) {
        System.out.println("Adding user: " + user.getName());
    }

}

在Spring配置文件中定义AspectJ代理：

<aop:aspectj-autoproxy/>

示例一

假设我们要在UserService中记录方法调用日志。可以将其定义为切入点：

@Pointcut("execution(* com.example.demo.service.UserService.*(..))")
public void serviceMethods() {}

在切面中定义前置通知（Before advice），记录方法调用前的日志：

@Before("serviceMethods()")
public void logBefore(JoinPoint joinPoint) {
    System.out.println("Logging before " + joinPoint.getSignature().getName() + " method");
}

在UserService中调用addUser方法时，会触发切面，记录日志：

@Override
public void addUser(User user) {
    System.out.println("Adding user: " + user.getName());
}

执行结果：

Logging before addUser method
Adding user: Alice
Logging after addUser method

示例二

假设我们要实现一个访问控制的系统，在UserService中，在用户执行每个操作时，需要检查是否具有访问权限。可以将其定义为切入点：

@Pointcut("execution(* com.example.demo.service.UserService.*(..)) && @annotation(com.example.demo.annotation.AccessControl)")
public void serviceMethods() {}

其中，@annotation(com.example.demo.annotation.AccessControl)表示要求匹配被@AccessControl注解标识的方法。

在切面中定义环绕通知（Around advice），检查用户是否具有访问权限：

@Around("serviceMethods()")
public Object checkAccessPermission(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Checking access permission before " + joinPoint.getSignature().getName() + " method");

    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    Method method = signature.getMethod();
    AccessControl accessControl = method.getAnnotation(AccessControl.class);
    if (accessControl != null) {
        boolean hasPermission = checkUserAccessPermission();
        if (!hasPermission) {
            throw new SecurityException("Access denied!");
        }
    }

    Object result = joinPoint.proceed();
    System.out.println("Checking access permission after " + joinPoint.getSignature().getName() + " method");
    return result;
}

在UserService中调用addUser方法时，会触发切面检查访问权限：

@Override
@AccessControl
public void addUser(User user) {
    System.out.println("Adding user: " + user.getName());
}