现在继续讲一讲保证接口的幂等性——使用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";
}
}
4. 接口测试
先发送创建Token请求
没有设置token校验的接口,可以重复请求
设置了token校验的接口,我们来试一试:
(没配置token请求头,就会报错说token不存在)
(带上token)
(第一次请求得到响应数据)
(第二次提示重复操作)
到此,我们完成了整个token机制保证接口幂等性的代码开发,在订单创建、支付的时候很适合用!结束!