Spring AOP切面编程，注解@Aspect的使用

最新推荐文章于 2025-02-24 17:09:40 发布

捞起月亮的渔民小豪

最新推荐文章于 2025-02-24 17:09:40 发布

阅读量1.3k

点赞数 1

文章标签： spring java 后端 springboot

本文链接：https://blog.youkuaiyun.com/csdndys/article/details/129858212

版权

AOP是一种编程思想，用于将横切关注点（如日志、事务管理）从核心业务中分离，降低耦合。SpringAOP是其实现之一，涉及通知、切点、切面等概念。通过@Aspect等注解定义切面和增强逻辑，实现方法的自动拦截和处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

AOP思想:

AOP(Aspect Oriented Programming)是一种面向切面的编程思想。

面向切面编程是将程序抽象成各个切面，即解剖对象的内部，将那些影响了多个类的公共行为抽取到一个可重用模块里，减少系统的重复代码，降低模块间的耦合度，增强代码的可操作性和可维护性。AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理、增强处理。性能

使用场景

利用AOP可以对我们边缘业务进行隔离，降低无关业务逻辑耦合性。提高程序的可重用性，同时提高了开发的效率。一般用于日志记录，性能统计，安全控制，权限管理，事务处理，异常处理，资源池管理。

技术要点

通知（Advice）包含了需要用于多个应用对象的横切行为，完全听不懂，没关系，通俗一点说就是定义了“什么时候”和“做什么”。
连接点（Join Point）是程序执行过程中能够应用通知的所有点。
切点（Poincut）是定义了在“什么地方”进行切入，哪些连接点会得到通知。显然，切点一定是连接点。
切面（Aspect）是通知和切点的结合。通知和切点共同定义了切面的全部内容——是什么，何时，何地完成功能。
引入（Introduction）允许我们向现有的类中添加新方法或者属性。
织入（Weaving）是把切面应用到目标对象并创建新的代理对象的过程，分为编译期织入、类加载期织入和运行期织入。

用法

1. 引入依赖

在使用 Spring AOP 之前，我们需要在项目中引入 Spring AOP 的依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.14</version>
</dependency>

2. 定义切面

使用 @Aspect 注解定义切面，@Pointcut 注解定义切点，@Before、@After、@Around 等注解定义增强逻辑。例如：

@Aspect
@Component
public class LogAspect {

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

    @Before("servicePointcut()")
    public void before(JoinPoint joinPoint) {
        // 执行前置增强逻辑
        System.out.println("执行 " + joinPoint.getSignature().toShortString() + " 方法前");
    }

    @After("servicePointcut()")
    public void after(JoinPoint joinPoint) {
        // 执行后置增强逻辑
        System.out.println("执行 " + joinPoint.getSignature().toShortString() + " 方法后");
    }

    @Around("servicePointcut()")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        // 执行环绕增强逻辑
        System.out.println("开始执行 " + proceedingJoinPoint.getSignature().toShortString() + " 方法");
        Object result = proceedingJoinPoint.proceed();
        System.out.println("结束执行 " + proceedingJoinPoint.getSignature().toShortString() + " 方法，返回值：" + result);
        return result;
    }

}

3. 启用 AOP

在 Spring Boot 应用程序中，我们可以通过在主类中添加 @EnableAspectJAutoProxy 注解来启用 AOP：

@SpringBootApplication
@EnableAspectJAutoProxy
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

测试案例

假设我们有一个 UserService 接口和一个对应的 UserServiceImpl 实现类：

public interface UserService {

    void addUser(String username, String password);

    void deleteUser(String username);

    void updateUser(String username, String password);

}

@Service
public class UserServiceImpl implements UserService {

    @Override
    public void addUser(String username, String password) {
        // 添加用户的具体实现
    }

    @Override
    public void deleteUser(String username) {
        // 删除用户的具体实现
    }

    @Override
    public void updateUser(String username, String password) {
        // 更新用户的具体实现
    }

}

然后，我们在 UserServiceImpl 中添加 @Log 注解，表示需要对该类的所有方法进行增强：

@Service
@Log
public class UserServiceImpl implements UserService {

    @Override
    public void addUser(String username, String password) {
        // 添加用户的具体实现
    }

    @Override
    public void deleteUser(String username) {
        // 删除用户的具体实现
    }

    @Override
    public void updateUser(String username, String password) {
        // 更新用户的具体实现
    }

}

最后，我们可以编写一个测试类，测试增强后的方法是否按照预期执行：

@SpringBootTest
class DemoApplicationTests {

    @Autowired
    private UserService userService;

    @Test
    void testAddUser() {
        userService.addUser("testuser", "testpass");
    }

    @Test
    void testDeleteUser() {
        userService.deleteUser("testuser");
    }

    @Test
    void testUpdateUser() {
        userService.updateUser("testuser", "newpass");
    }

}