开源工具（三）计算限流

已于 2023-12-14 15:00:42 修改
阅读量2.4w 收藏 5
点赞数 7
分类专栏： java 限流 redis 文章标签： java redis 分布式 开源
于 2022-06-14 09:48:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69270256/article/details/125271723
版权
java 同时被 3 个专栏收录
31 篇文章 2 订阅
订阅专栏
redis
6 篇文章 1 订阅
订阅专栏
限流
2 篇文章 1 订阅
订阅专栏

一、引言

        在项目中使用博主自己封装的计算限流工具已经很久了，慢慢发展已经比较完善通用，现在开源共享。

github地址：

GitHub - SongTing0711/count-limit

gitee地址：count-limit: 轻量级的java限流工具， 针对大容量、高并发的接口、mq或者其他计算方法，同一时间在运行的计算维度进行限制，相当于把资源到计算的对象维度。 不同于参数限制，工具针对的是服务所有线程对于该计算维度的限流。

         相比较博主之前在java计算限流工具_tingmailang的博客-CSDN博客_限流工具封装的工具，开源的工具除了支持本地锁、本地存储之外还支持spring redis、redisson等进行加锁或者存储，注解配置更为灵活，可以看出工具演变的过程。

二、代码解析

1、注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CountLimit {
    String objectName();

    String paramName() default "";

    int limit() default 10000;

    int waitTime() default 2;
    //存储与加锁方式，默认本地存储本地锁
    String countFactoryEnum() default CountLimitCommonUtil.LOCAL_LOCK_STORE;
}

2、注解配置加锁存储枚举

@Getter
public enum CountFactoryEnum {

    LOCAL_LOCK_STORE("local_lock_store", "使用本地锁本地缓存"),
    LOCAL_LOCK_REDISSON_STORE("local_lock_redisson_store", "使用本地锁redisson缓存"),
    LOCAL_LOCK_SPRING_REDIS_STORE("local_lock_spring_redis_store", "使用本地锁spring redis缓存"),
    REDISSON_LOCK_STORE("redisson_lock_store", "使用redisson锁本地缓存"),
    REDISSON_LOCK_REDISSON_STORE("redisson_lock_redisson_store", "使用redisson锁redisson缓存"),
    SPRING_REDIS_LOCK_STORE("spring_redis_lock_store", "使用spring redis锁本地缓存"),
    SPRING_REDIS_LOCK_SPRING_REDIS_STORE("spring_redis_lock_spring_redis_store", "使用spring redis锁spring redis缓存"),
    ;

    private String key;
    private String value;

    CountFactoryEnum(String key, String value) {
        this.key = key;
        this.value = value;
    }

    @JsonCreator
    public static CountFactoryEnum of(String key) {
        Optional<CountFactoryEnum> systemTypeEnum = Arrays.stream(CountFactoryEnum.values())
                .filter(c -> c.getKey().equals(key)).findFirst();
        return systemTypeEnum.orElse(null);
    }
}

3、工具类

/**
 * @description: 计算限流
 * @author: tingmailang
 */
@Data
public class CountLimitDTO {

    private String Key;
    private Integer count;
    private Integer limit;
    private Boolean isAdd;
}


/**
 * 共用类
 */
public class CountLimitCommonUtil {

    public static final String COUNT_LIMIT_LOCK = "COUNT_LIMIT_LOCK:";

    public static final String COUNT_LIMIT_REDIS_NODE_LOCK = "COUNT_LIMIT_REDIS_NODE_LOCK:";

    public static final String COUNT_LIMIT_REDIS_NODE_STORE = "COUNT_LIMIT_REDIS_NODE_STORE:";

    public static final String COUNT_LIMIT_STORE = "COUNT_LIMIT_STORE:";

    public static final String LOCAL_LOCK_STORE = "local_lock_store";

    public static final String LOCAL_LOCK_REDISSON_STORE = "local_lock_redisson_store";

    public static final String LOCAL_LOCK_SPRING_REDIS_STORE = "local_lock_spring_redis_store";

    public static final String REDISSON_LOCK_STORE = "redisson_lock_store";

    public static final String REDISSON_LOCK_REDISSON_STORE = "redisson_lock_redisson_store";

    public static final String SPRING_REDIS_LOCK_STORE = "spring_redis_lock_store";

    public static final String SPRING_REDIS_LOCK_SPRING_REDIS_STORE = "spring_redis_lock_spring_redis_store";

    private static volatile String NODE_ID;

    public static volatile int SPILT_SLEEP = 20;

    public static final String GET = "get";

    public static String getNodeId() {
        return NODE_ID;
    }

    public static synchronized void setNodeId(String nodeId) {
        NODE_ID = nodeId;
    }

    public static synchronized void setSpiltSleep(int spiltSleep) {
        SPILT_SLEEP = spiltSleep;
    }

    public static Object getFieldValueByName(String fieldName, Object o) {
        try {
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            String getter = GET + firstLetter + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[]{});
            Object value = method.invoke(o, new Object[]{});
            return value;
        } catch (Exception e) {
            throw new CountLimitException("获取属性值失败", e);
        }
    }

}

4、工厂类

/**
 * 计数限流  Facade
 *
 * @author tingmailang
 * @date 2020/3/2
 */
public interface CountLimitFacade<T> extends MatchingBean<CountFactoryEnum> {

    boolean process(T t);
}

@Component
public class CountLimitFacadeFactory<T> implements FactoryList<CountLimitFacade<T>, CountFactoryEnum> {
    @Resource
    private List<CountLimitFacade> countLimitFacades;

    @Override
    public CountLimitFacade<T> getBean(CountFactoryEnum factory) {
        for (CountLimitFacade countLimitFacade : countLimitFacades) {
            if (countLimitFacade.matching(factory)) {
                return countLimitFacade;
            }
        }
        throw new CountLimitException("找不到计数限流实现类");
    }
}

public interface FactoryList<E extends MatchingBean<K>, K> {

    E getBean(K factory);

}

public interface MatchingBean<T> {
    Boolean matching(T factory);
}

5、工厂实现类

①本地锁本地存储

@Component
public class LocalLockLocalStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {

    private static ReentrantLock lock = new ReentrantLock();


    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.LOCAL_LOCK_STORE, factory);
    }

    @Override
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return this.checkExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return this.reduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }

    /**
     * 检查是否超出计算限制
     *
     * @param key
     * @param count
     * @param limit
     * @return
     */
    public boolean checkExceed(String key, int count, int limit) {
        try {
            if (lock.tryLock()) {
                return super.localCheckExceed(key, count, limit);
            } else {
                return false;
            }
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }


    /**
     * 减少目前在查询中的参数量级
     *
     * @param key
     * @param count
     */
    public boolean reduce(String key, int count) {
        try {
            if (lock.tryLock(10, TimeUnit.SECONDS)) {
                return super.localReduce(key, count);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        return false;
    }

}

②本地锁redisson存储

@Component
public class LocalLockRedissonStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {

    private static ReentrantLock lock = new ReentrantLock();

    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.LOCAL_LOCK_REDISSON_STORE, factory);
    }

    @Override
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return this.checkExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return this.reduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }

    /**
     * 检查是否超出计算限制
     *
     * @param key
     * @param count
     * @param limit
     * @return
     */
    public boolean checkExceed(String key, int count, int limit) {
        try {
            if (lock.tryLock()) {
                return super.redissonCheckExceed(key, count, limit);
            } else {
                return false;
            }
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }


    /**
     * 减少目前在查询中的参数量级
     *
     * @param key
     * @param count
     */
    public boolean reduce(String key, int count) {
        try {
            if (lock.tryLock(10, TimeUnit.SECONDS)) {
                return super.redissonReduce(key, count);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        return false;
    }

}

③本地锁spring redis存储

@Component
public class LocalLockSpringRedisStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {

    private static ReentrantLock lock = new ReentrantLock();

    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.LOCAL_LOCK_SPRING_REDIS_STORE, factory);
    }

    @Override
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return this.checkExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return this.reduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }

    /**
     * 检查是否超出计算限制
     *
     * @param key
     * @param count
     * @param limit
     * @return
     */
    public boolean checkExceed(String key, int count, int limit) {
        try {
            if (lock.tryLock()) {
                return super.springRedisCheckExceed(key, count, limit);
            } else {
                return false;
            }
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }


    /**
     * 减少目前在查询中的参数量级
     *
     * @param key
     * @param count
     */
    public boolean reduce(String key, int count) {
        try {
            if (lock.tryLock(10, TimeUnit.SECONDS)) {
                return super.localReduce(key, count);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        return false;
    }

}

④redisson锁本地存储

这里使用了博主封装的分布式代理锁进行并发控制，后续使用分布式锁的地方都可以看到一个注解搞定加锁开源工具distributed-proxy-lock（分布式代理锁）_tingmailang的博客-CSDN博客

@Component
public class RedissonLockLocalStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {

    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.REDISSON_LOCK_STORE, factory);
    }

    @Override
    @DistributedProxyLock(key = CountLimitCommonUtil.COUNT_LIMIT_LOCK,
            suffixKeyTypeEnum = DistributedProxyLockCommonUtil.PARAM,
            objectName = "countLimitDTO",
            paramName = "LockKey")
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return super.localCheckExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return super.localReduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }

}

⑤redisson锁redisson存储

@Component
public class RedissonLockRedissonStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {

    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.REDISSON_LOCK_REDISSON_STORE, factory);
    }

    @Override
    @DistributedProxyLock(key = CountLimitCommonUtil.COUNT_LIMIT_LOCK,
            suffixKeyTypeEnum = DistributedProxyLockCommonUtil.PARAM,
            objectName = "countLimitDTO",
            paramName = "LockKey")
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return super.redissonCheckExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return super.redissonReduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }

}

⑥SpringRedis锁本地存储

@Component
public class SpringRedisLockLocalStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {


    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.SPRING_REDIS_LOCK_STORE, factory);
    }

    @Override
    @DistributedProxyLock(key = CountLimitCommonUtil.COUNT_LIMIT_LOCK,
            suffixKeyTypeEnum = DistributedProxyLockCommonUtil.PARAM,
            objectName = "countLimitDTO",
            paramName = "LockKey",
            lockConnectionEnum = DistributedProxyLockCommonUtil.SPRING_REDIS)
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return super.localCheckExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return super.localReduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }


}

⑦SpringRedis锁SpringRedis存储

@Component
public class SpringRedisLockSpringRedisStore extends CountLimitCommonBusiness implements CountLimitFacade<CountLimitDTO> {


    @Override
    public Boolean matching(CountFactoryEnum factory) {
        return Objects.equals(CountFactoryEnum.SPRING_REDIS_LOCK_SPRING_REDIS_STORE, factory);
    }

    @Override
    @DistributedProxyLock(key = CountLimitCommonUtil.COUNT_LIMIT_LOCK,
            suffixKeyTypeEnum = DistributedProxyLockCommonUtil.PARAM,
            objectName = "countLimitDTO",
            paramName = "LockKey",
            lockConnectionEnum = DistributedProxyLockCommonUtil.SPRING_REDIS)
    public boolean process(CountLimitDTO countLimitDTO) {
        if (countLimitDTO.getIsAdd()) {
            return super.springRedisCheckExceed(countLimitDTO.getKey(), countLimitDTO.getCount(), countLimitDTO.getLimit());
        } else {
            return super.springRedisReduce(countLimitDTO.getKey(), countLimitDTO.getCount());
        }
    }

}

以上工具都继承了父类CountLimitCommonBusiness，下面来看一下父类中做了什么

@Service
@Slf4j
public class CountLimitCommonBusiness {

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private RedisTemplate redisTemplate;

    @Resource
    private CountLimitNode countLimitNode;

    private static volatile ConcurrentHashMap<String, Integer> countMap = new ConcurrentHashMap<>();

    /**
     * redisson检查是否超出计算限制
     *
     * @param key
     * @param count
     * @param limit
     * @return
     */
    public boolean redissonCheckExceed(String key, int count, int limit) {
        this.checkNode(LockConnectionEnum.REDISSON);
        RBucket<Integer> bucket = redissonClient.getBucket(CountLimitCommonUtil.COUNT_LIMIT_STORE + CountLimitCommonUtil.getNodeId() + key);
        int now = 0;
        if (bucket.isExists()) {
            now = bucket.get();
        }
        if (now + count > limit) {
            return false;
        } else {
            log.debug("CountLimitAspect:{}增加计算量:{}", key, now + count);
            bucket.set(now + count);
            return true;
        }
    }


    /**
     * redisson减少目前在查询中的参数量级
     *
     * @param key
     * @param count
     */
    public boolean redissonReduce(String key, int count) {
        this.checkNode(LockConnectionEnum.REDISSON);
        RBucket<Integer> bucket = redissonClient.getBucket(CountLimitCommonUtil.COUNT_LIMIT_STORE + CountLimitCommonUtil.getNodeId() + key);
        int now = bucket.get();
        log.debug("CountLimitAspect:{}减少计算量:{}", key, now - count);
        bucket.set(now - count);
        return true;
    }


    /**
     * local检查是否超出计算限制
     *
     * @param key
     * @param count
     * @param limit
     * @return
     */
    public boolean localCheckExceed(String key, int count, int limit) {
        int now = countMap.getOrDefault(key, 0);
        if (now + count > limit) {
            return false;
        } else {
            log.debug("CountLimitAspect:{}增加计算量:{}", key, now + count);
            countMap.put(key, now + count);
            return true;
        }
    }


    /**
     * local减少目前在查询中的参数量级
     *
     * @param key
     * @param count
     */
    public boolean localReduce(String key, int count) {
        int now = countMap.get(key);
        log.debug("CountLimitAspect:{}减少计算量:{}", key, now - count);
        countMap.put(key, now - count);
        return true;
    }


    /**
     * springRedis检查是否超出计算限制
     *
     * @param key
     * @param count
     * @param limit
     * @return
     */
    public boolean springRedisCheckExceed(String key, int count, int limit) {
        this.checkNode(LockConnectionEnum.SPRING_REDIS);
        Integer now = (Integer) redisTemplate.opsForValue().get(CountLimitCommonUtil.COUNT_LIMIT_STORE + CountLimitCommonUtil.getNodeId() + key);
        if (now == null) {
            now = 0;
        }
        if (now + count > limit) {
            return false;
        } else {
            log.debug("CountLimitAspect:{}增加计算量:{}", key, now + count);
            redisTemplate.opsForValue().set(CountLimitCommonUtil.COUNT_LIMIT_STORE + CountLimitCommonUtil.getNodeId() + key, now + count);
            return true;
        }
    }


    /**
     * springRedis减少目前在查询中的参数量级
     *
     * @param key
     * @param count
     */
    public boolean springRedisReduce(String key, int count) {
        this.checkNode(LockConnectionEnum.SPRING_REDIS);
        Integer now = (Integer) redisTemplate.opsForValue().get(CountLimitCommonUtil.COUNT_LIMIT_STORE + CountLimitCommonUtil.getNodeId() + key);
        if (now == null) {
            now = 0;
        }
        log.debug("CountLimitAspect:{}减少计算量:{}", key, now - count);
        redisTemplate.opsForValue().set(CountLimitCommonUtil.COUNT_LIMIT_STORE + CountLimitCommonUtil.getNodeId() + key, now - count);
        return true;
    }

    /**
     * 检查节点id，如果为空就设置
     *
     * @param lockConnectionEnum
     */
    public void checkNode(LockConnectionEnum lockConnectionEnum) {
        if (CountLimitCommonUtil.getNodeId() != null) {
            return;
        }
        countLimitNode.setNode(lockConnectionEnum);
    }
}

可以看出父类封装了共通的操作redis和本地缓存的方法，同时在使用redis的同时考虑了分布式唯一性，在CountLimitCommonUtil中NODE_ID是可以设置的，可以由使用者自己进行赋值操作，volatile保证可见性。

如果使用者不进行赋值操作也没有问题，工具自动在CountLimitNode中实现了分布式节点的唯一id，保证节点存储的独立性。

@Service
public class CountLimitNode {

    @Resource
    private RedissonClient redissonClient;

    @Resource
    private RedisTemplate redisTemplate;

    @DistributedProxyLock(key = CountLimitCommonUtil.COUNT_LIMIT_REDIS_NODE_LOCK)
    public void setNode(LockConnectionEnum lockConnectionEnum) {
        if (CountLimitCommonUtil.getNodeId() != null) {
            return;
        }
        switch (lockConnectionEnum) {
            case SPRING_REDIS:
                Integer temp = (Integer) redisTemplate.opsForValue().get(CountLimitCommonUtil.COUNT_LIMIT_REDIS_NODE_STORE);
                if (temp == null) {
                    temp = 0;
                }
                temp++;
                redisTemplate.opsForValue().set(CountLimitCommonUtil.COUNT_LIMIT_REDIS_NODE_STORE, temp);
                CountLimitCommonUtil.setNodeId(temp.toString());
                break;
            case REDISSON:
                RBucket<Integer> bucket = redissonClient.getBucket(CountLimitCommonUtil.COUNT_LIMIT_REDIS_NODE_STORE);
                Integer now = 0;
                if (bucket.isExists()) {
                    now = bucket.get() + 1;
                }
                bucket.set(now);
                CountLimitCommonUtil.setNodeId(now.toString());
                break;
        }
    }

}

6、切面

@Aspect
@Component
public class CountLimitAspect<T> {

    @Resource
    private CountLimitFacadeFactory<CountLimitDTO> countLimitFacadeFactory;

    @Pointcut("@annotation(com.annotation.CountLimit)")
    public void lockPointCut() {

    }

    @Around("lockPointCut() && @annotation(countLimit)")
    public Object around(ProceedingJoinPoint joinPoint, CountLimit countLimit) throws Throwable {
        LocalDateTime start = LocalDateTime.now();
        String inter = joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName();
        String objectName = countLimit.objectName();
        Object[] args = joinPoint.getArgs();
        String[] paramNames = ((CodeSignature) joinPoint.getSignature()).getParameterNames();
        Map<String, Object> param = new HashMap<>();
        String par = countLimit.paramName();
        for (int i = 0; i < paramNames.length; i++) {
            param.put(paramNames[i], args[i]);
        }
        CountFactoryEnum countFactoryEnum = CountFactoryEnum.of(countLimit.countFactoryEnum());
        //获取限制的参数
        List<T> queryPar;
        String key = inter + objectName;
        int count;
        CountLimitDTO countLimitDTO = new CountLimitDTO();
        try {
            if (StringUtil.isBlank(par)) {
                //如果没有设置参数，说明在入参对象中
                queryPar = (List<T>) param.get(objectName);
            } else {
                //说明在入参的某个对象中，有一个参数是进行限流
                Object o = param.get(objectName);
                queryPar = (List<T>) CountLimitCommonUtil.getFieldValueByName(par, o);
                key += par;
            }
            count = queryPar.size();
            countLimitDTO.setKey(key);
            countLimitDTO.setCount(count);
            countLimitDTO.setLimit(countLimit.limit());
            countLimitDTO.setIsAdd(Boolean.TRUE);
            while (!countLimitFacadeFactory.getBean(countFactoryEnum).process(countLimitDTO)) {
                //是否超出等待时间
                if (start.plusSeconds(countLimit.waitTime()).isBefore(LocalDateTime.now())) {
                    throw new CountLimitException("超出等待时间" + key);
                }
                //将等待时长划分为等份时长
                Thread.sleep(countLimit.waitTime() * 1000 / CountLimitCommonUtil.SPILT_SLEEP);
            }
        } catch (Exception e) {
            throw new CountLimitException("计算限流异常", e);
        }

        try {
            return joinPoint.proceed();
        } finally {
            countLimitDTO.setIsAdd(Boolean.FALSE);
            boolean success = countLimitFacadeFactory.getBean(countFactoryEnum).process(countLimitDTO);
            if (!success) {
                throw new CountLimitException("计算量减少失败" + countLimitDTO.toString());
            }
        }
    }

}

三、使用

1、计算量的存储与并发控制主要分为redis和本地两种，目前支持链接redis的工具主要是redisson、spring redis
2、因此有以下七种使用方式，默认使用ReentrantLock加锁，本地map缓存
3、如果使用工具的地方很多，存储比较适合使用redis
4、如果限流的方法qps很高，使用redis进行加锁处理可能是比ReentrantLock更好的选择

   1、ReentrantLock加锁，本地map缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }
    
    2、ReentrantLock加锁，redisson缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000, 
        countFactoryEnum = CountLimitCommonUtil.LOCAL_LOCK_REDISSON_STORE)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }
    
    
    3、ReentrantLock加锁，spring redis缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000, 
        countFactoryEnum = CountLimitCommonUtil.LOCAL_LOCK_SPRING_REDIS_STORE)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }
    
    4、redisson加锁，本地map缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000, 
        countFactoryEnum = CountLimitCommonUtil.REDISSON_LOCK_STORE)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }
    
    5、redisson加锁，redisson缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000, 
        countFactoryEnum = CountLimitCommonUtil.REDISSON_LOCK_REDISSON_STORE)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }
    
    6、spring redis加锁，本地map缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000, 
        countFactoryEnum = CountLimitCommonUtil.SPRING_REDIS_LOCK_STORE)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }
    
    7、spring redis加锁，spring redis缓存
    
    @CountLimit(objectName = "request", 
        paramName = "shopIdList", 
        limit = 20000, 
        countFactoryEnum = CountLimitCommonUtil.SPRING_REDIS_LOCK_SPRING_REDIS_STORE)
    public void audit(ShopOnlineDTO request) {
        //业务处理
    }

四、总结

        新生的工具总是可以做到更多事情的，希望有兴趣的同学发挥想象力提出issue或者加入到工具开源的扩展中。

胖当当技术
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java服务限流之Guava
Java码农杂谈
05-16 915
Google开源的工具包Guava具备很多强大的功能，限流器就是其中之一。常见的限流算法主要有固定窗口、滑动窗口、漏桶、令牌桶算法这几种。Guava的限流算法是基于令牌桶来实现的！下面为大家通俗介绍下令牌桶算法：令牌桶算法核心就是一个维护一个固定容量令牌的容器（就是桶），按照固定速率往桶里添加令牌。桶中最多存放N个令牌，当桶满时，新添加的令牌被丢弃；当接收到请求时，去桶中获取一个令牌，获取到则继续执行，并删除对应的令牌；未获取到令牌则丢弃请求（被限流）。
常用的限流方式 Java 实现
Mosiclone的博客
02-15 1675
限流器通过限制请求次数来达到保护服务的目的，每次请求都会尝试执行，如果接口返回成功则可以执行，如果返回失败则需要等待或者直接返回失败。限流器主要分为固定时间窗口限流、滑动时间窗口限流、漏斗式限流和令牌桶限流。比较常用的是 guava 中的限流器，采用的是令牌桶的限流方式。固定时间窗口限流的方式比较简单，但是无法限制住突发流量。假设固定窗口大小为 1s，限制请求次数为 100，如果在 0.99s 和 1.01s 都被请求 100 次，对于固定时间窗口限流器来说，是正常流量，但是可能就导致服务异常。
5种限流算法，7种限流方式，挡住突发流量
gb4215287的博客
12-29 1076
限流算法
Java常见限流用法介绍和实现
最新发布
YY-帆S的博客
03-27 1683
在固定时间窗口的基础上进行优化，对大的时间窗口进行划分，每个小窗口对应大窗口中的不同时间点，每个窗口独立计数。又如在最后1个毫秒内请求了100个请求，下一个毫秒开始新的时间窗口，计数清0，此时又涌入了100个请求，虽说固定时间窗口内没有超过阈值，但是全局看来，这两个毫秒内就涌入了200个请求，对于限流100的概念是不可接受的。与漏桶算法相反，系统以固定的速率往桶里放入令牌，称为令牌桶，如果有请求需要这个令牌，这可以从桶里拿一个，拿到了令牌即允许放行，直到令牌被拿完即令牌不足，则请求需等待或被丢弃。
限流算法及实现
weixin_43489232的博客
03-21 156
限流算法
RateLimiter限流
玲珑骰子安红豆，入骨相思知不知
03-27 8354
限流背景 在早期的计算机领域，限流技术（time limiting）被用做控制网络接口收发通信数据的速率。可以用来优化性能，减少延迟和提高带宽等。现在在互联网领域，也借鉴了这个概念，用来为服务控制请求的速率，如双十一的限流，12306的抢票等。即使在细粒度的软件架构中，也有类似的概念。 系统在使用下游资源时，需要考虑下游对资源受限，处理能力，在下游资源无法或者短时间内无法提升处理性能的情况下，可以使用限流器或者类似保护机制，避免下游服务崩溃造成整体服务的不可用。 限流相关概念 在介绍限流之前先介绍几
基于加权计数器限流算法的java计算限流工具
05-24
与市面上开源的限流工具（如谷歌的RateLimiter令牌桶限流、京东HotKey的滑动窗口限流，更关注流量突发缓解，但是过去流量占用资源是否释放不被关注）不同点在于使用加权计数器限流算法，关注流量的处理结果 1、计算...
JAVA上百实例源码以及开源项目
01-03
两个例子，无状态SessionBean可会话Bean必须实现SessionBean，获取系统属性，初始化JNDI，取得Home对象的引用，创建EJB对象，计算利息等；在有状态SessionBean中，用累加器，以对话状态存储起来，创建EJB对象，并将...
国内外主流的三维GIS软件
03-14
　介绍：InfoEarth TelluroMap采用面向Internet的分布式计算技术和三维可视化技术，支持跨区域、跨网络的复杂大型网络三维应用系统集成。为海量三维空间数据的发布提供了可扩展的开发平台，开发者可以方便、灵活地...
JAVA上百实例源码以及开源项目源代码
09-17
两个例子，无状态SessionBean可会话Bean必须实现SessionBean，获取系统属性，初始化JNDI，取得Home对象的引用，创建EJB对象，计算利息等；在有状态SessionBean中，用累加器，以对话状态存储起来，创建EJB对象，并将...
Sensor-Stream-Pipe:开源传感器流服务器和用于数字化现实的客户端
05-07
通过将数据处理从设备上移开，您将能够对传感器数据进行更强大的计算，并充分利用所有可用的工具。 Moetsi Sensor Stream Pipe旨在克服设备上传感器数据处理的限制。 它通过对设备的颜色或深度帧进行编码和压缩，...
Java限流实现
04-24
NULL 博文链接：https://bijian1013.iteye.com/blog/2382409
【Java】四种方案实现限流
人生苦短，我用python
12-16 2746
详细介绍了四种常见的限流算法：固定窗口、滑动窗口、漏桶和令牌桶。每种算法都有具体的代码示例和适用场景，帮助读者理解和选择最适合自己的限流策略。
Java限流及常见方案
u013938578的博客
02-11 572
在系统架构中，Nginx的代理与路由转发是其作为网关层的一个很重要的功能，由于Nginx天生的轻量级和优秀的设计，让它成为众多公司的首选，Nginx从网关这一层面考虑，可以作为最前置的网关，抵挡大部分的网络流量，因此使用Nginx进行限流也是一个很好的选择，在Nginx中，也提供了常用的基于限流相关的策略配置.如果我们的接口设置了时间窗口内访问上限是20，那么当时间到第六秒的时候，这个时间窗口内的计数总和就变成了10，因为1秒的格子已经退出了时间窗口，因此在第六秒内可以接收的访问量就是20-10=10个。
常用限流算法的Java实现
Huangjiazhen711的博客
11-26 414
主要内容为三种限流算法的Java实现获取连接许可的接口。
实现JAVA高可用的限流算法、分布式限流、熔断框架、服务治理、熔断器、网关、Spring Cloud Gateway
weixin_42985390的博客
08-29 1914
本文设计实现JAVA高可用的限流算法、分布式限流、熔断框架、服务治理、熔断器、网关、Spring Cloud Gateway 限流就是对请求的速率进行限制，避免瞬时的大量请求击垮软件系统。 这往往也是权衡了软件系统的稳定性之后得到的最优解。 ...............
【Spring Web教程】Java常见12种限流方式和算法总结
热门推荐
terrybg
06-06 1万+
在用户并发量比较大的情况下，服务会发生雪崩效应：用户同时请求堆积在一个接口，导致其它的接口服务无法访问，这种效果给到用户体验不好。本章分别描述常见的限流算法。单机版本限流：计数器限流：AtomicInteger、Semaphore信号量、Semaphore控制并发量；滑动窗口限流算法；Guava令牌桶限流；漏桶限流；微服务限流方式：Alibaba Sentinel限流（底层采用滑动窗口算法）；SpringCloud Hystrix限流（底层采用滑动窗口算法）；网关统一设置限流；分布式限流：Redis + L
java中Sentinel限流组件的使用
weixin_68138130的博客
09-01 1298
Sentinel限流组件的使用
十分钟搞懂Java限流及常见方案
m0_71777195的博客
03-30 382
在系统架构中，Nginx的代理与路由转发是其作为网关层的一个很重要的功能，由于Nginx天生的轻量级和优秀的设计，让它成为众多公司的首选，Nginx从网关这一层面考虑，可以作为最前置的网关，抵挡大部分的网络流量，因此使用Nginx进行限流也是一个很好的选择，在Nginx中，也提供了常用的基于限流相关的策略配置.如果我们的接口设置了时间窗口内访问上限是20，那么当时间到第六秒的时候，这个时间窗口内的计数总和就变成了10，因为1秒的格子已经退出了时间窗口，因此在第六秒内可以接收的访问量就是20-10=10个。
基于python的三维重建开源代码怎么找
07-16
4. 开源工具库：还有一些专门用于三维重建的开源工具库，比如Open3D、PyntCloud、PyMesh等，它们提供了丰富的三维重建和点云处理功能，可以在它们的官方网站或者GitHub上找到相应的代码和文档。 总之，通过Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

胖当当技术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值