保证接口幂等性（token机制）

最新推荐文章于 2024-05-13 14:20:46 发布

stu_kk

最新推荐文章于 2024-05-13 14:20:46 发布

阅读量1.4k

点赞数 47

分类专栏： Java开发文章标签： spring java web安全

本文链接：https://blog.csdn.net/m0_54409739/article/details/138295529

版权

Java开发专栏收录该内容

42 篇文章 1 订阅

订阅专栏

现在继续讲一讲保证接口的幂等性——使用token机制，并编写代码实现！

1. 概念

Token机制是实现接口幂等性的一种常见策略，尤其是在处理如订单创建、支付确认等敏感操作时，确保即使用户因网络延迟、误操作等原因重复提交请求，系统也能保证结果的一致性，避免产生多次订单、多次扣款等问题。

2. Token机制的实现原理

1. 生成Token：在客户端首次发起请求之前，服务端为该特定操作生成一个唯一的Token（通常是一个随机字符串）。这个Token需要具备不可预测性和时效性，以确保安全性。
2. 传递Token：生成的Token随初始请求一起发送给客户端，客户端在后续的相同操作请求中携带此Token。
3. 存储Token：服务端接收到Token后，将其存储在一个全局可访问的地方，如Redis数据库，键值对形式存储，键通常是Token值，值可以是操作标识或者过期时间等元数据。
4. 验证Token：当客户端再次发起相同的请求时，必须包含第一次请求时获得的Token。服务端接收请求后，首先检查提供的Token是否有效（比如是否存在于Redis中，是否过期）。
5. 执行操作与删除Token：如果Token有效，服务端执行请求对应的业务逻辑一次，并在操作完成后从存储中移除或标记Token为已使用，防止同一Token被再次使用。
6. 幂等性保障：如果因为网络重传或其他原因导致相同的请求再次到达，由于Token已经被验证并处理过，服务端将识别出重复请求，并直接返回第一次操作的结果或告知请求已经处理，从而保证接口的幂等性。

具体时序历程图如下：

3. 代码实现

1.创建一个spring boot项目来实现吧，引入依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

    </dependencies>

2. 编写RedisService.java，实现Redis保存Token、删除Token以及判断是否存在等操作。

package org.example;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

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

/**
 * @Author: stukk
 * @Description: Redis业务方法类
 * @DateTime: 2024-04-29 16:13
 **/
@Service
public class RedisService {

    @Resource
    private RedisTemplate redisTemplate;

    public Boolean set(String key, Object value, Long times) {
        Boolean result = false;
        try {
            ValueOperations ops = redisTemplate.opsForValue();
            ops.set(key,value);
            redisTemplate.expire(key,times, TimeUnit.SECONDS);
            result = true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }

    public Boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    public Boolean remove(String key) {
        if(exists(key)){
            return redisTemplate.delete(key);
        }
        return false;
    }


}

3. 编写TokenService.java，创建Token还有检查请求头是否携带token

package org.example;

import io.netty.util.internal.StringUtil;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

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

/**
 * @Author: stukk
 * @Description: Token 业务类
 * @DateTime: 2024-04-29 16:31
 **/
@Service
public class TokenService {


    @Resource
    private RedisService redisService;

    /**
     * 创建Token
     * @return
     */
    public String createToken(){
        String uuid = UUID.randomUUID().toString();
        redisService.set(uuid,uuid,10000L);
        return uuid;
    }

    /**
     * 校验Token
     * @param request
     * @return
     */
    public Boolean checkToken(HttpServletRequest request){
        String token = request.getHeader("token");
        if(StringUtil.isNullOrEmpty(token)){
            throw new RuntimeException("token不存在");
        }
        if(!redisService.exists(token)){
            throw new RuntimeException("重复的操作");
        }
        Boolean remove = redisService.remove(token);
        if(!remove){
            throw new RuntimeException("重复的操作");
        }
        return true;
    }

}

4. 写一个注解Idempotence，用来在AOP中拦截请求进行token的校验。

package org.example.annotation;

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

/**
 * @Author: stukk
 * @Description:
 * @DateTime: 2024-04-29 17:19
 **/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotence {
    String value() default "";
}

package org.example.aop;

import org.example.servicve.TokenService;
import org.example.annotation.Idempotence;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

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

/**
 * @Author: stukk
 * @Description: 定义IdempotenceInterceptor拦截器
 * @DateTime: 2024-04-29 17:23
 **/
@Component
public class IdempotenceInterceptor implements HandlerInterceptor {

    @Resource
    private TokenService tokenService;

    /*
     * @Description: 拦截器
     * @Param: [request, response, handler]
     * @return: boolean
     **/
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if(!(handler instanceof HandlerMethod)){
            return true;
        }
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Idempotence idempotence = handlerMethod.getMethodAnnotation(Idempotence.class); //获取注解
        if(idempotence != null){
            return tokenService.checkToken(request);
        }
        return true;
    }

}

注册拦截器

package org.example.config;

import org.example.aop.IdempotenceInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * @Author: stukk
 * @Description: 注册拦截器
 * @DateTime: 2024-04-29 18:17
 **/
@Configuration
public class IdempotenceConfig implements WebMvcConfigurer {

    @Resource
    private IdempotenceInterceptor idempotenceInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(idempotenceInterceptor)
                .addPathPatterns("/**");
    }
}

5. 编写接口测试

先编写一个简单的全局异常处理器

package org.example.aop;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;


/**
 * 全局异常处理器
 *
 * @author stukk
 */
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(RuntimeException.class)
    public Object runtimeExceptionHandler(RuntimeException e) {
        return e.getMessage();
    }
}

测试接口如下：

package org.example.controller;

import org.example.TokenService;
import org.example.annotation.Idempotence;
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;

import javax.annotation.Resource;

/**
 * @Author: stukk
 * @Description:
 * @DateTime: 2024-04-29 17:47
 **/
@RestController
public class TestController {

    @Resource
    private TokenService tokenService;

    @GetMapping("createToken")
    public String createToken() {
        return tokenService.createToken();
    }

    @GetMapping("test1")
    public String test1() {
        return "test1";
    }

    @GetMapping("test2")
    @Idempotence
    public String test2() {
        return "test2";
    }

}