SpringBoot实现单机限流和分布式限流

淩亂°似流年 2024-03-23 10:50 146阅读 0赞

## 第一步，创建项目 ##

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

<dependencies>
      <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
      </dependency>
      
      <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>

## 第二步，实现限流功能 ##

### 创建限流接口 ###

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

public interface LimiterManager {
        
        boolean tryAccess(Limiter limiter);
    }

分别实现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 ##

@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

## 第六步，在项目中引用限流组件 ##

在application.properties中设置加载的限流组件

limit.type = redis

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

在需要限流的接口上加上注解

@Limit(key = "Limiter:test",limitNum = 3,seconds = 1)

> 参考文章：https://mp.weixin.qq.com/s/9-TyUWP93PM1o5oaPYBxjA