SpringBoot + Redis +注解＋拦截器来实现接口幂等性校验

最新推荐文章于 2023-11-28 09:55:30 发布
最新推荐文章于 2023-11-28 09:55:30 发布
阅读量279 收藏 1
点赞数
分类专栏： 技术问题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qflyit/article/details/108620282
版权

概念

幂等性,通俗的说就是一个接口,多次发起同一个请求,必须保证操作只能执行一次

比如:
订单接口, 不能多次创建订单
支付接口, 重复支付同一笔订单只能扣一次钱
支付宝回调接口, 可能会多次回调, 必须处理重复回调
普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次等等

常见解决方案

1.唯一索引 – 防止新增脏数据
2.token机制 – 防止页面重复提交
3.悲观锁 – 获取数据的时候加锁(锁表或锁行)
4.乐观锁 – 基于版本号version实现, 在更新数据那一刻校验数据
5.分布式锁 – redis(jedis、redisson)或zookeeper实现
6.状态机 – 状态变更, 更新数据时判断状态

本文实现

本文采用第2种方式实现, 即通过redis + token机制实现接口幂等性校验

实现思路

为需要保证幂等性的每一次请求创建一个唯一标识token, 先获取token, 并将此token存入redis, 请求接口时, 将此token放到header或者作为请求参数请求接口, 后端接口判断redis中是否存在此token:

  • 如果存在, 正常处理业务逻辑, 并从redis中删除此token, 那么, 如果是重复请求, 由于token已被删除, 则不能通过校验, 返回请勿重复操作提示
  • 如果不存在, 说明参数不合法或者是重复请求, 返回提示即可

代码实现

pom

 <!-- Redis-Jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!--lombok 本文用到@Slf4j注解, 也可不引用, 自定义log即可-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
        </dependency>
        <!--对字符串进行一些处理、判断、截取-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

1.在发送需要校验的接口前先创建token

package com.wangzaiplus.test.controller;

import com.wangzaiplus.test.common.ServerResponse;
import com.wangzaiplus.test.service.TokenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/token")
public class TokenController {

    @Autowired
    private TokenService tokenService;

    @GetMapping
    public ServerResponse token() {
        return tokenService.createToken();
    }

}

2.真正需要请求的接口

package com.wangzaiplus.test.controller;

import com.wangzaiplus.test.annotation.ApiIdempotent;
import com.wangzaiplus.test.common.ServerResponse;
import com.wangzaiplus.test.service.TestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {

    @Autowired
    private TestService testService;

    @ApiIdempotent
    @PostMapping("testIdempotence")
    public ServerResponse testIdempotence() {
        return testService.testIdempotence();
    }

}

3.redis工具类

package com.example.demo.util;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import javax.annotation.Resource;

@Component
@Slf4j
public class JedisUtil {
    private static final Logger LOG = LoggerFactory.getLogger(JedisUtil.class);
    @Resource
    private JedisPool jedisPool;

    private Jedis getJedis() {
        return jedisPool.getResource();
    }

    /**
     * 设值
     *
     * @param key
     * @param value
     * @return
     */
    public String set(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.set(key, value);
        } catch (Exception e) {
            LOG.error("set key:{} value:{} error", key, value, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 设值
     *
     * @param key
     * @param value
     * @param expireTime 过期时间, 单位: s
     * @return
     */
    public String set(String key, String value, int expireTime) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.setex(key, expireTime, value);
        } catch (Exception e) {
            LOG.error("set key:{} value:{} expireTime:{} error", key, value, expireTime, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 取值
     *
     * @param key
     * @return
     */
    public String get(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.get(key);
        } catch (Exception e) {
            LOG.error("get key:{} error", key, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 删除key
     *
     * @param key
     * @return
     */
    public Long del(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.del(key.getBytes());
        } catch (Exception e) {
            LOG.error("del key:{} error", key, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 判断key是否存在
     *
     * @param key
     * @return
     */
    public Boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.exists(key.getBytes());
        } catch (Exception e) {
            LOG.error("exists key:{} error", key, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 设值key过期时间
     *
     * @param key
     * @param expireTime 过期时间, 单位: s
     * @return
     */
    public Long expire(String key, int expireTime) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.expire(key.getBytes(), expireTime);
        } catch (Exception e) {
            LOG.error("expire key:{} error", key, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 获取剩余时间
     *
     * @param key
     * @return
     */
    public Long ttl(String key) {
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.ttl(key);
        } catch (Exception e) {
            LOG.error("ttl key:{} error", key, e);
            return null;
        } finally {
            close(jedis);
        }
    }

    private void close(Jedis jedis) {
        if (null != jedis) {
            jedis.close();
        }
    }

}

4.自定义注解@ApiIdempotent

package com.example.demo.util;

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

/**
 * 在需要保证 接口幂等性 的Controller的方法上使用此注解
 * 自定义注解@ApiIdempotent
 */
@Target({ElementType.METHOD})   //用于修饰方法
@Retention(RetentionPolicy.RUNTIME) //注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在；
public @interface ApiIdempotent {
}

5.ApiIdempotentInterceptor拦截器

package com.example.demo.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

/**
 * 接口幂等性拦截器
 */
public class ApiIdempotentInterceptor implements HandlerInterceptor {

    @Autowired
    private TokenService tokenService;

    @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);//得到方法上的注解 @ApiIdempotent
        //控制层方法上有 @ApiIdempotent注解就需要进行幂等性校验
        if (methodAnnotation != null)
        {
            check(request);// 幂等性校验, 校验通过则放行, 校验失败则抛出异常, 并通过统一异常处理返回友好提示
        }

        return true;
    }

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

    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    }
}

6.TokenServiceImpl 用来创建token和校验token的具体实现

package com.example.demo.util;


import com.example.demo.exception.ServiceException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;

@Service
public class TokenServiceImpl implements TokenService {

    private static final String TOKEN_NAME = "token";

    @Autowired
    private JedisUtil jedisUtil;


    @Override
    public ServerResponse createToken() {
        String str = RandomUtil.UUID32();
        StringBuilder token = new StringBuilder();
        token.append(Constant.Redis.TOKEN_PREFIX).append(str);//创建token

        jedisUtil.set(token.toString(), token.toString(), Constant.Redis.EXPIRE_TIME_MINUTE);//将token放入redis

        return ServerResponse.success(token.toString());
    }

    @Override
    public void checkToken(HttpServletRequest request) {
        String token = request.getHeader(TOKEN_NAME);
        //判断请求头中是否有token
        if (StringUtils.isBlank(token)) {// header中不存在token  isBlank：判断字符对象是否为空，为空返回true
            //判断是否在请求参数中
            token = request.getParameter(TOKEN_NAME);
            if (StringUtils.isBlank(token)) {// parameter中也不存在token
                throw new ServiceException(ResponseCode.ILLEGAL_ARGUMENT.getMsg());
            }
        }

        if (!jedisUtil.exists(token)) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }

        Long del = jedisUtil.del(token);
        if (del <= 0) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
    }
}

7.注册拦截器

package com.example.demo;

import com.example.demo.util.ApiIdempotentInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
@MapperScan("com.example.mapper")
@EnableScheduling
public class DemoApplication extends WebMvcConfigurerAdapter {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
    /**
     * 跨域
     * @return
     */
    @Bean
    public CorsFilter corsFilter() {
        final UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
        final CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
        return new CorsFilter(urlBasedCorsConfigurationSource);
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 接口幂等性拦截器
        registry.addInterceptor(apiIdempotentInterceptor());
        super.addInterceptors(registry);
    }

    @Bean
    public ApiIdempotentInterceptor apiIdempotentInterceptor() {
        return new ApiIdempotentInterceptor();
    }
}

具体文章请看：点击跳转.

未来可期MXH
关注
专栏目录
Spring Boot学习总结（21）——SpringBoot集成Redis等缓存以注解的方式优雅实现幂等，防千万次重复提交实例代码
科技D人生
04-02 2342
前言 在实际的开发项目中,一个对外暴露的接口往往会面临很多次请求，我们来解释一下幂等的概念：任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是 对数据库的影响只能是一次性的，不能重复处理。如何保证其幂等性，通常有以下手段： 数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据 token机制，每次接口请求前先获取一个token，然后再下次请求的时候在请求的he...
SpringBoot中接口幂等性实现方案-自定义注解+Redis+拦截器实现防止订单重复提交
BADAO_LIUMANG_QIZHI的博客
07-25 1898
以下接口幂等性的实现方式与上面博客类似，可参考。
springboot2.1+redis+拦截器 防止表单重复提交
10-05
springboot2.1+redis+拦截器 防止表单重复提交详细完整介绍，所用到的文件都上传了，下载即可使用。自己花了半天整理，并且测试通过，使用在实际项目中的，希望对每一个下载的朋友有帮助。
SpringBoot + Redis + 注解 + 拦截器来实现接口幂等性校验
程序员白楠楠的博客
09-14 193
一、概念 幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次 比如: 订单接口, 不能多次创建订单 支付接口, 重复支付同一笔订单只能扣一次钱 支付宝回调接口, 可能会多次回调, 必须处理重复回调 普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次 等等 二、常见解决方案 唯一索引 – 防止新增脏数据 token机制 – 防止页面重复提交 悲观锁 – 获取数据的时候加锁(锁表或锁行) 乐观锁 – 基于版本号version实现
SpringBoot---解决重复提交表单问题
本人随手记录，内容只是个人看懂程度，对内容有任何疑问请勿打扰
06-22 667
Web环境配置 很简单，只是为了测试。 <!DOCTYPE html> <html lang="en" xmlns:th="http://www.thymeleaf.org"> <head> <meta charset="utf-8"> <title>登录</title> </head> <form method="post" action="main.html" th:action="@{/ind
Java SpringBoot+Redis实现后端接口防重复提交校验
旭东怪的博客
06-20 2581
1 Maven依赖 <!--redis缓存--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> &lt
SpringBoot+Redis实现接口幂等性，就看这篇了
m0_55849656的博客
06-21 1065
幂等性的概念是，任意多次执行所产生的影响都与一次执行产生的影响相同，按照这个含义，最终的解释是对数据库的影响只能是一次性的，不能重复处理。
Spring Boot + Redis + 注解与拦截器实现接口幂等性校验
本文主要探讨了如何在Spring Boot应用中利用Redis和注解+拦截器来实现接口的幂等性校验。幂等性是一种设计原则，确保对于同一个请求，无论重复执行多少次，结果都保持一致，避免数据冗余或错误。常见的解决方案包括...
接口幂等性校验（使用拦截器+自定义注解+redis解决问题）
qq_42926855的博客
02-13 1713
使用 拦截器+自定义注解+redis解决接口幂等性问题
如何使用 SpringBoot + Redis 优雅的解决接口幂等性问题
十指波课堂的博客
08-27 488
# 前言在实际的开发项目中,一个对外暴露的接口往往会面临很多次请求，我们来解释一下幂等的概念：任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是 对数据库的影响只能是一次性的，不能重复处理。如何保证其幂等性，通常有以下手段：数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据token机制，每次接口请求前先获取一个token，然后再下次请求的时候在请求的header...
防重复提交方案
qq_37146354的博客
07-24 269
防重复提交方案 1.思路 因为服务端是使用Token来获取用户信息，没有对应的session管理机制，不能用sessionId加上用户请求的URL作为唯一标识。但是服务器中的userId是用雪花算法进行计算，能确保唯一性，所以我们选择用userId加上用户请求的URL作为用户请求的唯一标识。当用户请求POST、PUT、DELETE接口时，缓存用户的userId加上请求的地址，设置超时时间为2秒钟，...
springboot+拦截器实现接口幂等
最新发布
qiaoqianchuan的专栏
11-28 65
​​​/*** 用于拼接幂等性判断的key的入参字段* @return*//*** 用于接口幂等性校验的Redis中Key的过期时间，单位秒* @return*/​​​@Aspect@Component@Slf4j​@Resource​/**定义切入点*/​// 在进入controller 方法之前进行拦截i++) {if(!
系统幂等性设计与实践
u010960161的专栏
07-26 317
幂等性 什么是幂等性 HTTP/1.1中对幂等性的定义是：一次和多次请求某一个资源**对于资源本身**应该具有同样的结果（网络超时等问题除外）。也就是说，**其任意多次执行对资源本身所产生的影响均与一次执行的影响相同**。 简单来说，是指无论调用多少次都不会有不同结果的 HTTP 方法。 什么情况下需要幂等 业务开发中，经常会遇到重复提交的情况，无论是由于网络问题无法收到请求结果而重新发起请求，或是前端的操作抖动而造成重复提交情况。 在交易系统，支付系统这种重复提交造成的问题有尤其明显，比如：
幂等性注解，以及适配成启动类注解
人生到处知何似，应似飞鸿踏雪泥。
08-07 729
一. 前言： 在后端提供给前端接口之后，在某性场景下，如支付等。如果一个请求多次消费同一个接口，显然是错误的。这里显然就需要实现，多次消费和一次消费，是一样的结果了，这就和幂等性有关了。 二. 前后端未分离编写： 这由于架构的特殊性，小熙采用的是后端跳转页面并签发幂等性token，访问时再次校验。当然也有唯一索引、加锁、状态机等方法，看个人习惯吧。 创建幂等性注解 package com.chengxi.datalom.idempotent; import java.lang.annotation.E
Springboot + redis + 注解 + 拦截器来实现接口幂等性校验
春风化雨
06-13 1774
一、概念 幂等性：通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次。 场景举例: 1）订单接口, 不能多次创建订单 2）支付接口, 重复支付同一笔订单只能扣一次钱 3）支付宝回调接口, 可能会多次回调, 必须处理重复回调 4）普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次等等 二、常见解决方案 1）唯一索引 -- 防止新增脏数据 2）tok...
瞬间几千次的重复提交，我用 SpringBoot+Redis 扛住了
weixin_45727359的博客
03-23 312
作者 |慕容千语来源 |http://suo.im/5PaEZI在实际的开发项目中，一个对外暴露的接口往往会面临，瞬间大量的重复的请求提交，如果想过...
客户端 防止订单重复提交 接口处理
weixin_34044273的博客
11-13 243
2019独角兽企业重金招聘Python工程师标准>>> ...
springboot + redis +拦截器 实现接口幂等性校验
weixin_41988875的博客
11-01 388
一、概念 幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次 比如: 订单接口, 不能多次创建订单 支付接口, 重复支付同一笔订单只能扣一次钱 支付宝回调接口, 可能会多次回调, 必须处理重复回调 普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次 二、常见解决方案 唯一索引 – 防止新增脏数据 token机制 – 防止页面重复提交 悲观锁 – 获取数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值