Spring AOP 应用场景与源码解析

已于 2024-08-28 19:35:04 修改
阅读量1.2k 收藏 23
点赞数 33
文章标签： spring java
于 2024-08-28 19:32:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51052174/article/details/141647406
版权

一、AOP 概述

AOP（Aspect Oriented Programming，面向切面编程）是一种编程范式，旨在将横切关注点（如日志、事务、安全等）从核心业务逻辑中分离出来，从而提高代码的模块化和可维护性。在 Spring 框架中，AOP 提供了强大的功能，使得开发者能够在不修改业务逻辑代码的情况下，轻松添加额外的功能。

1. AOP 的核心概念

  • 切面（Aspect）：切面是一个关注点的模块化，可以定义横切关注点的行为。
  • 连接点（Join Point）：在程序执行过程中能够插入切面的点，通常是方法的调用。
  • 切入点（Pointcut）：切入点是用于定义哪些连接点会被切面所影响的表达式。
  • 通知（Advice）：通知是切面在特定连接点上执行的动作，包括前置通知、后置通知、异常通知等。
  • 目标对象（Target Object）：被切面增强的对象。
  • 代理（Proxy）：切面通过代理模式实现，代理对象是目标对象的增强版本。

二、AOP 实际应用场景

1. 日志记录

在电商系统中，用户进行注册、下单、支付等操作时，需要记录这些操作的日志。手动在每个方法中添加日志代码会导致代码冗余，且不易维护。使用 AOP，可以在方法执行前后自动记录日志，而无需在每个方法中重复代码。

示例：日志记录切面
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 日志切面，负责记录方法的调用日志
 */
@Aspect // 声明这是一个切面
@Component // 将该类注册为 Spring 组件
public class LoggingAspect {

    private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

    // 切入点：匹配所有 service 包下的所有方法
    @Before("execution(* com.example.service.*.*(..))") // 切点表达式：在匹配的连接点前执行
    public void logMethodAccess(JoinPoint joinPoint) {
        logger.info("进入方法: {}", joinPoint.getSignature().getName()); // 前置通知
    }

    @After("execution(* com.example.service.*.*(..))") // 切点表达式：在匹配的连接点后执行
    public void logMethodExit(JoinPoint joinPoint) {
        logger.info("退出方法: {}", joinPoint.getSignature().getName()); // 后置通知
    }
}

2. 事务管理案例

在电商系统中，用户下单的过程涉及多个步骤，如扣款、库存减免等。这些操作需要在一个事务中完成，以确保数据的一致性。如果某个步骤失败，所有操作都应回滚。通过 AOP，我们可以在方法执行前开启事务，执行成功后提交，如果发生异常则回滚。

示例：事务切面
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.springframework.stereotype.Component;

/**
 * 事务切面，负责管理事务的开始、提交和回滚
 */
@Aspect // 声明这是一个切面
@Component // 将该类注册为 Spring 组件
public class TransactionAspect {

    @Before("@annotation(org.springframework.transaction.annotation.Transactional)") // 切点表达式：在标记为 @Transactional 的方法前执行
    public void startTransaction() {
        // 开始事务逻辑
        System.out.println("事务开始"); // 前置通知
    }

    @AfterReturning("@annotation(org.springframework.transaction.annotation.Transactional)") // 切点表达式：在标记为 @Transactional 的方法成功返回后执行
    public void commitTransaction() {
        // 提交事务逻辑
        System.out.println("事务提交"); // 后置通知
    }

    @AfterThrowing("@annotation(org.springframework.transaction.annotation.Transactional)") // 切点表达式：在标记为 @Transactional 的方法抛出异常后执行
    public void rollbackTransaction() {
        // 回滚事务逻辑
        System.out.println("事务回滚"); // 异常通知
    }
}

三、完整事务应用示例

1. 创建 Service

以下是完整的 OrderService 类代码，包含用户下单、异常处理和事务管理的逻辑。（用于测试练习的）

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.List;

/**
 * 订单服务类，负责订单的业务逻辑
 */
@Service // 将该类注册为 Spring 组件
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate; // 注入 JdbcTemplate 以执行数据库操作

    /**
     * 创建订单
     * @param userId 用户ID
     * @param productId 产品ID
     * @param quantity 数量
     */
    @Transactional // 标记为事务性方法，启用事务管理
    public void createOrder(int userId, int productId, int quantity) {
        // 1. 检查库存是否充足
        int stock = jdbcTemplate.queryForObject("SELECT stock FROM products WHERE id = ?", new Object[]{productId}, Integer.class);
        if (stock < quantity) {
            throw new RuntimeException("库存不足"); // 抛出异常，触发事务回滚
        }

        // 2. 减少库存
        jdbcTemplate.update("UPDATE products SET stock = stock - ? WHERE id = ?", quantity, productId);
        System.out.println("减少产品库存，产品ID: " + productId + ", 数量: " + quantity);

        // 3. 创建订单记录
        jdbcTemplate.update("INSERT INTO orders (user_id, product_id, quantity) VALUES (?, ?, ?)", userId, productId, quantity);
        System.out.println("创建订单，用户ID: " + userId + ", 产品ID: " + productId + ", 数量: " + quantity);

        // 这里可以模拟抛出异常以测试事务回滚
        if (productId == -1) {
            throw new RuntimeException("模拟异常，触发事务回滚"); // 模拟异常
        }
    }

    // 获取所有订单
    public List<Order> getAllOrders() {
        return jdbcTemplate.query("SELECT * FROM orders", (rs, rowNum) -> new Order(rs.getInt("id"), rs.getInt("user_id"), rs.getInt("product_id"), rs.getInt("quantity")));
    }
}

2. 数据库模型

确保在数据库中有对应的表结构，如下所示：

CREATE TABLE products (
    id INT PRIMARY KEY,
    name VARCHAR(255),
    stock INT
);

CREATE TABLE orders (
    id INT PRIMARY KEY AUTO_INCREMENT,
    user_id INT,
    product_id INT,
    quantity INT,
    FOREIGN KEY (product_id) REFERENCES products(id)
);

3. 配置 Spring Boot 应用

在 application.properties 中配置数据库和事务管理。

properties

spring.datasource.url=jdbc:mysql://localhost:3306/ecommerce
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
spring.main.allow-bean-definition-overriding=true
logging.level.root=INFO

4. 主程序

编写主程序来测试 AOP 和 OrderService。

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

/**
 * Spring Boot 主应用程序
 */
@SpringBootApplication
public class AopDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(AopDemoApplication.class, args); // 启动 Spring Boot 应用
    }

    /**
     * CommandLineRunner：应用启动后执行的逻辑
     */
    @Bean
    public CommandLineRunner run(OrderService orderService) {
        return args -> {
            try {
                // 创建订单
                orderService.createOrder(1, 1, 2); // 正常订单
                orderService.createOrder(1, -1, 1); // 测试异常，触发回滚
            } catch (RuntimeException e) {
                System.out.println("捕获到异常: " + e.getMessage());
            }

            // 打印所有订单
            System.out.println("当前订单列表: " + orderService.getAllOrders());
        };
    }
}

5. 运行结果

当运行应用时，控制台会输出日志信息，显示方法的进入和退出，以及事务的处理情况。

进入方法: createOrder
事务开始
减少产品库存，产品ID: 1, 数量: 2
创建订单，用户ID: 1, 产品ID: 1, 数量: 2
退出方法: createOrder
事务提交
进入方法: createOrder
事务开始
捕获到异常: 模拟异常，触发事务回滚
退出方法: createOrder
事务回滚
当前订单列表: []

在这个示例中，我们通过 AOP 的切面逻辑成功切入了事务和日志的管理，确保在执行 createOrder 方法时能够看到“事务开始”和“事务提交”或“事务回滚”的输出。通过这种方式，可以有效地管理事务并记录日志，而无需在业务逻辑中插入大量的事务管理代码。

四、深入源码解析

一、引言

在现代软件开发中，面向切面编程（AOP） 是一种重要的编程范式，它允许将横切关注点（如日志、事务管理等）与业务逻辑分离，从而提高代码的可维护性和可读性。Spring AOP 是 Spring 框架中实现 AOP 的一部分，本文将通过生活情景、代码示例和详细注释来深入解析 Spring AOP 的实现原理、代理生成和配置方式。

二、生活情景引入

你在一家餐厅用餐。你点了一道菜，服务员（代理）会将你的订单传递给厨房（目标类），然后再将菜肴送到你的桌子上。服务员在这个过程中可能会在你点菜前问你是否需要饮料（前置通知），在上菜后询问味道如何（后置通知），如果你不满意，服务员会记录下你的反馈（异常通知）。

三、Spring AOP 的实现原理

Spring AOP 是基于代理模式实现的，主要有两种代理方式：

  • JDK 动态代理：适用于实现了接口的类。
  • CGLIB 代理：适用于没有实现接口的类。

1. JDK 动态代理

JDK 动态代理是通过 java.lang.reflect.Proxy 类实现的。它需要目标类实现一个或多个接口，并在运行时生成一个代理类。代理类会实现目标类的所有接口，并将方法调用转发到 InvocationHandler 接口的实现类。

示例代码：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义一个用户服务接口
public interface UserService {
    void addUser(String username); // 添加用户方法
}

// 目标类实现接口
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("用户 " + username + " 被添加。"); // 业务逻辑
    }
}

// 代理处理器
public class MyInvocationHandler implements InvocationHandler {
    private Object target; // 目标对象

    public MyInvocationHandler(Object target) {
        this.target = target; // 初始化目标对象
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法调用前"); // 前置通知
        Object result = method.invoke(target, args); // 调用目标方法
        System.out.println("方法调用后"); // 后置通知
        return result; // 返回结果
    }
}

// 使用 JDK 动态代理
public class JDKProxyDemo {
    public static void main(String[] args) {
        UserService userService = new UserServiceImpl(); // 创建目标对象
        // 创建代理实例
        UserService proxyInstance = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(), // 类加载器
                userService.getClass().getInterfaces(), // 接口
                new MyInvocationHandler(userService)); // 代理处理器

        proxyInstance.addUser("Alice"); // 调用代理方法
    }
}

输出结果：

方法调用前
用户 Alice 被添加。
方法调用后

2. CGLIB 代理

CGLIB 代理是通过生成目标类的子类来实现的。它不要求目标类实现接口，因此可以对没有实现接口的类进行代理。CGLIB 通过字节码技术动态生成一个继承目标类的代理类。

示例代码：
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

// 目标类
public class UserService {
    public void addUser(String username) {
        System.out.println("用户 " + username + " 被添加。"); // 业务逻辑
    }
}

// 代理处理器
public class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("方法调用前"); // 前置通知
        Object result = proxy.invokeSuper(obj, args); // 调用目标方法
        System.out.println("方法调用后"); // 后置通知
        return result; // 返回结果
    }
}

// 使用 CGLIB 代理
public class CGLIBProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer(); // 创建 Enhancer 对象
        enhancer.setSuperclass(UserService.class); // 设置目标类
        enhancer.setCallback(new MyMethodInterceptor()); // 设置代理处理器

        UserService proxyInstance = (UserService) enhancer.create(); // 创建代理实例
        proxyInstance.addUser("Bob"); // 调用代理方法
    }
}

输出结果：

方法调用前
用户 Bob 被添加。
方法调用后

四、代理的生成

在 Spring 中，AOP 的核心是通过代理来实现的。在创建代理时，Spring 会根据目标类是否实现接口来选择使用 JDK 动态代理还是 CGLIB 代理。

生活场景比喻

餐厅有两种服务模式——点菜单（JDK 动态代理）和自助餐（CGLIB 代理）。在自助餐中，顾客可以直接选择食物，而不需要依赖服务员的帮助。

五、Spring AOP 的配置

在 Spring 中，AOP 的配置主要通过 @EnableAspectJAutoProxy 注解开启。这个注解会启用 Spring 的基于注解的 AOP 功能，允许使用 @Aspect 注解定义切面。

1. 配置类示例

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * Spring 配置类
 */
@Configuration
@EnableAspectJAutoProxy // 启用 AspectJ 自动代理
public class AppConfig {

    @Bean
    public OrderService orderService() {
        return new OrderService(); // 创建 OrderService 实例
    }

    @Bean
    public TransactionAspect transactionAspect() {
        return new TransactionAspect(); // 创建 TransactionAspect 实例
    }

    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect(); // 创建 LoggingAspect 实例
    }
}

2. 注解说明

  • @Configuration：标记该类为 Spring 配置类，表示它可以提供 Bean 定义。
  • @EnableAspectJAutoProxy：启用 Spring AOP 的自动代理支持。Spring 会扫描带有 @Aspect 注解的类，并为其创建代理。

六、AOP 的工作流程

  1. 定义切面：使用 @Aspect 定义切面类，并在类中定义切点和通知。
  2. 配置 Spring：使用 @EnableAspectJAutoProxy 注解启用 AOP 功能。
  3. 创建代理：Spring 根据目标类是否实现接口决定使用 JDK 动态代理或 CGLIB 代理。
  4. 执行通知：在方法调用时，代理会根据定义的切点和通知，在适当的连接点执行相应的通知逻辑。

生活场景比喻

餐厅的服务员在接待顾客时，会根据顾客的需求（切点）提供相应的服务（通知），如问饮料、上菜等。

七、运行时的代理逻辑

在运行时，Spring 会根据配置生成代理对象。每当调用目标方法时，代理会先执行前置通知（如果存在），然后调用目标方法，最后执行后置通知（如果存在）。如果目标方法抛出异常，代理会执行异常通知（如果定义了）。

生活场景比喻

在餐厅点餐时，服务员会先确认你的订单（前置通知），然后把食物送到桌上（目标方法），最后询问你对菜品的满意度（后置通知或异常通知）。

八、总结

通过对 Spring AOP 的深入解析和生活场景的结合，我们可以更好地理解其实现原理、代理生成机制和配置方式。AOP 作为一种编程范式，通过代理模式将横切关注点（如日志、事务等）与业务逻辑分离，提高了代码的可维护性和可读性。在实际开发中，合理运用 AOP 能够显著提升开发效率和代码质量。通过以上的示例和情景比喻，相信您能更好地掌握 Spring AOP 的应用和实现。

九、相关问题

1. 什么是 AOP？它与 OOP 有什么区别？

 AOP（面向切面编程）是一种编程范式，旨在将横切关注点（如日志、事务等）从业务逻辑中分离出来，以提高代码的模块化和可维护性。而 OOP（面向对象编程）则是通过对象和类来组织代码，强调的是对象的封装、继承和多态。AOP 更关注横切关注点的处理，而 OOP 更关注对象之间的关系和行为。

2. 解释什么是切点和通知？

  • 切点（Pointcut）：切点是一个表达式，用于定义哪些连接点（方法调用、对象创建等）会被切面所影响。
  • 通知（Advice）：通知是切面在特定连接点上执行的动作，可以分为前置通知（方法执行前）、后置通知（方法执行后）、异常通知（方法抛出异常后）等。

3. Spring AOP 采用的代理模式是什么？

 Spring AOP 主要采用两种代理模式：

  • JDK 动态代理：适用于实现了接口的类，使用 Java 的反射机制创建代理类。
  • CGLIB 代理：适用于没有实现接口的类，通过继承目标类来创建代理类。

4. 如何实现事务管理？事务的传播行为是什么？

 在 Spring 中，可以通过 @Transactional 注解来实现事务管理。事务的传播行为定义了一个事务方法被调用时，事务的创建、挂起、恢复等行为。常见的传播行为有：

  • REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务，则新建一个事务。
  • REQUIRES_NEW：总是新建一个事务，如果存在当前事务，先将其挂起。
  • NESTED：如果存在一个事务，则在其内部嵌套一个事务。

5. AOP 的应用场景有哪些？

 AOP 的应用场景包括但不限于：

  • 日志记录：自动记录方法的调用和返回。
  • 事务管理：确保一组操作的原子性和一致性。
  • 安全控制：在方法执行前进行权限验证。
  • 性能监控：记录方法的执行时间，进行性能分析。
拾柒mm
关注
SpringAOP切面实例讲解及应用场景（通俗易懂）
12-21
AOP切面的实践 下面是一个在spring mvc中关于切面如何使用的例子，可以指直观的理解切面到底有什么作用 1、引用 AspectJ jar 包依赖 pom.xml 文件添加依赖 org.aspectj aspectjrt 1.9.2 2、创建两个新的包 com.hbxy.course.c03 test.com.hbxy.course.c03 3、创建一个业务类 UserXML package com.hbxy.course.c03; public class UserXML { private int id= 20190101; private String name
SpringAOP 常见应用场景
最新发布
Zyw907155124的博客
06-08 2963
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
spring aop 应用场景
樊城城的博客
07-05 505
比如在对每个表结构或者数据对象进行save update 操作时 需要生成创建者 创建时间 修改者 修改时间 ，如果自己手写，工作量比较大，这时就需要aop Authentication 权限 Caching 缓存 Context passing 内容传递 Error handling 错误处理 Lazy loading 懒加载 Debugging
Spring AOP的应用场景
yangyanping20108的博客
04-13 351
Spring AOP @Aspect 定义计算服务类 package com.spring.study.aop.service; public class CalculatorService { public int div(int a, int b) { return a / b; } } 定义LogAspect拦截类 package com.spring.s...
Spring AOP 应用场景
My_wife_QBL的博客
09-04 189
当我们谈论Spring AOP时，我们通常会关注其基本概念，如切面（Aspect）、连接点（Join Point）和处理逻辑（Advice）。然而，这只是冰山一角。在本文中，我们将探讨Spring AOP的其他重要应用场景，包括其他类型的切面、通知和增强。当我们谈论Spring AOP时，我们通常会关注其基本概念，如切面（Aspect）、连接点（Join Point）和处理逻辑（Advice）。在本文中，我们将探讨Spring AOP的其他重要应用场景，包括其他类型的切面、通知和增强。
Spring Aop 引用新功能 源码
05-01
**源码解析** 在`AopIntroduction`这个文件中，我们可以看到如何定义和实现引入的示例。首先，定义一个新的接口，比如`SecuredInterface`，然后创建一个实现`IntroductionInterceptor`的类，如`SecurityInterceptor...
Spring AOP源码解读
桐花思雨
01-23 4388
aop 是什么 AOP (Aspect-Oriented Programming，面向切面编程)，可以说是 OOP 的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP 则显得无能为力。OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布
Spring AOP源码深度解析：掌握Java高级编程核心技术
12-13
Spring AOP（面向切面编程）是Spring框架中的核心组件，它通过代理模式实现了对程序逻辑的非侵入式增强，使得...同时，Spring AOP的灵活性使其能够在不同的应用场景中发挥作用，是Java高级编程中不可或缺的一部分。
一文搞懂Spring AOP源码底层原理
程序媛小琬的博客
05-05 1222
一、什么是AOP 与OOP对比，AOP是处理一些横切性问题，这些横切性问题不会影响到主逻辑实现的，但是会散落到代码的各个部分，难以维护。一键获取源码地址spring aop面试题 AOP就是把这些问题和主业务逻辑分开，达到与主业务逻辑解耦的目的。 二、 AOP的应用场景 · 日志记录 · 权限验证 · 效率检查 · 事务管理 三、Spring AOP原理及其应用 3.1 AOP相关概念 · Aspect(切面): 通常是一个类(交给Spring容器管理)，里面可以定义切入点和通知 · JointPoin
【微服务】Spring Aop原理深入解析
热门推荐
congge
12-17 1万+
spring原理深度解析
spring aop应用场景
heyeweiwan的专栏
08-07 1658
1.事务处理:
Spring AOP 一般应用场景
qq513165077的博客
10-19 1879
主要用来事务控制，比如运行日志，性能检测权限控制等，除此以为，aop在模块的耦合，及管理，功能升级方面多有很好的用途。 AOP是Aspect Oriented Programing的简称，面向切面编程。AOP适合于那些具有横切逻辑的应用：如性能监测，访问控制，事务管理、缓存、对象池管理以及日志记录。AOP将这些分散在各个业务逻辑中的代码通过横向切割的方式抽取到一个独立的模块中。AOP 实现的关键
Spring AOP在项目中的典型应用场景
江南一点雨的专栏
12-08 6490
学过 Spring 的小伙伴相信都知道 AOP，AOP 学的好的小伙伴相信对 AOP 的概念也是轻车熟路：面向切面编程、切点、切面、通知，Aspect、Pointcut、Advice 等如数家珍。AOP 之所以这么重要，是因为它在项目中有着非常广泛的应用，今天这篇文章，松哥就来和大家总结一下，我们在日常开发中，都有哪些典型场景需要用到 AOP。先来一句话总结下，AOP 的使用，基本上都会涉及到自定义注解，一个非常常见的组合，就是自定义注解+AOP。
Spring AOP的使用场景
Godlike_M的博客
07-31 1806
@TOC 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增
Spring中AOP使用场景
qq_25073223的博客
10-29 608
Spring中AOP使用场景简介说明
Spring AOP经典应用场景
doxopcsdn的博客
06-25 286
因为 AOP 可以拦截到切入点方法，Spring 也支持通过注解的方式来定义切点表达式，所以可以通过 AOP 来实现自定义注解的功能。例如，自定义一个注解来实现声明式缓存，把方法的返回值进行缓存。/*** 缓的Key*//*** 缓存过期时间*//*** 缓存过期时间单位（默认：毫秒）*/然后定义一个切片来实现常规的缓存操作，先读缓存，缓存不存在时执行方法，然后把方法的返回结果进行缓存。@Aspect@Component// 自定义缓存逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值