SpringBoot使用AOP控制接口访问次数以及接口幂等性

已于 2023-07-05 17:23:16 修改
阅读量986 收藏 10
点赞数 1
文章标签： spring boot 后端 java redis
于 2023-07-05 17:18:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45850829/article/details/131557230
版权

最近跟朋友聊起接口优化…于是学习总结,记录下来。

本文目录

学习目标

  • 看完这篇将会：
    • 了解AOP
    • 学会使用AOP控制接口访问以及接口幂等性
    • 掌握AOP的使用场景

AOP

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它允许将横切关注点（cross-cutting concerns）从核心业务逻辑中分离出来。通过AOP，可以将这些关注点模块化，并将它们应用到多个不同的组件和对象上，从而提高代码的可重用性和可维护性。在AOP中，关注点可以被定义为切面（aspect），切面是一组跨越不同类、不同层次的关注点。通常，一个切面由切（pointcut）和通知（advice）组成。

 1. 切点：切点定义了在应用程序执行过程中哪些地方应该插入横切关注点。切点通常使用表达式来指定目标方法的选择。
 2. 通知：通知定义了在切点处执行的逻辑。在AOP中，存在以下几种类型的通知：
 3. 前置通知（Before Advice）：在目标方法执行前执行的逻辑。
 4. 后置通知（After Advice）：在目标方法执行后执行的逻辑，无论方法是正常返回还是抛出异常。
 5. 返回通知（After Returning Advice）：在目标方法正常返回后执行的逻辑。
 6. 异常通知（After Throwing Advice）：在目标方法抛出异常后执行的逻辑。
 7. 环绕通知（Around Advice）：在目标方法执行前后都可以执行的逻辑。

AOP常用使用场景

 8. 日志记录：通过在关键方法或操作的前后插入日志记录的切面，可以方便地记录系统的运行情况、用户的操作行为以及异常信息等。这对于调试、错误追踪和性能分析非常有帮助。
 9. 安全控制：通过在敏感操作（如认证、权限校验）的前后插入安全控制的切面，可以实现统一的安全策略和权限控制，避免在每个方法中都进行权限验证。
 10. 事务管理：通过在业务层方法的前后插入事务管理的切面，可以实现对数据库操作的自动事务管理。在方法执行前开启事务，在方法执行后根据执行结果提交或回滚事务，从而简化事务管理的代码，并保证数据的一致性。
 11. 性能监控：通过在关键方法或操作的前后插入性能监控的切面，可以实时监控系统的性能指标，例如方法的执行时间、资源消耗等，从而找出性能瓶颈并进行优化。
 12. 异常处理：通过在方法抛出异常时插入异常处理的切面，可以实现统一的异常处理逻辑。例如，可以记录异常日志、发送告警通知或返回给用户友好的错误信息。
 13. 缓存管理：通过在方法执行前后插入缓存管理的切面，可以实现对方法返回结果的缓存。这样可以减少对底层资源的访问，提高系统的响应速度和性能。
 14. 数据校验和转换：通过在参数校验、数据转换等操作的前后插入数据校验和数据转换的切面，可以实现统一的数据处理逻辑。例如，可以在保存数据之前进行数据的合法性验证或将不同数据格式进行转换。

开发准备

  1. Java 基础开发
  2. Maven 基本使用
  3. redis 基础使用
  4. 开发依赖版本
    JDK 1.8.0 Maven 3.9.2

此项目中集成了redis，如果没有安装redis。可以自己去搜索安装教程。

项目配置

  1. pom.xml
    因为项目中用到了AOP、Redis...所以引入对应的依赖文件
			<!-- Spring Data Redis -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>

            <!-- Redis 连接池 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
            </dependency>

            <!-- Spring AOP -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
  1. application.yml
########### 项目端口号设置 ##################
server:
  port: 8080
########### Redis配置 ##################
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:

如果redis设置了密码，在password后面加上密码即可

访问接口限制

  1. 首先自定义一个注解(RateLimit)
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface RateLimit {
}
  1. 创建一个AOP类
    如果需要对整个controller下的API都做限制，可以使用execution表达式
@SuppressWarnings("all")
@Slf4j
@Aspect
@Component
public class RateLimitAspect {
	
	//定义 Redis Key 的前缀
    private static final String KEY_PREFIX = "requestCount:";

    @Autowired
    private RedisTemplate redisTemplate;

    //定义环绕通知
    //将@annotation括号里的值换成自定义注释的所在路径
    @Around("@annotation(com.example.annotate.RateLimit)")
    public Object limitAccessCount(ProceedingJoinPoint joinPoint) throws Throwable {
        //获取接口方法名称
        String methodName = joinPoint.getSignature().toShortString();
        /**
         * 设置 redis 的 key
         * RedisKey = Key前缀 + IP地址 + 接口名 
         */
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        //获取访问该方法用户对应的 ip 地址，在此作为唯一值
        String ip = request.getRemoteAddr();
        //拼接RedisKey
        String redisKey = KEY_PREFIX + ip + methodName;
        //每次访问都会 +1 ，直到 > 10，即一分钟内最多访问同一个接口10次
        Long requestCount = redisTemplate.opsForValue().increment(redisKey, 1);
        if (requestCount == 1) {
            //设置过期时间为一分钟
            redisTemplate.expire(redisKey, 1, TimeUnit.MINUTES);
        }
        //如果超过 10 次，会提示限制访问
        if ((requestCount != null && requestCount > 10)){
            log.error("ip为：" + ip + "的用户访问" + methodName + "接口次数超过限制");
            //如果在限制期间再次访问该接口，会重置过期时间
            redisTemplate.expire(redisKey, 1, TimeUnit.MINUTES);
            return new Result(503, "系统繁忙，请稍后重试");
        }
        //如果条件不成立，将继续执行 controller 层的方法
        return joinPoint.proceed();
    }

}
  1. 在需要做接口限制的API上添加@RateLimit注释即可
  2. 效果展示
    超出接口访问次数效果展示
  3. 使用目的
    通过限制接口的访问次数，可以避免系统因为过多的请求而过载。首先某些接口可能会暴露敏感数据或具有特殊功能，限制访问次数可以减少滥用或恶意攻击的风险。其次某些接口可能会占用较多的系统资源，如数据库查询、文件操作等。通过限制接口的访问次数，可以控制对这些资源的消耗，确保系统能够合理分配资源，并提供良好的服务质量。

接口幂等性

  1. 自定义注解(Idempotent)
/**
 * 接口幂等性注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Idempotent {
}
  1. 创建一个AOP类
    如果需要对整个controller下的API都做限制，可以使用execution表达式
@Slf4j
@SuppressWarnings("all")
@Component
@Aspect
public class RequestIdempotentAspect {

    //保存每次请求的id
    private Set<String> requestIdsAndTokens = new HashSet<String>();

    Logger logger = LoggerFactory.getLogger(RequestIdempotentAspect.class);

    /**
     * Before 执行方法前， 检查 set 中是否存在 key
     *
     * @param joinPoint
     */
    @Before("@annotation(com.example.springboot_aes.annotate.Idempotent)")
    public void checkIdempotent(JoinPoint joinPoint) {
        //获取 HttpServletRequest 对象, 利用 HttpServletRequest 获得请求头部参数
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        //获取 header 的参数
        String requestId = request.getHeader("X-Request-ID");
        String token = request.getHeader("Cookie");
        //拼接 set 的 key
        String idempotentKey = createIdempotentKey(requestId, token);
        //判断当前 key 是否存在与 set 中，如果存在，报一个 RuntimeException 异常
        if (requestIdsAndTokens.contains(idempotentKey)) {
            throw new RuntimeException("该请求正在处理中，请勿多次点击");
        }
        //如果当前 key 不存在于 set 中，将此 key 保存到 set 中
        requestIdsAndTokens.add(idempotentKey);
    }

    /**
     * After 执行完方法后，删除 set 中。此 key
     *
     * @param joinPoint
     */
    @After("@annotation(com.example.springboot_aes.annotate.Idempotent)")
    public void clearIdempotent(JoinPoint joinPoint) {
        //获取 HttpServletRequest 对象, 利用 HttpServletRequest 获得请求头部参数
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        //获取 header 的参数
        String requestId = request.getHeader("X-Request-ID");
        String token = request.getHeader("Cookie");
        //拼接 set 的 key
        String idempotentKey = createIdempotentKey(requestId, token);
        //任务执行结束之后，删除 set 中对应的的key
        requestIdsAndTokens.remove(idempotentKey);
    }

    /**
     * 将请求ID和令牌组合成键
     * @param requestId
     * @param token
     * @return String
     */
    private String createIdempotentKey(String requestId, String token) {
        return requestId + "-" + token;
    }
  1. 在需要做接口限制的API上添加@Idempotent注释即可
  2. 效果展示
    接口幂等性效果展示
  3. 使用目的
    接口幂等性就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。举个最简单的例子，那就是支付，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额返发现多扣钱了，流水记录也变成了两条．．．这就没有保证接口的幂等性

其他场景

这里举个小例子，如日志记录…

@Aspect
@Component
public class AopLog {

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    //使用环绕通知
    @Around("execution(* com.example.controller.*.*(..))")
    public Object myLogger(ProceedingJoinPoint pjp) throws Throwable {
        //获取当前时间
        long startTime = System.currentTimeMillis();
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String className = pjp.getSignature().getDeclaringTypeName();
        String methodName = pjp.getSignature().getName();

        //使用数组来获取参数
        Object[] array = pjp.getArgs();
        ObjectMapper mapper = new ObjectMapper();
        //执行函数前打印日志
        logger.info("当前用户id为：" + StpUtil.getLoginIdDefaultNull());
        logger.info("调用前：{}：{},传递的参数为：{}", className, methodName, mapper.writeValueAsString(array));
        logger.info("URL:{}", request.getRequestURL().toString());
        logger.info("IP地址：{}", request.getRemoteAddr());
        //调用整个目标函数执行
        Object obj = pjp.proceed();
        //执行函数后打印日志
        logger.info("调用后：{}：{},返回值为：{}", className, methodName, mapper.writeValueAsString(obj));
        logger.info("耗时：{}ms", System.currentTimeMillis() - startTime);
        // 此处写存库逻辑...
        return obj;
    }
}

尾声

相信看过这篇文章的应该可以理解到以下两点…
AOP的作用及其优势

  • 作用：在程序运行期间，在不修改源码的基础上对方法进行功能增强。
  • 优势：减少重复代码，提高开发效率，并且便于维护。

如果对接口优化感兴趣的可以去网上学习，我这里给大家提供几个常用方案。。。

  1. 批处理
  2. 异步处理
  3. 空间换时间
  4. 预处理
  5. 池化思想
  6. 串行改并行
  7. 索引
  8. sql优化

好了，就先写到这里，如果有需要源码的可以在评论区评论。我会上传到git上供大家学习。

Jx_G1nger
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
SpringBoot 接口访问频率限制(流量控制)
m0_52440148的博客
09-01 2201
可以通过注解快速实现类似10分钟内仅可以搜索3次，以及N分钟尝试登陆多次即被禁止一小时等类似功能。
Springboot通过IP约束用户对接口的访问频次
qq_40266420的博客
05-17 495
既然要通过IP约束用户对接口的访问频次，我们需要首先存储用户用户的IP信息，这里采用ThreadLocal用来存储用户的IP信息，对每个用户的IP获取这里通过定义一个拦截器来采集用户的IP信息。这里值得注意的是如何解决访问频次的问题，在单机的情况下好解决定义一个容器即可，在分布式的情况下每一个服务器是相互隔离的，这里采用redis来解决多机器下的接口约束。与全局的接口约束方法一致，通过定义一个切面实现相关的业务代码，约束每60秒每个IP对接口不能超过5次的访问。
spring boot--使用异步请求，提高系统的吞吐量
zalan01408980的博客
02-21 345
前言： 在我们的实际生产中，常常会遇到下面的这种情况，某个请求非常耗时(大约5s返回)，当大量的访问该请求的时候，再请求其他服务时，会造成没有连接使用的情况，造成这种现象的主要原因是，我们的容器(tomcat)中线程的数量是一定的，例如500个，当这500个线程都用来请求服务的时候，再有请求进来，就没有多余的连接可用了，只能拒绝连接。要是我们在请求耗时服务的时候，能够异步请求(请求到controller中时，则容器线程直接返回，然后使用系统内部的线程来执行耗时的服务，等到服务有返回的时候，再将请求返回给客
springboot接口限制访问次数
qq_37342720的博客
02-17 3782
对接口访问次数的限制 是从java版web项目公众号中看到 于是百度结合自己现有项目写了一下 首先需要定义一个注解 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * @Auther: lirui * @Date: 2
SpringBoot 接口访问频率限制(二)
qq_40694890的博客
03-25 2212
Spring注解实现频率控制
API 调用次数限制实现
07-03
我们在开发接口服务器的过程中，为了防止客户端对于接口的滥用，保护服务器的资源， 通常来说我们会对于服务器上的各种接口进行调用次数的限制。
SpringBoot中使用AOP打印接口日志的方法
08-27
SpringBoot中使用AOP打印接口日志的方法 SpringBoot中使用AOP打印接口日志的方法是指通过Aspect Oriented Programming（面向切面编程）在SpringBoot框架中实现打印接口日志的功能。本篇文章将详细介绍AOP的概念、...
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用人员误操作...
Springboot接口项目如何使用AOP记录日志
08-19
Springboot 接口项目如何使用 AOP 记录日志 在软件开发中，日志记录是一项非常重要的任务，它可以帮助我们追踪程序的执行过程， debug 错误，优化性能等。但是，传统的日志记录方式通常需要在代码中添加大量的日志...
Aop注解+Redis解决SpringBoot接口幂等性(源码自取)
03-08
本教程将通过Spring Boot结合AOP注解与Redis来实现接口幂等性，以确保系统的稳定性和数据的一致性。 首先，我们需要了解Spring Boot和AOP注解。Spring Boot是基于Spring框架的快速开发工具，它简化了配置并提供了开...
springboot如何使用AOP做访问请求日志
08-25
"SpringBoot 中使用 AOP 实现访问请求日志" SpringBoot 中实现访问请求日志是通过 Aspect-Oriented Programming（AOP）的技术来实现的。AOP 的主要思想是将跨越多个类和对象的功能分离出来，形成一个独立的模块，以...
【SpringBoot】Spring Boot 的第一次请求接口过慢可能有多种原因
wjianwei666的专栏
08-28 2332
Spring Boot 应用程序第一次启动时，需要加载许多类、初始化应用程序上下文等等。这个过程可能需要花费一些时间。可以尝试将应用程序打成可执行的 JAR 包，这样启动时间会缩短很多。
SpringBoot 接口访问频率限制(一)
最新发布
qq_40694890的博客
04-01 1804
1. 在本文中，设计并实现了策略模式（Strategy Pattern），从而让程序能够根据需要灵活选择具体的行为实现。 2. 本文还实现了模板方法模式（Template Method Pattern），将一些步骤延迟到子类中实现，使得子类可以在不改变结构的基础上重写部分方法以适应不同的情况。 3. 对于策略模式的优化方面，我们进一步强化了开闭原则（Open-Closed Principle）应用。通过新增策略类的方式，使系统能够在不改动原有代码的前提下增加新的行为策略，从而提升了系统的可维护性和可扩展性。
SpringBoot集成AOP实现每个接口请求参数和返回参数并记录每个接口请求时间
风水道人
12-20 1006
AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架中的一个重要特性，它允许开发者定义跨多个对象的横切关注点。定义Aspect：Aspect是包含一些advice（通知）的类。通知是实际执行的代码，它可以是一个方法或者一个lambda表达式。在Aspect中，你可以定义前置通知（Before）、后置通知（After）、返回通知（AfterReturning）、异常通知（AfterThrowing）等。配置AspectJ自动代理定义Pointcut表达式。
SpringBoot自定义注解@Idempotent实现API幂等性（防止接口重复请求）
qq837993702的博客
02-05 6520
目的 一定时间内，同样的请求（业务参数相同）访问同一个接口，则只能成功一次，其余被拒绝。 自定义幂等性注解 import java.lang.annotation.*; /** * 幂等注解 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Idempotent { /** * 幂等名称，作为redis缓存Key的一部分。 */
如何在SpringBoot项目中使用AOP
jx1254916009的博客
12-11 400
本文主要讲述AOP在Springboot项目中如何使用AOP记录接口访问日志，具体的理论知识这边就不做过多的详解，具体的可以以后在另一篇文章做详细的介绍。 什么是AOP AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 再来回顾下AOP的一些相关术语 通知（Advice） 通知
springboot相同IP限制接口访问次数(AOP事物)
weixin_46063418的博客
04-19 1263
文章转载自：https://blog.csdn.net/befroe_You/article/details/83748927 用于自己学习 应用场景：应项目需求，前后台分离，增强接口安全，限制相同IP访问接口的次数有限 解决：在项目中增加事物，在进接口方法前处理 思路： 1）@Before 在进入接口方法之前进入处理，within里面的书写表示写在控制器上方并且有对应注解的控制器会来到这里。 2）用获取的IP+对应url作为key,存到redis中，如果Redis存在这个key，然后时间处理器在超过设置时
在SpringBoot中使用Spring-AOP实现接口鉴权
qq_42582773的博客
09-27 1633
Spring AOP实现接口鉴权
猫头虎分享：Springboot项目中实现IP白名单限制访问接口的深度探讨
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
02-19 3557
嗨，亲爱的读者们，我是猫头虎博主！🐾 今天，我们要一起探索的是如何在Springboot项目中巧妙地利用IP白名单来限制接口访问。这篇博客将详尽地讨论从搭建到实施的各个步骤，包括实际的测试接口和用例，以及一些额外的接口访问限制方案。无论你是初涉此领域的小白，还是资深的开发大佬，相信你都能从本文中获得有价值的知识和灵感哦！🌟在深入探讨如何在Springboot项目中实现IP白名单之前，让我们先了解一下Springboot框架和IP白名单的基本概念。
springboot 使用aop
12-03
以下是使用SpringBoot AOP的步骤： 1. 首先，在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 2. 创建一个切面类，使用@Aspect注解标记该类，并在该类中定义切点和通知。 ```java @Aspect @Component public class MyAspect { @Pointcut("execution(* com.example.demo.service.*.*(..))") public void pointcut() {} @Before("pointcut()") public void before(JoinPoint joinPoint) { System.out.println("Before method: " + joinPoint.getSignature().getName()); } @After("pointcut()") public void after(JoinPoint joinPoint) { System.out.println("After method: " + joinPoint.getSignature().getName()); } } ``` 3. 在应用程序主类上添加@EnableAspectJAutoProxy注解，启用自动代理。 ```java @SpringBootApplication @EnableAspectJAutoProxy public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } } ``` 4. 在需要使用AOP的类或方法上添加自定义注解，并在切面类中使用@Around注解来拦截该注解。 ```java @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface MyAnnotation {} @Around("@annotation(com.example.demo.aspect.MyAnnotation)") public Object around(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("Before method: " + joinPoint.getSignature().getName()); Object result = joinPoint.proceed(); System.out.println("After method: " + joinPoint.getSignature().getName()); return result; } @Service public class MyService { @MyAnnotation public void doSomething() { System.out.println("Doing something..."); } } ```
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值