广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Springboot使用redis实现接口Api限流的示例代码
  • 709

0
分享到

Springboot使用redis实现接口Api限流的示例代码

2024-04-02 19:04:59 709人浏览 独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

前言 该篇介绍的内容如题，就是利用Redis实现接口的限流（  某时间范围内 最大的访问次数 ） 。 正文  惯例，先看下我们的实战目录结构： 首先

前言

该篇介绍的内容如题，就是利用Redis实现接口的限流（  某时间范围内 最大的访问次数 ） 。

正文 

惯例，先看下我们的实战目录结构：

首先是pom.xml 核心依赖：

 <!--用于redis数据库连接-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--用于redis lettuce 连接池pool使用-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-WEB</artifactId>
        </dependency>

然后是application.yml里面的redis接入配置：

spring:
  redis:
    lettuce:
      pool:
        #连接池最大连接数 使用负值代表无限制 默认为8
        max-active: 10
        #最大空闲连接 默认8
        max-idle: 10
        #最小空闲连接 默认0
        min-idle: 1
    host: 127.0.0.1
    passWord: 123456
    port: 6379
    database: 0
    timeout: 2000ms
server:
  port: 8710

redis的配置类， RedisConfig.java：

import com.fasterxml.jackson.annotation.JSONAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2jsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
import static org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig;
 

@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration cacheConfiguration =
                defaultCacheConfig()
                        .disableCachingNullValues()
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer(Object.class)));
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(cacheConfiguration).build();
    }
 
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //序列化设置 ，这样为了存储操作对象时正常显示的数据，也能正常存储和获取
        redisTemplate.seTKEySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }
 
}

自定义注解：

import java.lang.annotation.*;
 

@Inherited
@Documented
@Target({ElementType.FIELD, ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLimit {
 
    
    int second() default 10;
 
 
 
    
    int maxCount() default 5;
 
 
    //默认效果 ： 10秒内 对于使用该注解的接口，只能总请求访问数 不能大于 5次
 
}

接下来是拦截器 RequestLimitInterceptor.java：

拦截接口的方式 是通过 ip地址+接口url ，做时间内的访问计数

import com.elegant.testdemo.annotation.RequestLimit;
import com.elegant.testdemo.utils.IpUtil;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
 
import javax.servlet.Http.httpservletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
 

 
@Component
public class RequestLimitInterceptor implements HandlerInterceptor {
    private final Logger log = LoggerFactory.getLogger(this.getClass());
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        try {
            if (handler instanceof HandlerMethod) {
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                // 获取RequestLimit注解
                RequestLimit requestLimit = handlerMethod.getMethodAnnotation(RequestLimit.class);
                if (null==requestLimit) {
                    return true;
                }
                //限制的时间范围
                int seconds = requestLimit.second();
                //时间内的 最大次数
                int maxCount = requestLimit.maxCount();
                String ipAddr = IpUtil.getIpAddr(request);
                // 存储key
                String key =  ipAddr+":"+request.getContextPath() + ":" + request.getServletPath();
                // 已经访问的次数
                Integer count = (Integer) redisTemplate.opsForValue().get(key);
                log.info("检测到目前ip对接口={}已经访问的次数", request.getServletPath() , count);
                if (null == count || -1 == count) {
                    redisTemplate.opsForValue().set(key, 1, seconds, TimeUnit.SECONDS);
                    return true;
                }
                if (count < maxCount) {
                    redisTemplate.opsForValue().increment(key);
                    return true;
                }
                log.warn("请求过于频繁请稍后再试");
                returnData(response);
                return false;
            }
            return true;
        } catch (Exception e) {
            log.warn("请求过于频繁请稍后再试");
            e.printStackTrace();
        }
        return true;
    }
 
    public void returnData(HttpServletResponse response) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        ObjectMapper objectMapper = new ObjectMapper();
        //这里传提示语可以改成自己项目的返回数据封装的类
        response.getWriter().println(objectMapper.writeValueAsString("请求过于频繁请稍后再试"));
        return;
    }
 
}

接下来是 拦截器的配置 WebConfig.java:

import com.elegant.testdemo.interceptor.RequestLimitInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorReGIStry;
import org.springframework.web.servlet.config.annotation.WebmvcConfigurer;
 

 
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private RequestLimitInterceptor requestLimitInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(requestLimitInterceptor)
 
                //拦截所有请求路径
                .addPathPatterns("
public class IpUtil {
    public static String getIpAddr(HttpServletRequest request) {
        String ipAddress = null;
        try {
            ipAddress = request.getHeader("x-forwarded-for");
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getHeader("WL-Proxy-Client-IP");
            }
            if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
                ipAddress = request.getRemoteAddr();
                if (ipAddress.equals("127.0.0.1")) {
                    // 根据网卡取本机配置的IP
                    InetAddress inet = null;
                    try {
                        inet = InetAddress.getLocalHost();
                    } catch (UnknownHostException e) {
                        e.printStackTrace();
                    }
                    ipAddress = inet.getHostAddress();
                }
            }
            // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
            if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
                // = 15
                if (ipAddress.indexOf(",") > 0) {
                    ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
                }
            }
        } catch (Exception e) {
            ipAddress="";
        }
        // ipAddress = this.getRequest().getRemoteAddr();
 
        return ipAddress;
    }
}

RedisUtil :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
 
 
@Component
public class RedisUtils {
 
 
    @Autowired
 
    private RedisTemplate redisTemplate;
 
 
    
 
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
 
    }
 
 
 
  
 
    public boolean setWithTime(final String key, Object value,int seconds) {
        boolean result = false;
        try {
 
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value,seconds, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
 
    }
 
 
 
    
 
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
 
    
 
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
 
    
 
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
 
 
    
 
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
 
 
    
 
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
 
 
    
 
    public void hmSet(String key, Object hashKey, Object value) {
 
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
 
        hash.put(key, hashKey, value);
 
    }
 
 
    
 
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
 
    }
 
 
    
 
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }
 
 
    
 
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }
 
 
    
 
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }
 
 
    
 
    public Set<Object> setMembers(String key) {
 
        SetOperations<String, Object> set = redisTemplate.opsForSet();
 
        return set.members(key);
 
    }
 
 
    
 
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }
 
 
    
 
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
 
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
 
        return zset.rangeByScore(key, scoure, scoure1);
 
    }
 
 
    
 
    public Set<Integer> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
 
    
 
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
}

最后写个测试接口

TestController.java

import com.elegant.testdemo.annotation.RequestLimit;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
 

@RestController
public class TestController {
 
    @GetMapping("/test")
    @RequestLimit(maxCount = 3,second = 60)
    public String test() {
        return "你好，如果对你有帮助，请点赞加关注。";
    }

}

这个/test接口的注解，我们设置的是 60秒内 最大访问次数为 3次 （实际应用应该是根据具体接口做相关的次数限制。）

然后使用postman测试一下接口：

前面三次都是请求通过的：

第四次：

 ok，就先到这。

到此这篇关于SpringBoot使用redis实现接口api限流的示例代码的文章就介绍到这了,更多相关Springboot redis接口限流内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Springboot使用redis实现接口Api限流的示例代码

本文链接: https://www.lsjlt.com/news/154134.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • Springboot+Redis实现API接口限流的示例代码
    添加Redis的jar包. <dependency> <groupId>org.springframework.boot</groupId&...
    99+
    2022-11-12
  • Springboot使用redis实现接口Api限流的示例代码
    前言 该篇介绍的内容如题，就是利用redis实现接口的限流（  某时间范围内 最大的访问次数 ） 。 正文  惯例，先看下我们的实战目录结构： 首先...
    99+
    2022-11-13
  • Springboot使用redis实现接口Api限流的实例
    前言 该篇介绍的内容如题，就是利用redis实现接口的限流（  某时间范围内 最大的访问次数 ） 。 正文  惯例，先看下我们的实战目录结构： 首...
    99+
    2022-11-12
  • Springboot使用redis实现接口Api限流的方法
    这篇文章主要介绍“Springboot使用redis实现接口Api限流的方法”，在日常操作中，相信很多人在Springboot使用redis实现接口Api限流的方法问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答...
    99+
    2023-06-20
  • SpringBoot使用自定义注解+AOP+Redis实现接口限流的实例代码
    目录为什么要限流限流背景实现限流1、引入依赖2、自定义限流注解3、限流切面4、写一个简单的接口进行测试5、全局异常拦截6、接口测试为什么要限流 系统在设计的时候，我们会有一个系统的预...
    99+
    2022-11-13
  • 如何使用SpringBoot + Redis实现接口限流
    本篇内容介绍了“如何使用SpringBoot + Redis实现接口限流”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！配...
    99+
    2023-06-30
  • 使用SpringBoot + Redis 实现接口限流的方式
    目录配置限流注解定制 RedisTemplateLua 脚本注解解析接口测试全局异常处理Redis 除了做缓存，还能干很多很多事情：分布式锁、限流、处理请求接口幂等性。。。太多太多了...
    99+
    2022-11-13
  • springboot+redis 实现分布式限流令牌桶的示例代码
    1、前言 网上找了很多redis分布式限流方案，要不就是太大，需要引入第三方jar，而且还无法正常运行，要不就是定时任务定时往key中放入数据，使用的时候调用，严重影响性能，所以着手...
    99+
    2022-11-12
  • SpringBoot结合Redis实现接口幂等性的示例代码
    目录介绍实现过程引入 maven 依赖spring 配置文件写入引入 Redis自定义注解token 的创建和实现拦截器的配置测试用例介绍 幂等性的概念是，任意多次执行所产生的影响都...
    99+
    2022-11-13
  • SpringBoot中使用Redis对接口进行限流的实现
    目录实现的思路 使用 Hash 存储接口的限流配置 使用普通kv，存储api的请求次数 使用SpringBoot实现 RedisKeys ObjectRedisTemplate Re...
    99+
    2022-11-12
  • Vue+Springboot实现接口签名的示例代码
    1、实现思路 接口签名目的是为了，确保请求参数不会被篡改，请求的数据是否已超时，数据是否重复提交等。 接口签名示意图 客户端提交请求时，将以下参数按照约定签名方式进行签名，随后...
    99+
    2022-11-12
  • SpringBoot利用限速器RateLimiter实现单机限流的示例代码
    目录一. 概述二. SpringBootDemo2.1 依赖2.2 application.yml2.3 启动类2.4 定义一个限流注解 RateLimiter.java2.5 代理...
    99+
    2022-11-13
  • Go+Redis实现常见限流算法的示例代码
    目录固定窗口滑动窗口hash实现list实现漏桶算法令牌桶滑动日志总结限流是项目中经常需要使用到的一种工具，一般用于限制用户的请求的频率，也可以避免瞬间流量过大导致系统崩溃，或者稳定消息处理速率。并且有时候我们还需要使用...
    99+
    2023-04-02
    Go Redis实现限流算法 Go Redis限流算法 Go 限流算法
  • SpringBoot实现api加密的示例代码
    目录SpringBoot的API加密对接项目介绍什么是RSA加密加密实战实战准备真刀真枪解密实战实战准备真刀真枪总结项目坑点SpringBoot的API加密对接 在项目中，为了保证数...
    99+
    2022-11-12
  • redis zset实现滑动窗口限流的代码
    目录限流redis zset特性滑动窗口算法java代码实现补充：Redis zSet实现滑动窗口对短信进行防刷限流前言示例代码限流 需求背景：同一用户1分钟内登录失败次数超过3次，...
    99+
    2022-11-13
  • SpringBoot实现接口等幂次校验的示例代码
    目录主流的实现方案如下：第一步：书写redis工具类第二步、书写token工具类第三步：定义注解，使用在方法上，当控制层的方法上被注释时，表示该请求为等幂性请求第四步：拦截器配置。选...
    99+
    2022-11-12
  • SpringBoot实现接口参数加密解密的示例代码
    目录1. 开发加解密 starter1.1 创建项目1.2 加密工具类1.3 响应工具类1.4 定义注解1.5 定义一个 EncryptProperti...
    99+
    2022-11-13
  • node.js实现微信JS-API封装接口的示例代码
    Wechat JS-API接口 功能： 用于管理和获取微信 JSSDK 生产的access_token、jsapi_ticket和签名（signature） Installation npm i we...
    99+
    2022-06-04
    示例 接口 代码
  • SpringBoot+Redis实现布隆过滤器的示例代码
    目录简述Redis 安装 Bloom Filter基本指令结合 SpingBoot方式一方式二简述 关于布隆过滤器的详细介绍，我在这里就不再赘述一遍了 我们首先知道：BloomFil...
    99+
    2022-11-13
  • SpringBoot+RabbitMQ+Redis实现商品秒杀的示例代码
    目录业务分析创建表功能实现1.用户校验2.下单3.减少库存4.支付总结业务分析 一般而言，商品秒杀大概可以拆分成以下几步： 用户校验 校验是否多次抢单，保证每个商品每个用户只能秒杀一...
    99+
    2022-11-12
软考高级职称资格查询
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作