接口幂等的涵义大致是：任意多次执行所产生的影响均与一次执行的影响是相同的。有很多的接口天然就是幂等的，比如删除操作，不管重复执行多少次同样的删除操作最终影响的结果是一致的。
实现接口幂等的方案还是挺多的，比如
- 基于乐观锁来实现幂等，次方案比较适合更新场景。比较简单的实现方式就是利用只能递增而不能减的 version （版本号）来实现。
- 基于表中唯一的标识ID来实现幂等，次方案比较适合新增的场景。新增一条记录时传唯一标识，如果是重复提交数据库会抛出异常。
- 基于悲观锁，这也比较适合更新场景，但是考虑到性能差操作不当还会锁表一般不推荐使用。
- 先查询后判断，首先通过查询数据库是否存在数据，若不存在则是第一次提交，放行。反之拒绝放行。此方案效率也偏低不推荐使用。
本文基于redis、token 实现接口幂等
不多说，咋们直接上代码吧。
安装redis 的步骤就暂且跳过吧，安装比较简单从官网下载然后解压就好了。
先看一下此方案的大致思路
（图片来源于网络，代码实现有很多种思路大致一致）
创建SpringBoot Demo 后添加依赖
<!-- Redis-Jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${jedis.version}</version>
</dependency>
<!--lombok @Slf4j注解-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.10</version>
</dependency>
<!-- commons-lang3 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.4</version>
</dependency>这个Demo 用到了一些工具类，下面一一列举。
- Jedis 工具类，用于操作redis.
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
/**
* @description: Jedis 工具类
* @author: x
* @create: 2020-06-04 11:09
**/
@Slf4j
@Component
public class JedisUtil {
@Autowired(required = false)
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();
}
}
}- RandomUtil 随机字符工具类 用于产生随机字符
import java.util.Random;
import java.util.UUID;
/**
* @description: 随机工具类
* @author: x
* @create: 2020-06-05 09:56
**/
public class RandomUtil {
public static final String ALL_CHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String LETTER_CHAR = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String NUMBER_CHAT = "0123456789";
public static String UUID32() {
String str = UUID.randomUUID().toString();
return str.replaceAll("-", "");
}
public static String UUID36() {
return UUID.randomUUID().toString();
}
/**
* 生成包含大、小写字母、数字的字符串
*
* @param length
* @return 如: zsK8rCCi
*/
public static String generateStr(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(ALL_CHAR.charAt(random.nextInt(ALL_CHAR.length())));
}
return sb.toString();
}
/**
* 生成纯数字字符串
*
* @param length
* @return 如: 77914
*/
public static String generateDigitalStr(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(NUMBER_CHAT.charAt(random.nextInt(NUMBER_CHAT.length())));
}
return sb.toString();
}
/**
* 生成只包含大小写字母的字符串
*
* @param length
* @return 如: XetrWaYc
*/
public static String generateLetterStr(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(LETTER_CHAR.charAt(random.nextInt(LETTER_CHAR.length())));
}
return sb.toString();
}
/**
* 生成只包含小写字母的字符串
*
* @param length
* @return 如: nzcaunmk
*/
public static String generateLowerStr(int length) {
return generateLetterStr(length).toLowerCase();
}
/**
* 生成只包含大写字母的字符串
*
* @param length
* @return 如: KZMQXSXW
*/
public static String generateUpperStr(int length) {
return generateLetterStr(length).toUpperCase();
}
/**
* 生成纯0字符串
*
* @param length
* @return 如: 00000000
*/
public static String generateZeroStr(int length) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < length; i++) {
sb.append('0');
}
return sb.toString();
}
/**
* 根据数字生成字符串，长度不够前面补0
*
* @param num 数字
* @param strLength 字符串长度
* @return 如: 00000099
*/
public static String generateStrWithZero(int num, int strLength) {
StringBuffer sb = new StringBuffer();
String strNum = String.valueOf(num);
if (strLength - strNum.length() >= 0) {
sb.append(generateZeroStr(strLength - strNum.length()));
} else {
throw new RuntimeException("将数字" + num + "转化为长度为" + strLength + "的字符串异常!");
}
sb.append(strNum);
return sb.toString();
}
}- Constant 常量管理工具类
/**
* @description: 常量管理
* @author: x
* @create: 2020-06-05 10:11
**/
public class Constant {
public interface Redis {
String OK = "OK";
Integer EXPIRE_TIME_MINUTE = 60;// 过期时间, 60s, 一分钟
Integer EXPIRE_TIME_HOUR = 60 * 60;// 过期时间, 一小时
Integer EXPIRE_TIME_DAY = 60 * 60 * 24;// 过期时间, 一天
String TOKEN_PREFIX = "token:";
}- 服务响应枚举类
/**
* 常用枚举
* @author x
*/
public enum ResponseCode {
// 系统模块
SUCCESS(0, "操作成功"),
ERROR(1, "操作失败"),
SERVER_ERROR(500, "服务器异常"),
// 通用模块
ILLEGAL_ARGUMENT(10000, "参数不合法"),
REPETITIVE_OPERATION(10001, "请勿重复操作"),
ACCESS_LIMIT(10002, "请求太频繁, 请稍后再试"),
MAIL_SEND_SUCCESS(10003, "邮件发送成功"),
// 用户模块
NEED_LOGIN(20001, "登录失效"),
USERNAME_OR_PASSWORD_EMPTY(20002, "用户名或密码不能为空"),
USERNAME_OR_PASSWORD_WRONG(20003, "用户名或密码错误"),
USER_NOT_EXISTS(20004, "用户不存在"),
WRONG_PASSWORD(20005, "密码错误"),
;
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;
}
}- ServiceException 异常类
/**
* @description: 异常类
* @author: x
* @create: 2020-06-05 10:11
**/
public class ServiceException extends RuntimeException{
private String code;
private String msg;
public ServiceException() {
}
public ServiceException(String msg) {
this.msg = msg;
}
public ServiceException(String code, String msg) {
this.code = code;
this.msg = msg;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}- ServerResponse 响应工具类
import com.fasterxml.jackson.annotation.JsonIgnore;
import java.io.Serializable;
/**
* @description: 服务响应工具类
* @author: x
* @create: 2020-06-04 11:09
**/
public class ServerResponse implements Serializable{
private static final long serialVersionUID = 7498483649536881777L;
private Integer status;
private String msg;
private Object data;
public ServerResponse() {
}
public ServerResponse(Integer status, String msg, Object data) {
this.status = status;
this.msg = msg;
this.data = data;
}
@JsonIgnore
public boolean isSuccess() {
return this.status.equals(ResponseCode.SUCCESS.getCode()) ;
}
public static ServerResponse success() {
return new ServerResponse(ResponseCode.SUCCESS.getCode(), null, null);
}
public static ServerResponse success(String msg) {
return new ServerResponse(ResponseCode.SUCCESS.getCode(), msg, null);
}
public static ServerResponse success(Object data) {
return new ServerResponse(ResponseCode.SUCCESS.getCode(), null, data);
}
public static ServerResponse success(String msg, Object data) {
return new ServerResponse(ResponseCode.SUCCESS.getCode(), msg, data);
}
public static ServerResponse error(String msg) {
return new ServerResponse(ResponseCode.ERROR.getCode(), msg, null);
}
public static ServerResponse error(Object data) {
return new ServerResponse(ResponseCode.ERROR.getCode(), null, data);
}
public static ServerResponse error(String msg, Object data) {
return new ServerResponse(ResponseCode.ERROR.getCode(), msg, data);
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
}工具类暂且就这么多了，下面开始核心代码吧！
1. 定义一个自定义注解
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @description: 自定义接口幂等注解
* @author: x
* @create: 2020-06-04 11:21
**/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {
}2. 创建token Service
这仅仅是一个简单的token 创建，具体可根据自己的项目的情况来生成token
接口
/**
* @description: token service
* @author: x
* @create: 2020-06-05 09:45
**/
public interface TokenService {
/** 创建token
* 返回 ServerResponse
* @return
*/
ServerResponse createToken();
/**
* 检查token
* @param request
*/
void checkToken(HttpServletRequest request);
}实现类
/**
* @description:
* @author: x
* @create: 2020-06-05 09:50
**/
@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();
StrBuilder token = new StrBuilder();
token.append(Constant.Redis.TOKEN_PREFIX).append(str);
jedisUtil.set(token.toString(), token.toString(), Constant.Redis.EXPIRE_TIME_MINUTE);
return ServerResponse.success(token.toString());
}
@Override
public void checkToken(HttpServletRequest request) {
String token = request.getHeader(TOKEN_NAME);
// header中不存在token
if (StringUtils.isBlank(token)) {
token = request.getParameter(TOKEN_NAME);
// parameter中也不存在token
if (StringUtils.isBlank(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());
}
}
}**3. 创建幂等接口拦截器 ApiIdempotentInterceptor **
/**
* @description: 幂等接口拦截器
* @author: x
* @create: 2020-06-05 09:22
**/
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);
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 {
}
}4. 配置jedisPool
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* @description: Jedis 配置
* @author: x
* @create: 2020-06-05 16:01
**/
@Configuration
public class JedisConfig {
@Value("${spring.redis.host}")
private String host;
@Value("${spring.redis.port}")
private int port;
@Value("${spring.redis.password}")
private String password;
@Value("${spring.redis.jedis.pool.max-idle}")
private int maxIdle;
@Value("${spring.redis.jedis.pool.max-wait}")
private long maxWait;
@Value("${spring.redis.jedis.pool.min-idle}")
private int minIdle;
@Value("${spring.redis.timeout}")
private int timeout;
@Bean
public JedisPool redisPoolFactory() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(maxIdle);
jedisPoolConfig.setMaxWaitMillis(maxWait);
jedisPoolConfig.setMinIdle(minIdle);
JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
return jedisPool;
}
}文件 application.properties
server.port=8069
# redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123456
spring.redis.jedis.pool.max-idle=32
spring.redis.jedis.pool.max-wait=-1
spring.redis.jedis.pool.min-idle=0
spring.redis.timeout=05. 测试服务
接口
/**
* @description: 测试service
* @author: x
* @create: 2020-06-05 11:22
**/
public interface TestService {
/**
* 幂等测试
* @return
*/
ServerResponse idempotentTestTest();
}实现类
/**
* @description:
* @author: x
* @create: 2020-06-05 11:28
**/
@Service
public class TestServiceImpl implements TestService {
@Override
public ServerResponse idempotentTestTest() {
return ServerResponse.success("idempotentTestTest: success");
}
}6. Token控制层 TokenController
**
* @description: Token controller
* @author: x
* @create: 2020-06-05 11:08
**/
@RestController
@RequestMapping("/token")
public class TokenController {
@Autowired
private TokenService tokenService;
@GetMapping
public ServerResponse token() {
return tokenService.createToken();
}
}7. 幂等测试Controller ApiIdempotentTestController
/**
* @description: 幂等性测试controller
* @author: x
* @create: 2020-06-05 11:14
**/
@RestController
@RequestMapping("/idempotent")
@Slf4j
public class ApiIdempotentTestController {
@Autowired
private TestService testService;
@ApiIdempotent
@PostMapping("/test")
public ServerResponse idempotentTest() {
return testService.idempotentTestTest();
}
}8. 启动类 配置跨域
/**
* @author
* demo 启动类
*/
@SpringBootApplication
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();
}
}启动测试
1. 先获取token
2. 再拿获取到的token 去请求接口
请求成功再点击一次请求（重复提交）
请求失败 我们可以细化异常类 让返回的信息提示重复提交
over
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
