微服务架构的四大杀手锏

redis.extend.hostName=127.0.0.1redis.extend.port=6379redis.extend.password=pwdcoderedis.extend.timeout=10000
redis.idempotent.enabled=true

    public String get(String key);
    /**     * 获取指定的key对应的对象,异常也会返回null     *     * @param key     * @param clazz     * @return     */    public <T> T get(String key, Class<T> clz);
    /**     * 存储缓存数据,忽略过期时间     *     * @param key     * @param value     * @return     */    public <T extends Serializable> booleanput(String key, T value);
    /**     * 存储缓存数据     *     * @param key     * @param value     * @param expiredTime     * @param unit     * @return     */    public <T extends Serializable> booleanput(String key, T value, int expiredTime, TimeUnit unit);
    /**     * 基于key删除缓存数据     *     * @param key     * @return     */    publicbooleaninvalid(String key);
get 方法针对 key 进行查询， put 存储缓存数据， invalid 删除缓存数据。

 /**     * 指定过期时间自增计数器，默认每次+1，非滑动窗口     *     * @param key 计数器自增key     * @param expireTime 过期时间     * @param unit  时间单位     * @return     */    publiclongincrCount(String key, int expireTime, TimeUnit unit);
    /**     * 指定过期时间自增计数器,单位时间内超过最大值rateThreshold返回true，否则返回false     *     * @param key 限流key     * @param rateThreshold 限流阈值     * @param expireTime 固定窗口时间     * @param unit 时间单位     * @return     */    publicbooleanrateLimit(final String key, finalint rateThreshold, int expireTime, TimeUnit unit);

 /**     * @param limitKey 限流KEY     * @param resultSupplier 回调方法     * @param rateThreshold 限流阈值     * @param limitTime 限制时间段     * @param blockDuration 阻塞时间段     * @param unit 时间单位     * @param errCodeEnum 指定限流错误码     * @return     */    public <T> T execute(String limitKey, Supplier<T> resultSupplier, long rateThreshold, long limitTime,                         long blockDuration, TimeUnit unit, ErrCodeEnum errCodeEnum){        boolean blocked = tryAcquire(limitKey, rateThreshold, limitTime, blockDuration, unit);        if (errCodeEnum != null) {            AssertUtils.assertTrue(blocked, errCodeEnum);        } else {            AssertUtils.assertTrue(blocked, ExceptionEnumType.ACQUIRE_LOCK_FAIL);        }
        return resultSupplier.get();    }

@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.METHOD)@Documentedpublic @interface RateLimit {
    /**     * 限流KEY     */    String limitKey();
    /**     * 允许访问的次数，默认值MAX_VALUE     */    longlimitCount()default Long.MAX_VALUE;
    /**     * 时间段     */    longtimeRange();
    /**     * 阻塞时间段     */    longblockDuration();
    /**     * 时间单位，默认为秒     */    TimeUnit timeUnit()default TimeUnit.SECONDS;}

@RateLimit(limitKey = "#key", limitCount = 5, timeRange = 2, blockDuration = 3, timeUnit = TimeUnit.MINUTES)public String testLimit2(String key){    ..........    return key;}

 /**     * 分布式锁处理模板执行器     *     * @param lockKey 分布式锁key     * @param resultSupplier 分布式锁处理回调     * @param waitTime 锁等待时间     * @param unit 时间单位     * @param errCodeEnum 指定特殊错误码返回     * @return     */    public static <T> T execute(String lockKey, Supplier<T> resultSupplier, long waitTime, TimeUnit unit,                                ErrCodeEnum errCodeEnum){        AssertUtils.assertTrue(StringUtils.isNotBlank(lockKey), ExceptionEnumType.PARAMETER_ILLEGALL);        boolean locked = false;        Lock lock = DistributedReentrantLock.newLock(lockKey);        try {            locked = waitTime > 0 ? lock.tryLock(waitTime, unit) : lock.tryLock();        } catch (InterruptedException e) {            throw new RuntimeException(String.format("lock error,lockResource:%s", lockKey), e);        }        if (errCodeEnum != null) {            AssertUtils.assertTrue(locked, errCodeEnum);        } else {            AssertUtils.assertTrue(locked, ExceptionEnumType.ACQUIRE_LOCK_FAIL);        }        try {            return resultSupplier.get();        } finally {            lock.unlock();        }    }

    @Idempotent(spelKey = "#request.requestId", firstLevelExpireDate = 7，secondLevelExpireDate = 30)    publicvoidexecute(BizFlowRequest request){       ..................    }

/**     * 幂等模板处理器     *     * @param request 幂等Request信息     * @param executeSupplier 幂等处理回调function     * @param resultPreprocessConsumer 幂等结果回调function 可以对结果做些预处理     * @param ifResultNeedIdempotence 除了根据异常还需要根据结果判定是否需要幂等性的场景可以提供此参数     * @return     */    public R execute(IdempotentRequest<P> request, Supplier<R> executeSupplier,                     Consumer<IdempotentResult<P, R>> resultPreprocessConsumer, Predicate<R> ifResultNeedIdempotence){
      ........    }