代码编织梦想

现在,一个问题摆在我们面前:如何将这两种限流机制整合到同一个组件中,以便用户随时切换呢?

显然,我们需要定义一个通用的限流组件,将其引入到业务中,并支持通过配置文件自由切换不同的限流机制。举例而言,当使用limit.type=redis时,启用Redis分布式限流组件,当使用limit.type=local时,启用Guava限流组件。这种自由切换机制能够为用户提供更大的灵活性和可维护性。

接下来,让我们开始动手实现吧!

第一步,创建通用模块cloud-limiter-starter

首先在父项目下创建一个模块

然后在pom文件中引入相关依赖

<dependencies>
  <dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
  </dependency>
  <!--SpringFramework-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <scope>provided</scope>
  </dependency>

</dependencies>
复制代码

小提示:通用模块命名最好遵照规则以starter命名结束,同时通用模块引入的依赖最好设置<scope>provided</scope>属性。

第二步,实现限流功能

  1. 创建限流接口

既然有两种限流机制,按照套路肯定得先创建一个限流接口,就叫LimiterManager吧。

public interface LimiterManager {
    boolean tryAccess(Limiter limiter);
}
复制代码
  1. 分别实现Redis的限流功能和Guava的限流功能,这里只给出核心代码。

Guava限流的核心实现GuavaLimiter

@Slf4j
public class GuavaLimiter implements LimiterManager{
    private final Map<String, RateLimiter> limiterMap = Maps.newConcurrentMap();

    @Override
    public boolean tryAccess(Limiter limiter) {
        RateLimiter rateLimiter = getRateLimiter(limiter);
        if (rateLimiter == null) {
            return false;
        }

        boolean access = rateLimiter.tryAcquire(1,100, TimeUnit.MILLISECONDS);

        log.info("{} access :{}",limiter.getKey() , access);

        return access;
    }
}    
复制代码

Redis限流的核心实现RedisLimiter

@Slf4j
public class RedisLimiter implements LimiterManager{

    private final StringRedisTemplate stringRedisTemplate;

    public RedisLimiter(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean tryAccess(Limiter limiter) {

        String key = limiter.getKey();
        if (StringUtils.isEmpty(key)) {
            throw new LimiterException( "redis limiter key cannot be null" );
        }

        List<String> keys = new ArrayList<>();
        keys.add( key );

        int seconds = limiter.getSeconds();
        int limitCount = limiter.getLimitNum();

        String luaScript = buildLuaScript();

        RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);

        Long count = stringRedisTemplate.execute( redisScript, keys, "" + limitCount, "" + seconds );

        log.info( "Access try count is {} for key={}", count, key );

        return count != null && count != 0;
    }
}    
复制代码

第三步,创建配置类

编写配置类根据配置文件注入限流实现类,当配置文件中属性 limit.type=local 时启用Guava限流机制,当limit.type=redis 时启用Redis限流机制。

@Configuration
public class LimiterConfigure {

    @Bean
    @ConditionalOnProperty(name = "limit.type",havingValue = "local")
    public LimiterManager guavaLimiter(){
        return new GuavaLimiter();
    }


    @Bean
    @ConditionalOnProperty(name = "limit.type",havingValue = "redis")
    public LimiterManager redisLimiter(StringRedisTemplate stringRedisTemplate){
        return new RedisLimiter(stringRedisTemplate);
    }
}
复制代码

第四步,创建AOP

根据前面的两篇文章可知,避免限流功能污染业务逻辑的最好方式是借助Spring AOP,所以很显然还得需要创建一个AOP。

@Aspect
@EnableAspectJAutoProxy(proxyTargetClass = true) //使用CGLIB代理
@Conditional(LimitAspectCondition.class)
public class LimitAspect {

    @Setter(onMethod_ = @Autowired)
    private LimiterManager limiterManager;

    @Pointcut("@annotation(com.jianzh5.limit.aop.Limit)")
    private void check() {

    }

    @Before("check()")
    public void before(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        Limit limit = method.getAnnotation(Limit.class);
        if(limit != null){

            Limiter limiter = Limiter.builder().limitNum(limit.limitNum())
                    .seconds(limit.seconds())
                    .key(limit.key()).build();

            if(!limiterManager.tryAccess(limiter)){
                throw new LimiterException( "There are currently many people , please try again later!" );
            }
        }
    }
}
复制代码

注意到类上我加了一行@Conditional(LimitAspectCondition.class),使用了自定义条件选择器,意思是只有当配置类中出现了limit.type属性时才会加载这个AOP。

public class LimitAspectCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //检查配置文件是否包含limit.type属性
        return conditionContext.getEnvironment().containsProperty(ConfigConstant.LIMIT_TYPE);
    }
}
复制代码

第四步,创建spring.factories文件,引导SpringBoot加载配置类

## AutoConfiguration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.jianzh5.limit.config.LimiterConfigure,\
  com.jianzh5.limit.aop.LimitAspect
复制代码

完整目录结构如下:

第五步,在项目中引用限流组件

  1. 引入依赖
<dependency>
    <groupId>com.jianzh5</groupId>
    <artifactId>cloud-limit-starter</artifactId>
</dependency>
复制代码
  1. 在application.properties中设置加载的限流组件
limit.type = redis
复制代码

如果不配置此属性则不加载对应限流功能。

  1. 在需要限流的接口上加上注解
@Limit(key = "Limiter:test",limitNum = 3,seconds = 1)
复制代码

小结

通过上述步骤,我们已经成功实现了一个通用限流组件。在实际应用中,只需要根据场景需求选择对应的限流机制,即可非常方便的进行限流操作。这种灵活性和便捷性,也是SpringBoot中定义Starter的一般套路。

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/ww2651071028/article/details/129670653

分布式服务限流_卓立~的博客-爱代码爱编程

上篇简单讲述了一下本地服务令牌桶限流实现,只能用于本地服务,在分布式环境下,就不太适用了。比如我们想对接口做限流控制,如果使用令牌桶实现,每秒最大的服务数目是10,假如分布式服务有10台实例,考虑到负载均衡配置,那么整个分布式系统的服务能力每秒应该大概在100左右,很明显不太适合。如果想要对分布式服务做精确限流,令牌桶这种方式肯定是不合适的。跟之前分布式服

在springboot中使用Guava基于令牌桶实现限流-爱代码爱编程

限流说详细了,名堂也多。这种算法那种算法,这种策略那种策略的。没有绝对的银弹。都要结合实际的场景来实现。最简单的,使用Google的Guava,几行代码。就可以优雅的对一个接口完成限流。 令牌桶算法 通俗的理解就是,有一个固定大小的水桶,水龙头一直按照一定的频率往里面滴水。水满了,就不滴了。客户端每次进行请求之前,都要先尝试从水桶里面起码取出“一滴

在SpringBoot中使用Guava基于令牌桶实现限流,就是这么流批!-爱代码爱编程

点击上方蓝色字体,选择“标星公众号” 优质文章,第一时间送达 关注公众号后台回复pay或mall获取实战项目资料+视频 作者:KevinBlandy https://springboot.io/t/topic/2352 限流说详细了,名堂也多。这种算法那种算法,这种策略那种策略的。没有绝对的银弹。都要结合实际的场景来实现

在SpringBoot中缓存HTTP请求响应体(实现请求响应日志的记录)-爱代码爱编程

缓存请求响应体的目的 把一个HTTP的请求,响应信息完整的纪录到日志。是一种常见有效的问题排查,BUG重现的手段。 但是流这种东西,有一个特点就是只能读取/写入一次,不能重复。下一次读写,就是一个空的流,为了实现流的重用,就很有必要,把读取和写入的数据缓存起来, 可以在某个地方,再一次的读取。 实现的思路 HttpServletRequestWra

分布式系统限流、降级、熔断框架Hystrix-爱代码爱编程

为什么需要容错限流 复杂分布式系统通常有很多依赖,如果一个应用不能对来自依赖 故障进行隔离,那么应用本身就处在被拖垮的风险中。在一个高流量的网站中,某个单一后端一旦发生延迟,将会在数秒内导致 所有应用资源被耗尽(一个臭鸡蛋影响一篮筐)。如秒杀、抢购、双十一等场景,在某一时间点会有爆发式的网络流量涌入,如果没有好的网络流量限制,任由流量压到后台服务实例,很

自定义注解+Aop 实现 SpringBoot 限流-爱代码爱编程

来聊聊在SpringBoot项目中如何对接口进行限流,有哪些常见的限流算法,如何优雅的进行限流。 首先就让我们来看看为什么需要对接口进行限流? 为什么要进行限流? 因为互联网系统通常都要面对大并发大流量的请求,在突发情况下(最常见的场景就是秒杀、抢购),瞬时大流量会直接将系统打垮,无法对外提供服务。那为了防止出现这种情况最常见的解决方案之一就是限流,

SpringBoot 如何进行限流-爱代码爱编程

如何优雅的进行限流(基于AOP)。 首先就让我们来看看为什么需要对接口进行限流? 为什么要进行限流? 因为互联网系统通常都要面对大并发大流量的请求,在突发情况下(最常见的场景就是秒杀、抢购),瞬时大流量会直接将系统打垮,无法对外提供服务。那为了防止出现这种情况最常见的解决方案之一就是限流,当请求达到一定的并发数或速率,就进行等待、排队、降级、拒绝服务等

新来个技术总监,把限流实现的那叫一个优雅,佩服!_公众号-芋道源码的博客-爱代码爱编程

点击上方“芋道源码”,选择“设为星标” 管她前浪,还是后浪? 能浪的浪,才是好浪! 每天 10:33 更新文章,每天掉亿点点头发... 源码精品专栏  原创 | Java 2021 超神之路,很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件

springboot+redis 实现 api 接口防刷限流_java基基的博客-爱代码爱编程

点击上方“Java基基”,选择“设为星标” 做积极的人,而不是积极废人! 每天 14:00 更新文章,每天掉亿点点头发... 源码精品专栏  原创 | Java 2021 超神之路,很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Shard

【java开发技术积累篇】之springboot项目优美的文件上传方式_java序码的博客-爱代码爱编程

一、首先抛出问题 以阿里云oss文件上传为例,假设我的需求是这样的,我需要发布一条动态,这条动态呢可以是图片、语音、视频,3种类型,每种类型的上传我必须要限制它的文件大小,超过了我就不能让他上传的。如果传统的方式,那就是创建3个上传类型bucket对应图片、语音和视频,其实这种做法是可以的,但是怎么说呢,还不够优雅,如果当这个动态有越来越多种类型,你是不

【spring高级49讲】-爱代码爱编程

Spring高级49讲 Spring是整个Java体系最核心的框架,没有之一面试必备技术、思想提升 一.容器和Bean 第1讲.BeanFactory和ApplicationContext 1.1.Bean

javaee简单示例——基于注解的aop实现-爱代码爱编程

简单介绍: 之前我们介绍了关于XML的面向切面的编程,通过配置文件的方法,在不修改源代码的情况下完成了对已有方法的增强 除了基于XML配置文件的方式,我们还可以使用更简单的,基于注解的方式。 每一次,我们在使用面向切面的注解的时候,我们都要明确三个问题,插什么?插谁?插在哪? 这三个问题也就对应了我们面向切面中的切面,增强,切入点,关系。带着这样的问题

实验5---spring ioc-注解实现-爱代码爱编程

Spring IoC-注解实现 一、实验目的及任务 通过该实验掌握利用Spring 注解方式实现控制反转IoC(依赖注入),掌握Spring常用注解的含义和用法。 二、实验结果 自己编写的代码和配置信息,包括applicationContext.xml,UserServiceImpl,UserDaoImpl等与注解相关的代码。