使用token机制实现接口幂等性校验

最新推荐文章于 2024-08-25 14:52:23 发布
最新推荐文章于 2024-08-25 14:52:23 发布
阅读量6k 收藏 39
点赞数 7
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LiuAustin/article/details/104439239
版权

在这里插入图片描述
接口的幂等性原则

1、接口调用存在的问题

现如今我们的系统大多拆分为分布式SOA，或者微服务，一套系统中包含了多个子系统服务，而一个子系统服务往往会去调用另一个服务，而服务调用服务无非就是使用RPC通信或者restful，既然是通信，那么就有可能在服务器处理完毕后返回结果的时候挂掉，这个时候用户端发现很久没有反应，那么就会多次点击按钮，这样请求有多次，那么处理数据的结果是否要统一呢？那是肯定的！尤其在支付场景。

2、什么是接口幂等性

接口幂等性就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。举个最简单的例子，那就是支付，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额返发现多扣钱了，流水记录也变成了两条．．．,这就没有保证接口的幂等性。

实现思路

为需要保证幂等性的每一次请求创建一个唯一标识token, 先获取token, 并将此token存入redis, 请求接口时, 将此token放到header或者作为请求参数请求接口, 后端接口判断redis中是否存在此token:
如果存在, 正常处理业务逻辑, 并从redis中删除此token, 那么, 如果是重复请求, 由于token已被删除, 则不能通过校验, 返回请勿重复操作提示，
如果不存在, 说明参数不合法或者是重复请求, 返回提示即可。

代码实现

pom.xml

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

RedisUtil

package com.smartMap.media.common.apiIdempotent.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * @description
 */
@Component
public class RedisUtil {

    private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 设值
     * @param key
     * @param value
     * @return
     */
    public void set(String key, String value) {
        logger.info("set key:{} value:{}", key, value);
        stringRedisTemplate.opsForValue().set(key,value);
    }

    /**
     * 设值
     * @param key
     * @param value
     * @param expireTime 过期时间, 单位: s
     * @return
     */
    public void set(String key, String value, int expireTime) {
        logger.info("set key:{} value:{} expireTime:{}", key, value, expireTime);
        stringRedisTemplate.opsForValue().set(key,value, expireTime,TimeUnit.SECONDS);
    }

    /**
     * 取值
     * @param key
     * @return
     */
    public String get(String key) {
        logger.info("get key:{}", key);
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 删除key
     * @param key
     * @return
     */
    public Boolean del(String key) {
        if (exists(key)) {
            return stringRedisTemplate.delete(key);
        } else {
            logger.error("del key:{}", key+" 不存在");
            return false;
        }

    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public Boolean exists(String key) {
        Boolean exists = stringRedisTemplate.hasKey(key);
        logger.info("exists key:{} hasKey:{}", key, exists);
        return exists;
    }
}

自定义注解 @ApiIdempotent

package com.smartMap.media.common.apiIdempotent.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @description
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {

}

响应状态码 ResponseCode

package com.smartMap.media.common.apiIdempotent.common;

/**
 * @description
 */
public enum ResponseCode {

    ILLEGAL_ARGUMENT(10000, "参数不合法"),
    REPETITIVE_OPERATION(10001, "请勿重复操作"),
    ;

    ResponseCode(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    private Integer code;

    private String msg;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

常量 Constant

package com.smartMap.media.common.apiIdempotent.common;

/**
 * @description
 */
public class Constant {

    public interface Redis {
        String OK = "OK";
        Integer EXPIRE_TIME_MINUTE = 60;// 过期时间, 60s, 一分钟
        Integer EXPIRE_TIME_FIVE_MINUTE = 5 * 60;// 过期时间, 60s, 一分钟
        Integer EXPIRE_TIME_HOUR = 60 * 60;// 过期时间, 一小时
        Integer EXPIRE_TIME_DAY = 60 * 60 * 24;// 过期时间, 一天
        String TOKEN_PREFIX = "API_IDEMPOTENT_TOKEN:";
    }
}

token接口 ApiIdempotentTokenService

package com.smartMap.media.common.apiIdempotent.service;

import com.smartMap.media.common.utils.R;

import javax.servlet.http.HttpServletRequest;

/**
 * @description
 */
public interface ApiIdempotentTokenService {

    R createToken();

    void checkToken(HttpServletRequest request);
}

token接口实现类 ApiIdempotentTokenServiceImpl

package com.smartMap.media.common.apiIdempotent.service.impl;

import com.smartMap.media.common.apiIdempotent.common.Constant;
import com.smartMap.media.common.apiIdempotent.common.ResponseCode;
import com.smartMap.media.common.apiIdempotent.service.ApiIdempotentTokenService;
import com.smartMap.media.common.apiIdempotent.utils.RedisUtil;
import com.smartMap.media.common.exception.RRException;
import com.smartMap.media.common.utils.R;
import com.smartMap.media.common.utils.UuidUtils;
import org.apache.commons.lang.text.StrBuilder;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;

/**
 * @description
 */
@Service("apiIdempotentTokenService")
public class ApiIdempotentTokenServiceImpl implements ApiIdempotentTokenService {

    private static final String API_IDEMPOTENT_TOKEN_NAME = "apiIdempotentToken";

    @Autowired
    private RedisUtil redisUtil;

    @Override
    public R createToken() {
        String str = UuidUtils.randomUUID();
        StrBuilder token = new StrBuilder();
        token.append(Constant.Redis.TOKEN_PREFIX).append(str);
        redisUtil.set(token.toString(), token.toString(), Constant.Redis.EXPIRE_TIME_FIVE_MINUTE);
        return R.ok().put("token",token.toString());
    }

    @Override
    public void checkToken(HttpServletRequest request) {
        String token = request.getHeader(API_IDEMPOTENT_TOKEN_NAME);
        // header中不存在token
        if (StringUtils.isBlank(token)) {
            token = request.getParameter(API_IDEMPOTENT_TOKEN_NAME);
            // parameter中也不存在token
            if (StringUtils.isBlank(token)) {
                throw new RRException(ResponseCode.ILLEGAL_ARGUMENT.getMsg(),ResponseCode.ILLEGAL_ARGUMENT.getCode());
            }
        }

        if (!redisUtil.exists(token)) {
            throw new RRException(ResponseCode.REPETITIVE_OPERATION.getMsg(),ResponseCode.REPETITIVE_OPERATION.getCode());
        }

        Boolean del = redisUtil.del(token);
        if (!del) {
            throw new RRException(ResponseCode.REPETITIVE_OPERATION.getMsg(),ResponseCode.REPETITIVE_OPERATION.getCode());
        }
    }
}

拦截器 ApiIdempotentInterceptor

package com.smartMap.media.common.apiIdempotent.interceptor;

import com.smartMap.media.common.apiIdempotent.annotation.ApiIdempotent;
import com.smartMap.media.common.apiIdempotent.service.ApiIdempotentTokenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

/**
 * @description
 */
@Component
public class ApiIdempotentInterceptor extends HandlerInterceptorAdapter {

    @Autowired
    private ApiIdempotentTokenService apiIdempotentTokenService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }

        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();

        ApiIdempotent methodAnnotation = method.getAnnotation(ApiIdempotent.class);
        if (methodAnnotation != null) {
            check(request);
        }

        return true;
    }

    private void check(HttpServletRequest request) {
        apiIdempotentTokenService.checkToken(request);
    }
}

拦截器注册 WebConfig

package com.smartMap.media.common.config;

import com.smartMap.media.common.apiIdempotent.interceptor.ApiIdempotentInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @description
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private ApiIdempotentInterceptor apiIdempotentInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(apiIdempotentInterceptor);
    }
}

测试验证 controller

package com.smartMap.media.modules.mobile.controller;

import com.smartMap.media.common.apiIdempotent.annotation.ApiIdempotent;
import com.smartMap.media.common.apiIdempotent.service.ApiIdempotentTokenService;
import com.smartMap.media.common.utils.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @description
 */
@RestController
@RequestMapping("/mobile/test")
public class TestController {

    @Autowired
    private ApiIdempotentTokenService apiIdempotentTokenService;

    /**
     * 获取token
     * @return
     */
    @RequestMapping("getToken")
    public R getToken() {
        return apiIdempotentTokenService.createToken();
    }
    
    /**
     * 测试接口幂等性, 在需要幂等性校验的方法上声明此注解即可
     * @return
     */
    @ApiIdempotent
    @RequestMapping("testIdempotence")
    public R testIdempotence() {
        return R.ok("测试接口幂等性");
    }
}

1、获取token
在这里插入图片描述
2、查看redis
在这里插入图片描述
3、利用jmeter测试工具模拟200个并发请求, 将上一步获取到的token作为参数
找到jmeter的文件夹
https://www.pianshen.com/article/37281737063/
在这里插入图片描述
打开终端，输入open /Users/hawk/Desktop/apache-jmeter-5.2.1/bin/jmeter
启动jmeter
在这里插入图片描述
表示在1秒内将“线程数：200”全部启动，循环次数是1
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
4、header或参数均不传token, 或者token值为空, 或者token值乱填, 均无法通过校验, 如token值为"123456"
在这里插入图片描述
在这里插入图片描述
注意点(非常重要)
在这里插入图片描述
上图中, 不能单纯的直接删除token而不校验是否删除成功, 会出现并发安全性问题, 因为, 有可能多个线程同时走到第51行, 此时token还未被删除, 所以继续往下执行, 如果不校验redisUtil.del(token)的删除结果而直接放行, 那么还是会出现重复提交问题, 即使实际上只有一次真正的删除操作。

总结

通过拦截器加注解的方式，就不用写很多重复的代码啦。

悟空码字
关注
订单服务篇-使用Token机制解决接口幂等性
Simon的博客
07-21 1104
文章目录一、在何处使用二、怎么使用1.生成Token2.验证Token 一、在何处使用 二、怎么使用 1.生成Token //防重复令牌 String token = UUID.randomUUID().toString().replace("-", ""); orderConfirmVo.setOrderToken(token); //保存到redis redisTemplate.opsForValue().set(OrderConstant.USER_ORDER_TOKEN_PREFIX+
结合Redis基于Token机制处理接口幂等性问题
LY514094904的博客
08-15 847
拦截器会拦截请求，我们只需获取添加了自定义注解的接口即可，获取接口之后校验token令牌，如果存在则放行，不存在则说明多次发送参数相同的同一请求(注意：第一次发送请求时会从redis中删除token并放行，之后再次请求redis中将不存在该token)，从请求头或请求参数中获取token信息，如果没有获取token令牌，则抛出异常，说明token没有发送过来，接着判断token是否存在，如果不存在则不再往下进行逻辑处理如果存在则删除，下一次请求访问时就不用继续往下进行逻辑处理。
保证接口幂等性（token机制）
stu_kk的博客
04-29 1985
Token机制是实现接口幂等性的一种常见策略，本文实现了token机制的代码
幂等方案分析
最新发布
Haenu0317的博客
08-25 671
幂等是一个数学上的概念 f(n) = 1^ n 无论n为多少 f(n)的值永远为1在我们的编程中定义为:以SQL为例：此SQL无论执行多少次，虽然结果有可能出现不同，都不会对数据产生改变，具备幂等性。此SQL如果id或name有唯一性约束，多次操作只允许插入一条记录，则具备幂等性。如果不是，则不具备幂等性，多次操作会产生多条数据。此SQL无论执行多少次，对数据产生的影响都是相同的。具备幂等性。此SQL涉及到了计算，每次操作对数据都会产生影响。不具备幂等性。
token 方式处理接口幂等性
miniy
06-04 171
方式系统接口的重复调用，在分布式系统中A服务重复向B服务发送指令，导致B服务重复消费消息。 在单体系统中类似新增操作重复指令，导致系统参数多天重复数据。 方式一 数据库增加唯一索引，保证数据的唯一性方式二 接口增加幂等性校验 具体方式如下： ①定义注解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Docume...
Spring Boot + Token 实现接口幂等性 | 防止表单重复提交
骏马逸动，心随你动的博客
08-16 7392
一、概念 幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次 比如: 订单接口, 不能多次创建订单 支付接口, 重复支付同一笔订单只能扣一次钱 支付宝回调接口, 可能会多次回调, 必须处理重复回调 普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次 等等 二、常见解决方案 唯一索引 -- 防止新增脏数...
接口幂等性解决方案：基于token实现接口幂等的落地实现
秃了也弱了
08-21 1792
接口的幂等性——详细谈谈接口的幂等即解决方案通过token机制来保证幂等是一种非常常见的解决方案，同时也适合绝大部分场景。该方案需要前后端进行一定程度的交互来完成。1）服务端提供获取token接口，供客户端进行使用。服务端生成token后，如果当前为分布式架构，将token存放于redis中，如果是单体架构，可以保存在jvm缓存中。2）当客户端获取到token后，会携带着token发起请求。3）服务端接收到客户端请求后，首先会判断该token在redis中是否存在。
接口幂等性校验（使用拦截器+自定义注解+redis解决问题）
qq_42926855的博客
02-13 1713
使用 拦截器+自定义注解+redis解决接口幂等性问题
接口幂等性 token机制(防重令牌) 基于springboot2 redis实现 请提供示例代码
tanwu1的博客
12-07 586
在基于Spring Boot 2和Redis实现防重令牌的幂等性控制时，你可以使用Redis存储令牌信息，并在接口请求时验证令牌的有效性。检查令牌的有效性，如果有效则处理业务逻辑，然后可以选择将令牌从Redis中删除，确保同一个令牌在有效期内只能使用一次。请注意，这只是一个简单的示例，实际应用中可能需要根据具体业务需求进行更详细的处理。在这个例子中，当客户端发起一个请求时，需要携带一个令牌。在你的Controller中，你可以使用。在Controller中，首先通过。
幂等校验是什么意思_接口的幂等性怎么设计？
weixin_30824577的博客
01-28 4914
点击上方IT牧场，选择置顶或者星标技术干货每日送达自己最近负责的几个接口，都涉及到了幂等性的操作，抽空总结了一下，这也是面试官比较爱问的问题。一、什么是幂等？看一下维基百科怎么说的：幂等性：多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。二、使用幂等的场景1、前端重复提交用户注册，用户创建商品等操作，前端都会提交一些数据给后台服务，后台需要根据用户...
【SpringBoot】基于自定义注解实现接口幂等性方法
弱水提沧的博客
03-02 2618
近期需要对接口进行幂等性的改造，特此记录下。 一、背景 在微服务架构中，幂等是一致性方面的一个重要概念。一个幂等操作的特点是指其多次执行所产生的影响均与一次执行的影响相同。在业务中也就是指的，多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。 二、常见场景 1.用户重复操作 在产品订购下单过程中，由于网络延迟或者用户误操作等原因，导致多次提交。这时就会在后台执行多条重复请求，导致脏数据或执行错误等。 2.分布式消息重复消费 消息队列中由于某种原因消息二次发送或者
token与幂等性问题
weixin_56777219的博客
06-11 1075
token
Redis +Token 实现接口幂等性
热门推荐
xueguchen的博客
03-01 2万+
1.幂等性 幂等：任意多次执行所产生的影响均与一次执行的影响相同 接口幂等性： 在HTTP/1.1中，对幂等性进行了定义。它描述了一次和多次请求某一个资源对于资源本身应该具有同样的结果（网络超时等问题除外），即第一次请求的时候对资源产生了副作用，但是以后的多次请求都不会再对资源产生副作用。 即，任意多次执行对资源本身所产生的影响均与一次执行的影响相同 2.非幂等操作的问题 前端重复提交表单 恶意刷单 接口超时重复提交：很多时候 HTTP 客户端工具都默认开启超时重试的机制，尤其是第三方调用接口时候，为了防
防重 Token 令牌如何实现幂等性？
Leon_Jinhai_Sun的博客
04-24 1581
针对客户端连续点击或者调用方的超时重试等情况，例如提交订单，此种操作就可以用Token的机制实现防止重复提交。 简单的说就是调用方在调用接口的时候先向后端请求一个全局 ID（Token），请求的时候携带这个全局 ID 一起请求（Token 最好将其放到 Headers 中），后端需要对这个 Token 作为 Key，用户信息作为 Value 到 Redis 中进行键值内容校验，如果 Key 存在且 Value 匹配就执行删除命令，然后正常执行后面的业务逻辑。如果不存在对应的 Key 或 Value 不..
Redis+token实现接口幂等性
weixin_40598838的博客
06-13 1171
在秒杀场景或情况下，用户多次发送请求会导致订单表中有多条数据的情况，为此要实现的功能是接口幂等，
Redis+token机制实现幂等性操作
红烧大熊猫的博客
01-08 3913
Redis+Token机制实现幂等性操作 前言  使用redis+token实现幂等性操作，防止表单的重复提交和一些其他重复请求操作。有些接口需要保证操作的唯一性，比如：订单接口（重复点击下单，只会生成一个订单号）；支付接口（重复支付也只会扣一次款）；表单接口等等… 一、实现幂等性操作的方法 唯一索引 – 防止新增脏数据 token机制 – 防止页面重复提交 悲观锁 – 获取数据的时候加锁(锁表...
Spring Boot+Redis 扛住，瞬间千次重复提交
KHOST的博客
06-23 875
作者：慕容千语 来源：http://suo.im/5PaEZI 前言: 在实际的开发项目中，一个对外暴露的接口往往会面临，瞬间大量的重复的请求提交，如果想过滤掉重复请求造成对业务的伤害，那就需要实现幂等！ 我们来解释一下幂等的概念： 任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是 对数据库的影响只能是一次性的，不能重复处理。 如何保证其幂等性，通常有以下手段： 1、数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据2、token机制，每次接口请...
使用防重Token的接口幂等性校验
weixin_54174344的博客
12-18 531
使用防重token的好处：可扩展性好：使用注解，对于有注解标记的接口拦截器才会起作用。工作过程：1进入下单界面，前端会自动发请求，后端产生token返回前端，并将token存于redis中2用户点击“下单”，由于网络原因，点击多次发送多次请求3拦截器会拦截所有请求，只有成功删除redis中token的请求，才能进入“下单接口”，在数据库中创建订单。
评论 18
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悟空码字

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

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

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

打赏作者

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

抵扣说明：

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

余额充值