Java aop切面使用方法详解_Java

一、为什么需要切面？

在面向对象编程（oop）中，我们通常会将业务逻辑封装到不同的类中，并通过继承和多态来实现代码的复用和扩展。然而，有些功能（如日志记录、事务管理、安全控制等）并不属于任何单一的业务逻辑，而是横切在多个业务逻辑中的。如果直接将这些功能硬编码到每个业务逻辑中，会导致代码的重复和混乱，违反了单一职责原则。

例如，假设我们有一个用户管理模块和一个订单管理模块，它们都涉及到日志记录和事务管理。如果我们将日志记录和事务管理的代码直接写在每个模块中，那么每个模块都需要维护相同的代码。一旦日志记录或事务管理的需求发生变化，就需要在每个模块中修改代码，这显然很不方便。

为了解决这个问题，aop 提出了切面的概念。切面将横切关注点封装起来，可以在运行时动态地插入到主业务逻辑中。这样，我们就可以在不修改主业务逻辑代码的情况下，轻松地管理横切关注点。

二、如何使用切面？

1. 引入 aop 的依赖

在项目中使用切面，首先需要引入 aop 相关的依赖。如果你使用的是 maven 项目，可以在 pom.xml 文件中添加以下依赖：

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-aop</artifactid>
</dependency>

2. 定义切面类

切面类是 aop 的核心，它封装了横切关注点。在 spring 中，我们可以通过 @aspect 注解来定义切面类。例如，我们定义一个日志记录的切面类：

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.aspectj.lang.joinpoint;
import org.springframework.stereotype.component;

@aspect
@component
public class loggingaspect {
    @before("execution(* com.example.demo.service.*.*(..))")
    public void logbefore(joinpoint joinpoint) {
        system.out.println("before method: " + joinpoint.getsignature().getname());
    }
}

在上面的代码中，@aspect 注解表示这是一个切面类，@before 注解表示这是一个前置通知，它会在目标方法执行之前被调用。execution(* com.example.demo.service.*.*(..)) 是一个切入点表达式，表示匹配 com.example.demo.service 包下的所有类的所有方法。

3. 使用切面

定义好切面类后，我们就可以在业务逻辑中使用它了。假设我们有一个用户服务类：

import org.springframework.stereotype.service;

@service
public class userservice {
    public void adduser() {
        system.out.println("adding user...");
    }
}

当调用 adduser 方法时，loggingaspect 中的 logbefore 方法会被自动调用，并输出日志信息。

4. 测试切面

我们可以创建一个测试类来验证切面是否生效：

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.test.context.springboottest;
import org.junit.jupiter.api.test;

@springboottest
public class aspecttest {
    @autowired
    private userservice userservice;

    @test
    public void testaspect() {
        userservice.adduser();
    }
}

运行测试，你会看到控制台输出了日志信息，证明切面生效了。

三、切面的其他使用场景

除了日志记录外，切面还可以用于其他多种场景，例如：

1. 事务管理

我们可以定义一个事务管理的切面类，统一管理事务：

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.pointcut;
import org.aspectj.lang.annotation.before;
import org.aspectj.lang.annotation.afterreturning;
import org.aspectj.lang.annotation.afterthrowing;
import org.aspectj.lang.annotation.after;

@aspect
@component
public class transactionaspect {
    @pointcut("execution(* com.example.demo.service.*.*(..))")
    public void servicemethods() {}

    @before("servicemethods()")
    public void before() {
        system.out.println("transaction started");
    }

    @afterreturning("servicemethods()")
    public void afterreturning() {
        system.out.println("transaction committed");
    }

    @afterthrowing("servicemethods()")
    public void afterthrowing() {
        system.out.println("transaction rolled back");
    }

    @after("servicemethods()")
    public void after() {
        system.out.println("transaction ended");
    }
}

这样，我们就可以在不修改业务逻辑代码的情况下，统一管理事务。

2. 安全控制

我们还可以定义一个安全控制的切面类，检查用户是否具有权限：

import org.aspectj.lang.annotation.aspect;
import org.aspectj.lang.annotation.before;
import org.aspectj.lang.joinpoint;
import org.springframework.stereotype.component;

@aspect
@component
public class securityaspect {
    @before("execution(* com.example.demo.service.*.*(..))")
    public void checkpermission(joinpoint joinpoint) {
        // 检查用户是否具有权限
        system.out.println("checking permission for method: " + joinpoint.getsignature().getname());
    }
}

在业务逻辑中，无需再手动检查权限，切面会自动完成这个工作。