策略模式实现接口的幂等性校验

yolo自动化项目实例解析(九) 导航 比如我们经常使用的导航,说白了就是寻找两点之间最近的路径,也就是所谓的寻路,我们需要想办法让程序知道他要去哪里,路径包含(起点、轨迹、路径) 阅读详情

👉 这是一个或许对你有用的社群

🐱 一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料: 

239f6471bbfb2e46e613d6b24d38c15b.gif

👉这是一个或许对你有用的开源项目

国产 Star 破 10w+ 的开源项目,前端包括管理后台 + 微信小程序,后端支持单体和微服务架构。

功能涵盖 RBAC 权限、SaaS 多租户、数据权限、商城、支付、工作流、大屏报表、微信公众号、CRM 等等功能:

  • Boot 仓库:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • Cloud 仓库:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn

【国内首批】支持 JDK 21 + SpringBoot 3.2.2、JDK 8 + Spring Boot 2.7.18 双版本 

来源:juejin.cn/post/
7307857937698963494

d5716fc5e5f935213ca03f752807bd35.jpeg


背景

最近在小组同学卷的受不了的情况下,我决定换一个方向卷去,在算法上还是认命吧,跟他们差距太大了, 在最近一段时间偶然看到网上关于接口幂等性校验的文章,在我一番思索下,发现他们的实现原理各有不同而且每种实现原理各有不同,加之最近恰好在学设计模式,我就在想怎样利用设计模式让我们可以随意选择不同的实现方式。在此声明一下,笔者仅仅是一个学生,对于正式的业务流程开发并不太懂,只是利用自己现有的知识储备,打造一个让自己使用起来更方便的小demo, 如果有大佬觉得哪儿有问题,欢迎指出。

71d7d880472204b4505ce4548b869437.jpeg

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

什么是幂等性

在数学领域中对于幂等性的解释是 f(f(x)) = f(x) 即幂等元素x在函数f的多次作用下,其效果和在f的一次作用下相同。在编程上可以理解为,如果某个函数(方法)或接口被调用多次其行为结果和被调用一次相同,则这种函数或接口就具有幂等性。简单举个例子,==天然幂等性==:

假设对象Person中有个name属性,有个

setName(String name){
   this.name = name
}

的方法,那这个方法就是天然幂等的哦,你输入相同的“小明”参数,不论你重复调用多少次都是将名字设置为“小明”,其对对象Person的影响都是一样的。这就是天然幂等性。

==非幂等性==:还是拿对象Person举例子,假设对象中有个age属性,有个

increaseAge(){
   this.age++;
}

方法,我们按正常的步骤一次一次调用是不会有问题的,如果调用者没有控制好逻辑,一次流程重复调用好几次,这时候影响效果和一次是有非常大区别,代码编写者以为它只会调用一次,结果出现了意外调用了很多次,恰好方法不具有幂等性,于是就会出现和预期不一样的效果。这个方法本身是不具备幂等性的,我们可以修改这个方法,让其传入一个标识符,每一次重复的请求会有相同的标识符,方法内部可以根据标识符查数据库是不是已经处理过,如果处理过就不重复处理。这样方法就具备了幂等性。

更通俗一点就是:当在进行转账的时候,我们分了两个系统来处理这个转账的流程:

①系统A负责收集转账人和接收人还有金额的信息然后传给系统B进行转账,将控制逻辑留在系统A。

②系统B读取系统A传过来的信息,负责更改数据库的金额。如果操作成功,就回复系统A成功,如果失败就回复系统A失败。

③系统A可以接受系统B操作成功或失败的回复,但是我们知道,系统A这个交易流程是有等待时间的,如果等待超时,它不确认是否是转账成功或失败,于是系统A会重试调用直到得到一个明确的回复。

这是系统大致的交易流程。这个流程是有问题的,系统B提供的操作接口不是幂等性的,因为A会重复调用接口,导致出现一个接口被同一个数据源发送相同数据切想要达到请求一次接口的效果的现象。

a295593ce2f3bb9bebd99a8010c13943.jpeg

常见请求方式的幂等性

  • √ 满足幂等

  • x 不满足幂等

  • 可能满足也可能不满足幂等,根据实际业务逻辑有关

方法类型是否幂等描述
Get√Get 方法用于获取资源。其一般不会也不应当对系统资源进行改变,所以是幂等的。
PostxPost 方法一般用于创建新的资源。其每次执行都会新增数据,所以不是幂等的。
Put_Put 方法一般用于修改资源。该操作则分情况来判断是不是满足幂等,更新操作中直接根据某个值进行更新,也能保持幂等。不过执行累加操作的更新是非幂等。
Delete_Delete 方法一般用于删除资源。该操作则分情况来判断是不是满足幂等,当根据唯一值进行删除时,删除同一个数据多次执行效果一样。不过需要注意,带查询条件的删除则就不一定满足幂等了。例如在根据条件删除一批数据后,这时候新增加了一条数据也满足条件,然后又执行了一次删除,那么将会导致新增加的这条满足条件数据也被删除。

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://github.com/YunaiV/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

为什么要实现幂等性校验

在接口调用时一般情况下都能正常返回信息不会重复提交,不过在遇见以下情况时可以就会出现问题,如:

  • 前端重复提交表单:在填写一些表格时候,用户填写完成提交,很多时候会因网络波动没有及时对用户做出提交成功响应,致使用户认为没有成功提交,然后一直点提交按钮,这时就会发生重复提交表单请求。

  • 用户恶意进行刷单:例如在实现用户投票这种功能时,如果用户针对一个用户进行重复提交投票,这样会导致接口接收到用户重复提交的投票信息,这样会使投票结果与事实严重不符。

  • 接口超时重复提交:很多时候 HTTP 客户端工具都默认开启超时重试的机制,尤其是第三方调用接口时候,为了防止网络波动超时等造成的请求失败,都会添加重试机制,导致一个请求提交多次。

  • 消息进行重复消费:当使用 MQ 消息中间件时候,如果发生消息中间件出现错误未及时提交消费信息,导致发生重复消费。

使用幂等性最大的优势在于使接口保证任何幂等性操作,免去因重试等造成系统产生的未知的问题。

8c78c08c270c9a9f613e5915d73e37a8.jpeg

如何实现接口的幂等性校验

网上流传最多的应该是四种方式去实现接口的幂等性校验,接下来我们来一个个盘点。

数据库唯一主键

「方案描述」 数据库唯一主键的实现主要是利用数据库中主键唯一约束的特性,一般来说唯一主键比较适用于“插入”时的幂等性,其能保证一张表中只能存在一条带该唯一主键的记录。使用数据库唯一主键完成幂等性时需要注意的是,该主键一般来说并不是使用数据库中自增主键,而是使用分布式 ID 充当主键(或者使用其他算法生成的全局唯一的id),这样才能能保证在分布式环境下 ID 的全局唯一性。

「适用操作:」 插入操作 删除操作

「使用限制:」 需要生成全局唯一主键 ID;

「主要流程:」 ① 客户端执行创建请求,调用服务端接口。② 服务端执行业务逻辑,生成一个分布式 ID,将该 ID 充当待插入数据的主键,然后执数据插入操作,运行对应的 SQL 语句。③ 服务端将该条数据插入数据库中,如果插入成功则表示没有重复调用接口。如果抛出主键重复异常,则表示数据库中已经存在该条记录,返回错误信息到客户端。

数据库乐观锁

「方案描述:」 数据库乐观锁方案一般只能适用于执行“更新操作”的过程,我们可以提前在对应的数据表中多添加一个字段,充当当前数据的版本标识。这样每次对该数据库该表的这条数据执行更新时,都会将该版本标识作为一个条件,值为上次待更新数据中的版本标识的值。「适用操作:」 更新操作

「使用限制:」 需要数据库对应业务表中添加额外字段;

防重 Token 令牌

「方案描述:」 针对客户端连续点击或者调用方的超时重试等情况,例如提交订单,此种操作就可以用 Token 的机制实现防止重复提交。简单的说就是调用方在调用接口的时候先向后端请求一个全局 ID(Token),请求的时候携带这个全局 ID 一起请求(Token 最好将其放到 Headers 中),后端需要对这个 Token 作为 Key,用户信息作为 Value 到 Redis 中进行键值内容校验,如果 Key 存在且 Value 匹配就执行删除命令,然后正常执行后面的业务逻辑。如果不存在对应的 Key 或 Value 不匹配就返回重复执行的错误信息,这样来保证幂等操作。

「适用操作:」 插入操作 更新操作 删除操作

「使用限制:」 需要生成全局唯一 Token 串;需要使用第三方组件 Redis 进行数据效验;

redis

「方案描述:」

第四种是我觉着用着挺方便的,但是实用性应该不大,而且和第三种类似,我们可以把接口名加请求参数通过算法生成一个全局唯一的id,然后 存到redis中,如果在一定时间请求多次,我们就直接拒绝。

「适用操作:」 插入操作 更新操作 删除操作

「使用限制:」 需要使用第三方组件 Redis 进行数据效验;

如何将这几种方式都组装到一起

我使用了Java自带的注解以及设计模式中的策略模式,我们可以在注解中直接指定幂等性校验的方式,当然也可以在配置文件中指定,但是直接在注解中指定更加灵活。

8228d672405c8587b7ce568e187d24a8.jpeg

但是,由于最近时间比较忙,天天被某些人卷,很少有时间去完善,目前只是实现了redis和防重 Token 令牌两种方式的。以下是部分代码

「自定义注解」

package org.example.annotation;

import java.lang.annotation.*;

/**
 * @author zrq
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface RequestMany {
    /**
     * 策略
     * @return
     */
    String value() default "";

    /**
     * 过期时间
     * @return
     */
    long expireTime() default 0;
}

「定义切面」

package org.example.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.example.annotation.RequestMany;
import org.example.factory.RequestManyStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.DigestUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author zrq
 * @ClassName RequestManyValidationAspect
 * @date 2023/11/22 9:14
 * @Description TODO
 */
@Aspect
@Component
public class RequestManyValidationAspect {
    @Autowired
    private Map<String, RequestManyStrategy> idempotentStrategies;

    @Around("@annotation(org.example.annotation.RequestMany)")
    public Object validateIdempotent(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();

        RequestMany requestMany = method.getAnnotation(RequestMany.class);
        String strategy = requestMany.value(); // 获取注解中配置的策略名称
        Integer time = (int)requestMany.expireTime(); // 获取注解中配置的策略名称
        if (!idempotentStrategies.containsKey(strategy)) {
            throw new IllegalArgumentException("Invalid idempotent strategy: " + strategy);
        }
        String key = generateKey(joinPoint); // 根据方法参数等生成唯一的key
        RequestManyStrategy idempotentStrategy = idempotentStrategies.get(strategy);
        idempotentStrategy.validate(key, time);
        return joinPoint.proceed();
    }

    private String generateKey(ProceedingJoinPoint joinPoint) {
        // 获取类名
        String className = joinPoint.getTarget().getClass().getSimpleName();

        // 获取方法名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        String methodName = methodSignature.getMethod().getName();

        // 获取方法参数
        Object[] args = joinPoint.getArgs();
        String argString = Arrays.stream(args)
                .map(Object::toString)
                .collect(Collectors.joining(","));
        // 获取请求携带的 Token
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        // 生成唯一的 key
        String key = className + ":" + methodName + ":" + argString + ":" + token;
        String md5Password = DigestUtils.md5DigestAsHex(key.getBytes());
        return md5Password;
    }

}

「处理异常」

package org.example.exception;

/**
 * 运行时异常
 * @author binbin.hou
 * @since 0.0.1
 */
public class RequestManyValidationException extends RuntimeException {

    public RequestManyValidationException() {
    }

    public RequestManyValidationException(String message) {
        super(message);
    }

    public RequestManyValidationException(String message, Throwable cause) {
        super(message, cause);
    }

    public RequestManyValidationException(Throwable cause) {
        super(cause);
    }

    public RequestManyValidationException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}

「模式工厂」

package org.example.factory;

import org.example.exception.RequestManyValidationException;

/**
 * @author zrq
 * @ClassName RequestManyStrategy
 * @date 2023/11/22 9:04
 * @Description TODO
 */
public interface RequestManyStrategy {
    void validate(String key, Integer time) throws RequestManyValidationException;
}

「模式实现01」

package org.example.factory.impl;

import org.example.exception.RequestManyValidationException;
import org.example.factory.RequestManyStrategy;
import org.example.utils.RedisCache;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * @author zrq
 * @ClassName RedisIdempotentStrategy
 * @date 2023/11/22 9:07
 * @Description TODO
 */
@Component
public class RedisIdempotentStrategy implements RequestManyStrategy {
    @Resource
    private RedisCache redisCache;

    @Override
    public void validate(String key, Integer time) throws RequestManyValidationException {
        if (redisCache.hasKey(key)) {
            throw new RequestManyValidationException("请求次数过多");
        } else {
            redisCache.setCacheObject(key,"1", time, TimeUnit.MINUTES);
        }
    }
}

「模式实现02」

package org.example.factory.impl;

import org.example.exception.RequestManyValidationException;
import org.example.factory.RequestManyStrategy;
import org.example.utils.RedisCache;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * @author zrq
 * @ClassName TokenIdempotentStrategy
 * @date 2023/11/22 9:13
 * @Description TODO
 */
@Component
public class TokenIdempotentStrategy implements RequestManyStrategy {
    @Resource
    private RedisCache redisCache;
    @Override
    public void validate(String key, Integer time) throws RequestManyValidationException {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String token = request.getHeader("token");
        if (token == null || token.isEmpty()) {
            throw new RequestManyValidationException("未授权的token");
        }
        // 根据 key 和 token 执行幂等性校验
        boolean isDuplicateRequest = performTokenValidation(key, token);
        if (!isDuplicateRequest) {
            throw new RequestManyValidationException("多次请求");
        }
    }
    private boolean performTokenValidation(String key, String token) {
        // 执行根据 Token 进行幂等性校验的逻辑
        // 这里可以使用你选择的合适的方法,比如将 Token 存储到数据库或缓存中,然后检查是否已存在
        String storedToken = redisCache.getCacheObject(key);
        // 比较存储的 Token 和当前请求的 Token 是否一致
        return token.equals(storedToken);
    }
}

「redisutil类」

package org.example.utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.BitFieldSubCommands;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
@Slf4j
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 缓存基本的对象,Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象,Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功;false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }
    public boolean hasKey(final String key)
    {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功;false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
    {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext())
        {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<Integer, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 删除Hash中的数据
     *
     * @param key
     * @param hkey
     */
    public void delCacheMapValue(final String key, final String hkey)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(key, hkey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }

    public Boolean sign(String key, int day, boolean sign) {
      return  redisTemplate.opsForValue().setBit(key, day, sign);
    }

    public List<Long> result(String key, int day, int num){
        List<Long> result = stringRedisTemplate.opsForValue().bitField(key, BitFieldSubCommands.create()
                .get(BitFieldSubCommands.BitFieldType.unsigned(day)).valueAt(0)
        );
        return result;
    }

    public Long bigCount(String key) {
        Long execute = (Long)redisTemplate.execute((RedisCallback) cbk -> cbk.bitCount(key.getBytes()));
        return execute;
    }
    public <T> void setCacheZSet(String name,T key, double num) {
        if (key != null) {
            redisTemplate.opsForZSet().add(name,key,num);
        }
    }
    public <T> Long getCacheZSetRanking(String name,String key) {
        Long aLong = null;
        if (key != null) {
            aLong = redisTemplate.opsForZSet().reverseRank(name, key);
        }
        return aLong;
    }
    public <T> Double getCacheZSetScore(String name,T key) {
        Double score = null;
        if (key != null) {
            score = redisTemplate.opsForZSet().score(name, key);
        }
        return score;
    }
    public  Set getCacheZSetLookTop(String name,int nums) {
        Set set = null;
        if (name != null) {
            set = redisTemplate.opsForZSet().reverseRange(name, 0, nums);
        }
        return set;
    }
    public Long getCacheZSetSize(String key) {
        Long aLong = null;
        if (key != null) {
            aLong = redisTemplate.opsForZSet().zCard(key);
        }
        return aLong;
    }

    public <T> Long deleteCacheZSet(String key, T value) {
        Long remove = null;
        if (key != null) {
            remove = redisTemplate.opsForZSet().remove(key, value);
        }
        return remove;
    }
    public List<Long> getBitMap(String key,Integer day) {
        List<Long> bitFieldList = (List<Long>) redisTemplate.execute((RedisCallback<List<Long>>) cbk
                -> cbk.bitField(key.getBytes(), BitFieldSubCommands.create().get(BitFieldSubCommands.BitFieldType.unsigned(day)).valueAt(0)));
        return bitFieldList;
    }
    public Long incrExpire(String key, long time) {
        Long count = redisTemplate.opsForValue().increment(key, 1);
        if (count != null && count == 1) {
            redisTemplate.expire(key, time, TimeUnit.SECONDS);
        }
        return count;
    }
    public boolean removeList(String listName, Integer count, String value) {
        redisTemplate.opsForList().remove(listName,count,value);
        return true;
    }
}

「配置文件」

a7f232db4204b207ca3ed7133aff82df.jpeg

如果要实现其他方式的话只需要实现下RequestManyStrategy模板方法,然后编写自己的校验逻辑就可以。

以上代码已经上传到github :https://github.com/Lumos-i/tools-and-frameworks

结语

大学过的可真快,转眼就大三了,自己的技术还是不行,跟别人的差距还有很大距离,希望自己能在有限的时间里学到更多有用的知识,同时也希望在明年的这个时候可以坐在办公室里敲代码。突然想到高中时中二的一句话“听闻少年二字,应与平庸相斥”,谁不希望这样呢,奈何身边大佬太多,现在只能追赶别人的脚步。。。


欢迎加入我的知识星球,全面提升技术能力。

👉 加入方式,“长按”或“扫描”下方二维码噢:

fb3eb608c777d3cf9172f7f2c4c57449.png

星球的内容包括:项目实战、面试招聘、源码解析、学习路线。

9b8c3739628ee6d13f19ddf7f0e1de86.png

856adb2ba06df79e57d7b7a3058ab9e8.png354009f0bacc5486eb3255ce57adad05.png4d2736acf5643ba65610e00dfff2a92b.png8b9a7b6723fdffe8522c2eea2b7e4030.png

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
Qt 插件开发 plugin 超详细 有源码 Qt 插件化开发框架类似于前后端的微服务的场景,授权哪个微服务则前端可以使用哪个微服务,插件就行硬件插卡一样,可以被随时删除、插入和修改,所以结构很灵活,容易修改,方便软件的升级和维护;插件主要面向接口编程,无需访问.lib文件,热插拔、利于团队开发。即使在程序运行时.dll不存在,也可以正常启动,只是相应插件功能无法正常使用而已;动态库需要访问.lib文件,而且在程序运行时必须保证.lib存在,否则无法正常启动; 阅读详情

相关推荐

基于Python实现基于遥感指数的水体提取

基于Python实现基于遥感指数的水体提取

gis收藏家的博客 6150

一个注解实现接口幂等性,真心优雅!

????这是一个或许对你有用的社群????一对一交流/面试小册/简历优化/求职解惑,欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料:《项目实战(视频)》:从书中学,往事中“练”《互联网高频面试题》:面朝简历学习,春暖花开《架构 x 系统设计》:摧枯拉朽,掌控面试高频场景题《精进 Java 学习指南》:系统学习,互联网主流技术栈《必读 Java 源码专栏》:知其然,知其所以然????这是一个或许...

weixin_44421461的博客 243

一种4位sar adc仿真验证

4位sar adc采用下图的电容阵列,电路如下图:所有电容的正端(也称为上极板)与比较器的反相端连接,比较器同相端接Vin,其工作过程进行大致分析见之前的文章《一种4位sar adc工作过程推导(三)》,下面对这个电路进行仿真验证。 两个参考电压VrefPV_{refP}VrefP​和VrefNV_{refN}VrefN​,V+=VinV_{+}=V_{in}V+​=Vin​,假设1116(VrefP−VrefN)+VrefN<Vin<1216(VrefP−VrefN)+VrefN\frac{

大学生视野 1956

微服务篇之接口幂等性

多次调用方法或者接口不会改变业务状态,可以保证重复调用的结果和单次调用的结果一致。基于RESTful API的角度对部分常见类型请求的幂等性特点进行分析:解决方案如下。

冲鸭的博客 790

恶意流量检测数据集

对当前公开的恶意流量相关数据集进行归类总结,持续更新相关论文

tyutwuxuan的博客 1945

蛋白质组学实战指南 | (八)从数据到洞见:差异蛋白筛选与功能解析全流程

本文系统阐述了蛋白质组学数据分析中,从原始数据质控到差异蛋白筛选与功能解析的全流程。重点介绍了数据质量评估、差异蛋白筛选的统计方法(包括多重检验校正)、功能注释与富集分析,以及蛋白互作网络构建与关键节点识别。最后,为如何将生物信息学洞见转化为实验验证提供了清晰的规划思路,助力研究者完成从数据到生物学知识的闭环。

weixin_29250573的博客 373

rouyi后端开发文档-幂等性(防止重复提交)

例如说,用户快速的双击了某个按钮,前端没有禁用该按钮,导致发送了两次重复的请求。

随风why 1423

PYTHON 打印三角形大全

用PYTHON语言打印各种三角形

世上无难事,只要肯攀登 1万+

微服务接口幂等性问题解决方案(史上最全的)

微服务幂等性接口设计? 首先,什么是接口的幂等性? 就是一个用户对于同一个操作发起一次或多次的请求,请求的结果一致。不会因为多次点击而产生多条数据。 话不多说,下面直接上代码,用代码说话。 当我提交数据的时候,重复提交,则会出现下面的情况: 当多次提交后: 数据库中则会提交一样的数据,这就是幂等性问题,当我在回退的时候再次发请求,则继续向数据库中添加数据: 怎么去解决由于网络延迟或者回滚而产...

qq_44622763的博客 9750

ADS基础教程16 - 存档和导入(workspace、cell、view)

选择workspace_Archive目录作为保存workspace归档的目录,点击打开进行目录选择,点击Finish保存目录。,选择cell_Archive目录作为保存cell归档的目录,点击打开进行目录选择,点击Finish保存目录。,选择view_Archive目录作为保存view归档的目录,点击打开进行目录选择,点击Finish保存目录。(2)在弹框中,可以选择点击Select将参考的条目添加进来,然后点击Next…(2)在弹框中,可以选择点击Select将参考的条目添加进来,然后点击Next…

XZ_ZC的博客 3710

MySQL 一一 MySQL基本使用

1、数据库 简单来说,所谓的数据库就是存储数据的容器,而且是永久存储的。 2、为什么需要数据库 3、为什么要学习MySQL数据库 最早MySQL数据,瑞典AB公司开发的一款开源型的关系型数据库。 随着时间的推移,瑞典AB公司把MySQL数据库转让给Sun公司(Java语言的创始公司) 后来,Sun公司经营不善,又把MySQL数据库转让给甲骨文公司(Oracle数据库) 4、数

Guizy 7万+

如何使用注解实现接口的幂等性校验

在数学领域中对于幂等性的解释是即幂等元素x在函数f的多次作用下,其效果和在f的一次作用下相同。在编程上可以理解为,如果某个函数(方法)或接口被调用多次其行为结果和被调用一次相同,则这种函数或接口就具有幂等性。简单举个例子,天然幂等性假设对象Person中有个name属性,有个的方法,那这个方法就是天然幂等的哦,你输入相同的“小明”参数,不论你重复调用多少次都是将名字设置为“小明”,其对对象Person的影响都是一样的。这就是天然幂等性。非幂等性。

天青色 等烟雨的博客 1008

Python 爬虫实战:从零搭建第一个爬虫程序(附完整代码)

本文介绍了Python网络爬虫的入门实战,以豆瓣Top250电影榜单为例,详细讲解爬虫开发全流程。内容包括爬虫基础原理、环境搭建、请求发送与响应处理、数据解析与保存等核心环节,并提供了可直接运行的完整代码示例。文章还分析了常见问题解决方案,并强调了爬虫开发的合规注意事项。通过本教程,读者可快速掌握Python爬虫的基本思路和实操技巧,为后续深入学习BeautifulSoup、XPath等进阶技术打下基础。

2503_91057718的博客 2316

【设计模式】Java开发:策略模式与注解结合实现接口幂等性

本文展示了一种结合Java注解和策略模式的技术方案,用于实现接口的幂等性校验。通过定义自定义注解@RequestMany和AOP切面RequestManyValidationAspect,开发人员能够在不侵入业务逻辑的前提下,为Web服务的方法添加幂等性支持。文中提供了完整的代码实例,涵盖了幂等性策略接口RequestManyStrategy的设计及其实现,例如基于Redis的RedisIdempotentStrategy和基于Token的TokenIdempotentStrategy。

欢迎来到我的技术空间!我是一名经验丰富的Java开发工程师,热衷于分享我在软件开发领域的知识和心得。在这个博客里,您会发现一系列关于Java编程的文章,包括最佳实践、技术趋势、代码优化技巧以及一些有趣的项目案例。无论是初学者还是有经验的开发者,都能在这里找 853

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

拒绝 If-Else 堆砌:复杂分账业务下的 Python 工业级接口设计

写业务代码最忌讳“面向过程”。如果你发现你的if-else该抽象了。这套方案已经在我们的生产环境平稳运行了很久。虽然前期多写了几个类,但在面对后期需求变动(比如新增分账方、修改费率逻辑)时,那种“只改一个配置文件”的优雅,才是开发者真正的尊严。

2201_75368691的博客 315

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

2025年医学信息工程毕业设计效率提升指南:从重复造轮子到模块化开发实践

通过这一套“模块化开发”的组合拳,我的毕业设计开发周期从预估的4个月缩短到了2个半月,并且代码结构清晰,后期添加新功能也非常顺畅。最大的体会是,前期在技术选型和架构设计上多花一两天时间思考,中期就能节省几周甚至更长的调试和返工时间。毕业设计不仅是完成一个任务,更是一次完整的、贴近工业实践的软件工程训练。希望这份指南能帮助2025年的你,更从容、更高效地完成这份学业答卷,甚至为未来的职业发展埋下一颗种子。当你看着自己构建的、结构清晰、运行稳定的系统时,那种成就感,绝对远超“糊弄”出一个勉强能跑的程序。

2600_94959880的博客 342

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

技术组件之幂等性组件

生产级幂等性组件设计思路及实现,通过sdk方式无缝引入到服务中,支持多场景灵活的幂等性拦截机制,满足各个业务场景的接口级别幂等性拦截。

爱好技术的小老头 1302

设计好接口的36个锦囊

接口参数校验 修改老接口时,注意接口的兼容性 设计接口时,充分考虑接口的可扩展性。策略模式

weixin_42248522的博客 314

携程后端实习一面深度复盘:从 Redis 分布式锁、幂等设计到 HTTPS 加密全流程,面试官连环追问底层原理!

非对称加密:仅用于安全传输对称密钥;对称加密:用于高效加密大量数据;CA:作为可信第三方,证明“公钥属于该网站”。🔒核心思想:用非对称解决密钥分发问题,用对称解决性能问题。维度考察点工程能力分布式锁、幂等、MQ、代码规范底层原理SDS、Bitmap、String 内存、密码学系统设计分层架构、前后端交互、安全设计。

吾为热爱计科,致力于知识分享的践行者,此博客是我在这条道路上留下的足迹。 743

spring cloud项目电商C端的秒杀业务三性六讲

因为是高流量高并发的业务场景会有高并发的问题,就会出现超卖的现象,当时解决这个问题我采用的是redisson分布式锁,对库存进行上锁,redis分布式锁其实就是往redis设置一个key和value同时设置一个有效时间,并且redis是单线程的,不会并发操作,之后在进行删除redis的缓存进行解锁,从而避免超卖的现象,后期测项目效率不够快,做了优化通过lua脚本,意为着可以将多个操作合并为一个原子操作,做到无锁。我们目前做的项目是一个社区团购的电商系统,主要就是实现一个线上线下的结合。

2401_84479435的博客 726

AI 辅助开发实战:基于 Java 的工资管理系统毕业设计架构与实现

面对众多Java技术栈,如何选择?我的原则是:成熟、主流、社区活跃、学习成本适中。AI工具(如GitHub Copilot、通义灵码)对这些主流框架的支持也更好。Spring Boot vs. 原生Servlet:毫无疑问选择Spring Boot。它通过自动配置和起步依赖,极大地简化了Spring应用的初始搭建和开发过程。你不再需要繁琐的XML配置,可以快速构建出独立运行、生产级别的应用。原生Servlet开发效率低,且需要手动管理很多基础设施。:这是一个常见的选择题。

2600_94959952的博客 262

基于Netty的高性能RPC框架(分布式缓存、雪花算法、幂等性)

解决了幂等性不能在多台服务器实现的问题,处理涉及分布式缓存、雪花算法、时钟回拨等有挑战性的问题。VERSIONVERSION2.1.02.1.0JDK: 8.0JDKJDK8.08.0NACOSNACOS1.431.43NETTYNETTYLICENCELICENCEMITMIT一个分布式微服务RPC框架 |英文说明文档|SpringBoot整合RPC基于Socket和Netty异步非阻塞通信的解决方案;

fyphome 1554

自动化毕设选题系统的技术实现:从需求建模到可扩展架构

构建一个自动化毕设选题系统,技术上的核心在于处理好“选择”这一动作在并发下的正确性(不超卖、数据一致)、公平性(合理的分配策略)和体验(响应快、可补偿)。我们采用了策略模式来封装分配逻辑,通过数据库悲观锁和事务保证并发正确性,利用幂等键防止重复提交。这套架构清晰、可扩展,能够支撑起千人并发的选题场景。在完全没有用户历史行为数据(冷启动)的情况下,如何设计一个“公平性优先”的分配策略?是纯粹的随机分配,还是结合绩点、志愿优先级进行多轮匹配?或许可以尝试实现一个简化版的Gale-Shapley稳定匹配算法。

2600_94960234的博客 571

服装租赁管理系统毕业设计:从需求建模到高内聚架构的完整技术实现

最近在辅导学弟学妹们的毕业设计时,发现不少同学在做“服装租赁管理系统”这类项目时,虽然功能都做出来了,但代码结构混乱,业务逻辑像面条一样缠在一起,后期想加个新功能都无从下手。这其实是一个从“课程作业”思维到“工程项目”思维转变的问题。今天,我就结合一个典型的服装租赁系统,聊聊如何用工程化的思路,从零开始构建一个结构清晰、易于维护的毕业设计项目。

2600_94960031的博客 250

餐饮系统菜品删除接口设计:高并发下的安全实践

在数据库操作中,删除功能是保证数据完整性的关键环节,其核心原理是通过事务管理和关联校验实现数据一致性。技术实现上通常采用软删除替代物理删除,配合乐观锁或分布式锁解决并发冲突,这对电商、餐饮等高频操作系统尤为重要。以餐饮管理系统为例,菜品删除涉及订单关联、库存同步等复杂场景,需要建立包括防误删机制、操作日志、性能监控在内的完整技术方案。通过合理使用Redis分布式锁和数据库隔离级别,可有效避免高并发下的'幽灵删除'问题,而Prometheus监控体系则保障了生产环境的可观测性。

388

聚合支付系统设计与实现概述

本文介绍了聚合支付系统的设计与实现,通过整合微信、支付宝、银联等支付渠道,提供统一接入平台。系统采用分层架构,结合工厂模式、策略模式和模板方法等设计模式,确保高扩展性和可维护性。核心功能包括支付流程管理、异步回调处理、多渠道配置和安全机制,支持动态路由选择、MQ异步解耦和自动重试策略。该系统实现了"一次对接,多端支持"的目标,有效解决了商户对接多支付渠道的痛点,同时具备灵活配置、高可用性和安全可靠等特点。

qq_41262225的博客 1063
上一篇: 我们放弃了Nacos作为配置中心,转而选择了这款神器~
下一篇: 一波年初面试总结……
公众号-芋道源码
博客等级 码龄10年 1637粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值