SpringBoot+自定义注解+拦截器实现接口幂等性问题

最新推荐文章于 2022-07-19 16:05:25 发布
最新推荐文章于 2022-07-19 16:05:25 发布
阅读量437 收藏 2
点赞数 3
分类专栏： SpringBoot 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Curtisjia/article/details/113447718
版权

前言

这是一个老生常谈的话题，关于如何实现接口幂等性，网上也给了好几个解决方案：

  1. 数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据
  2. token 机制，每次接口请求前先获取一个 token，然后再下次请求的时候在请求的 header 体中加上这个 token，后台进行验证，如果验证通过删除 token，下次请求再次判断 token
  3. 悲观锁或者乐观锁，悲观锁可以保证每次 for update 的时候其他 sql 无法 update 数据 (在数据库引擎是 innodb 的时候, select 的条件必须是唯一索引, 防止锁全表)

当然还有其他解决方案，我记得我之前看到的好像有七八种，但是重合性比较高，大致方向就是要么基于代码要么就是基于数据库的内部机制。

创建工程

创建一个springboot工程，导入依赖
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

配置文件

# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379

代码

RedisConfig.java

package com.example.demo.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 20:38
 */
@Configuration
public class RedisConfig
{
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
    {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

RedisService.java

package com.example.demo.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.concurrent.TimeUnit;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 19:51
 */
@Component
public class RedisService
{
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 写入缓存
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 写入缓存设置时效时间
     * @param key
     * @param value
     * @return
     */
    public boolean setEx(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 判断缓存中是否有对应的value
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 删除对应的value
     * @param key
     */
    public boolean remove(final String key) {
        if (exists(key)) {
            Boolean delete = redisTemplate.delete(key);
            return delete;
        }
        return false;

    }
}

自定义注解

package com.example.demo.annotation;

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

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoIdempotent
{
}

token校验服务
TokenService

package com.example.demo.service;

import javax.servlet.http.HttpServletRequest;

public interface TokenService
{
    /**
     * 创建token
     *
     * @return
     */
    String createToken();

    /**
     * 检验token
     *
     * @param request
     * @return
     */
    boolean checkToken(HttpServletRequest request) throws Exception;
}

实现类

package com.example.demo.service.impl;

import com.example.demo.constant.RedisConstant;
import com.example.demo.service.TokenService;
import com.example.demo.utils.RedisService;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.text.StrBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.UUID;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 19:54
 */
@Service
public class TokenServiceImpl implements TokenService
{
    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private RedisService redisService;

    @Override
    public String createToken()
    {
        String str = UUID.randomUUID().toString().replace("-", "");
        StrBuilder token = new StrBuilder();
        try
        {
            token.append(RedisConstant.TOKEN_PREFIX).append(str);
            redisService.setEx(token.toString(), token.toString(), 10000L);
            boolean notEmpty = StringUtils.isNotEmpty(token.toString());
            if (notEmpty)
            {
                return token.toString();
            }
        } catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public boolean checkToken(HttpServletRequest request) throws Exception
    {
        String token = request.getHeader(RedisConstant.TOKEN_NAME);
        if (StringUtils.isBlank(token))
        {
            // header中不存在token
            token = request.getParameter(RedisConstant.TOKEN_NAME);
            if (StringUtils.isBlank(token))
            {
                // parameter中也不存在token
                log.error("token为空！");
                return false;
            }
        }
        if (!redisService.exists(token))
        {
            log.error("token不存在！");
            return false;
        }
        boolean remove = redisService.remove(token);
        if (!remove)
        {
            log.error("移除失败！");
            return false;
        }
        return true;
    }
}

开始写拦截器

package com.example.demo.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

import javax.annotation.Resource;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 20:16
 */
@Configuration
public class WebConfiguration extends WebMvcConfigurationSupport
{
    @Resource
    private AutoIdempotentInterceptor autoIdempotentInterceptor;

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

package com.example.demo.config;

import com.example.demo.annotation.AutoIdempotent;
import com.example.demo.service.TokenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
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.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 20:17
 */
@Component
public class AutoIdempotentInterceptor implements HandlerInterceptor
{
    @Autowired
    private TokenService tokenService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
    {
        if (!(handler instanceof HandlerMethod))
        {
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        AutoIdempotent autoIdempotent = method.getAnnotation(AutoIdempotent.class);
        if (autoIdempotent != null)
        {
            try
            {
                return tokenService.checkToken(request);// 幂等性校验, 校验通过则放行, 校验失败则抛出异常, 并通过统一异常处理返回友好提示
            } catch (Exception ex)
            {
                throw ex;
            }
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception
    {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception
    {

    }
}

定义常量

package com.example.demo.constant;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 20:02
 */
public class RedisConstant
{
    public static final String TOKEN_PREFIX="tk";
    public static final String TOKEN_NAME ="token";
}

控制器

package com.example.demo.controller;

import com.example.demo.annotation.AutoIdempotent;
import com.example.demo.service.TokenService;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * @author 朝花不迟暮
 * @version 1.0
 * @date 2021/1/30 20:24
 */
@RestController
public class BusinessController
{
    @Autowired
    private TokenService tokenService;

    @PostMapping("/get/token")
    public String getToken()
    {
        String token = tokenService.createToken();
        if (StringUtils.isNotEmpty(token))
        {
            return token;
        }
        return StringUtils.EMPTY;
    }

    @AutoIdempotent
    @GetMapping("/test/Idempotence")
    public String testIdempotence(HttpServletRequest req)
    {
        return "aaa！";
    }
}

测试效果

启动项目，打开postman，请求 http://127.0.0.1:8080/get/token 获取token
在这里插入图片描述
请求 http://127.0.0.1:8080/test/Idempotence
在这里插入图片描述
请求，返回结果说明通过，一旦成功，存到redis里的token就会被删掉，这样一个token对应一个请求，下一个请求要想进来就得重新申请一个token，这就是接口的保护机制！

总结

在一些传递重要数据的接口上，实现接口幂等性是十分重要的，要保证一个请求只能影响一次数据以防止脏乱数据的产生，并且可以防止一定的并发量，所以这样做是有必要的。而且通过自定义接口，提高了功能伸缩性，更值得提倡，学会（废）了吗？
源码地址：https://gitee.com/thirtyleo/java_training_ground/tree/master/MiDeng
球球给个star吧！在这里插入图片描述

朝花不迟暮
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分布式服务 API 的幂等设计方案 & Spring Boot + Redis 拦截器实现实例
禅与计算机程序设计艺术
03-31 8511
什么是幂等？简单讲，幂等性是指相同的参数调用同一个 API，执行一次或多次效果一样。在函数式编程里面，这叫“无副作用”，Pure Function。用业务的语言将，就是：对于同一笔业务操作...
Spring Boot + Redis 实现接口幂等性 | 分布式开发必知！
程序猿DD
08-11 1395
点击蓝色“程序猿DD”关注我回复“资源”获取独家整理的学习资料！来源：http://tinyurl.com/y5k2sx5t>>阿里云8月最新优惠，点击查看&...
如何保证幂等性及解决方案
疯一样的女子
08-30 4692
一、概念 幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次，比如: 订单接口, 不能多次创建订单 支付接口, 重复支付同一笔订单只能扣一次钱 支付宝回调接口, 可能会多次回调, 必须处理重复回调 普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次 等等 二、常见解决方案 唯一...
通过redis实现SpringBoot接口幂等性的自定义注解
weixin_45357745的博客
07-19 663
通过自定义注解实现接口的幂等性，亲测可用
SpringBoot+Redis幂等性拦截
清华大咖
08-26 293
在实际的开发项目中,一个对外暴露的接口往往会面临很多次请求，我们来解释一下幂等的概念：任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是 对数据库的影响只能是一次性的，不能重复处理。如何保证其幂等性，通常有以下手段： 数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据create unique index uniqueName on tableName(f...
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
内容概要：springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用...
SpringBoot使用自定义注解实现权限拦截的示例
08-29
SpringBoot 使用自定义注解实现权限拦截的示例 在本篇文章中，我们将介绍如何使用 SpringBoot 框架使用自定义注解实现权限拦截的示例。权限拦截是指在用户请求资源时，服务器端对用户的请求进行检查和验证，以确保...
java SpringBoot自定义注解,及自定义解析器实现对象自动注入操作
08-24
Java SpringBoot 自定义注解及自定义解析器实现对象自动注入操作 在 Java SpringBoot 框架中，自定义注解和自定义解析器是非常重要的概念，它们可以帮助开发者轻松地实现对象自动注入操作。下面，我们将详细介绍 ...
springboot通过自定义注解完成简单的权限认证.zip
10-11
springboot自定义注解的demo;通过本案例实现了通过自定义注解的拦截的方法可以设置访问权限;通过拦截器获取指定方法上的自定义的注解,然后判断当前的接口需不要权限校验;然后通过对应的访问去处理;demo里面的代码...
SpringBoot-自定义注解AOP实现及拦截器示例
最新发布
04-12
SpringBoot-自定义注解AOP实现及拦截器示例代码
Spring Boot通过Redis和自定义注解实现api幂等处理
henry的博客
07-04 1570
1、简述 为了实现同一时间段，同样的请求（请求url和请求参数相同），只能成功一次，其余被拒绝，需实现幂等处理。 本示例实现原理： 通过自定义注解并配合切点切面实现请求验证功能。其中验证功能通过redis实现，当第一次获取请求时，根据请求url、controller层调用方法、请求参数生成MD5值，将其作为redis的key和value值，并设置失效时间，当在失效时间之内再次请求时，根据是否...
Redis处理 Spring Boot 接口幂等性【使用拦截器处理版本】
泠青沼
03-22 930
接口幂等性就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。举个最简单的例子，支付操作，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额返发现多扣钱了，流水记录也变成了两条，这就是没能保证接口的幂等性
【转载】Springboot 使用redis实现接口幂等性拦截
t194978的博客
07-10 630
2
Springboot + redis + 注解 + 拦截器来实现接口幂等性校验
xmt1139057136的专栏
01-03 927
一、概念幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次比如:订单接口, 不能多次创建订单支付接口, 重复支付同一笔订单只能扣一次钱支付宝回调接口, 可能...
springboot + redis +拦截器 实现接口幂等性校验
weixin_41988875的博客
11-01 361
一、概念 幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次 比如: 订单接口, 不能多次创建订单 支付接口, 重复支付同一笔订单只能扣一次钱 支付宝回调接口, 可能会多次回调, 必须处理重复回调 普通表单提交接口, 因为网络超时等原因多次点击提交, 只能成功一次 二、常见解决方案 唯一索引 – 防止新增脏数据 token机制 – 防止页面重复提交 悲观锁 – 获取数...
【SpringBoot】基于自定义注解实现接口幂等性方法
弱水提沧的博客
03-02 2453
近期需要对接口进行幂等性的改造，特此记录下。 一、背景 在微服务架构中，幂等是一致性方面的一个重要概念。一个幂等操作的特点是指其多次执行所产生的影响均与一次执行的影响相同。在业务中也就是指的，多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。 二、常见场景 1.用户重复操作 在产品订购下单过程中，由于网络延迟或者用户误操作等原因，导致多次提交。这时就会在后台执行多条重复请求，导致脏数据或执行错误等。 2.分布式消息重复消费 消息队列中由于某种原因消息二次发送或者
springboot拦截器获取接口返回值_springboot+redis+拦截器，实现接口幂等性校验
weixin_39597636的博客
01-25 717
wangzaiplushttps://www.jianshu.com/p/6189275403ed文中的图片如看不清，请点击阅读原文查看！！一、概念幂等性, 通俗的说就是一个接口, 多次发起同一个请求, 必须保证操作只能执行一次比如:订单接口, 不能多次创建订单支付接口, 重复支付同一笔订单只能扣一次钱支付宝回调接口, 可能会多次回调, 必须处理重复回调普通表单提交接口, 因为网络超时等...
springboot + mybatis 拦截器
08-20
在SpringBoot中使用Mybatis拦截器的方法有三种。 第一种方法是在启动项目时不会自动调用自定义拦截器的setProperties方法。可以通过在SpringBoot的配置类中使用@Bean注解进行配置。 第二种方法是在Mybatis核心...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值