采用redistoken,分布式锁的接口幂等性实现

每一次进行幂等校验之前先获取token&＃xff0c;因为token的时效性只有1次&＃xff0c;我们每次获得的token在幂等操作后就无效了&＃xff0c;所以一个token不需要长期保存在redis中。

&＃64;RestController
public class TokenController {&＃64;Autowired
private RedisService redisService;
&＃64;GetMapping("/users-anon/gettoken")public Map getToken(&＃64;RequestParam("url") String url) {Map,String> tokenMap &＃61; new HashMap();
String tokenValue &＃61; UUID.randomUUID().toString();
tokenMap.put(url &＃43; tokenValue, tokenValue);
redisService.set(url &＃43; tokenValue, tokenValue);
return tokenMap;
}
}

获取token后&＃xff0c;访问该url的接口&＃xff0c;此时我们使用拦截器进行拦截(/add/**可表示为所有有新增操作的接口)

&＃64;SpringBootConfiguration
public class TokenInterceptorConfig extends WebMvcConfigurerAdapter {&＃64;Autowired
private TokenInterceptor tokenInterceptor;

&＃64;Override
public void addInterceptors(InterceptorRegistry registry) {registry.addInterceptor(tokenInterceptor).addPathPatterns("/add/**");
}
}

拦截器的具体内容为

&＃64;Slf4j
&＃64;Component
public class TokenInterceptor implements HandlerInterceptor {&＃64;Autowired
private RedisService redisService;
&＃64;Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {String tokenName &＃61; request.getRequestURI() &＃43; request.getParameter("token_value");
String tokenValue &＃61; request.getParameter("token_value");
if (tokenValue !&＃61; null && !tokenValue.equals("")) {log.info("tokenName:{},tokenValue:{}",tokenName,tokenValue);
return handleToken(request,response,handler);
}return false;
}&＃64;Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, &＃64;Nullable ModelAndView modelAndView) throws Exception {if (redisService.exists(request.getParameter("token_value"))) {RedisTool.releaseDistributedLock(redisService, request.getParameter("token_value"), request.getParameter("token_value"));
}}&＃64;Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, &＃64;Nullable Exception ex) throws Exception {}/**
* 分布式锁处理
* &＃64;param request
* &＃64;param response
* &＃64;param handler
* &＃64;return
* &＃64;throws Exception
*/
private boolean handleToken(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//当大量高并发下所有带token参数的请求进来时&＃xff0c;进行分布式锁定,允许某一台服务器的一个线程进入&＃xff0c;锁定时间3分钟
if (RedisTool.tryGetDistributedLock(redisService,request.getParameter("token_value"),request.getParameter("token_value"),180)) {if (redisService.exists(request.getRequestURI() &＃43; request.getParameter("token_value"))) {//当请求的url与token与redis中的存储相同时
if (redisService.get(request.getRequestURI() &＃43; request.getParameter("token_value")).equals(request.getParameter("token_value"))) {//放行的该线程删除redis中存储的token
redisService.del(request.getRequestURI() &＃43; request.getParameter("token_value"));
//放行
return true;
}}//当请求的url与token与redis中的存储不相同时&＃xff0c;解除锁定
RedisTool.releaseDistributedLock(redisService,request.getParameter("token_value"),request.getParameter("token_value"));
//进行拦截
return false;
}return false;
}

直到后续controller操作执行完毕后释放分布式锁,见postHandle。

分布式锁的具体实现为

package com.cloud.user.config.redis;

/**
* Created by Administrator on 2018-08-05.
*/
public class RedisTool {private static final String LOCK_SUCCESS &＃61; "OK";
private static final Long RELEASE_SUCCESS &＃61; 1L;
/**
* 尝试获取分布式锁
* &＃64;param lockKey 锁
* &＃64;param requestId 请求标识
* &＃64;param expireTime 超期时间
* &＃64;return 是否获取成功
*/
public static boolean tryGetDistributedLock(RedisService redisService, String lockKey, String requestId, int expireTime) {String result &＃61; redisService.set(lockKey, requestId, expireTime);

if (LOCK_SUCCESS.equals(result)) {return true;
}return false;
}/**
* 释放分布式锁
* &＃64;param lockKey 锁
* &＃64;param requestId 请求标识
* &＃64;return 是否释放成功
*/
public static boolean releaseDistributedLock(RedisService redisService, String lockKey, String requestId) {Object result &＃61; redisService.eval(lockKey,requestId);

if (RELEASE_SUCCESS.equals(result)) {return true;
}return false;

}
}

在RedisServiceImpl实现类中&＃xff0c;以上set跟eval的具体实现为

private static final String SET_IF_NOT_EXIST &＃61; "NX";
private static final String SET_WITH_EXPIRE_TIME &＃61; "PX";
&＃64;Autowired
private JedisPool jedisPool;public T execute(RedisFunction fun) {Jedis jedis &＃61; null;try {jedis &＃61; jedisPool.getResource();return (T)fun.callback(jedis);}catch (Exception e) {logger.error(e.getMessage());return null;}finally {if (jedis !&＃61; null) {jedis.close();}}
}

&＃64;Override
public String set(String lockKey, String requestId, int expireTime) {return execute(new RedisFunction, Jedis>() {&＃64;Override
public String callback(Jedis jedis) {return jedis.set(lockKey,requestId,SET_IF_NOT_EXIST,SET_WITH_EXPIRE_TIME,expireTime);
}});
}

&＃64;Override
public Object eval(String lockKey, String requestId) {return execute(new RedisFunction, Jedis>() {&＃64;Override
public Object callback(Jedis jedis) {String script &＃61; "if redis.call(&＃39;get&＃39;, KEYS[1]) &＃61;&＃61; ARGV[1] then return redis.call(&＃39;del&＃39;, KEYS[1]) else return 0 end";
return jedis.eval(script, Collections.singletonList(lockKey),Collections.singletonList(requestId));
}});
}

public interface RedisFunction {Object callback(E jedis);
}

最后解释一下为什么在分布式锁中不直接使用setnx&＃43;expire来设置分布式锁&＃xff0c;而使用set(key,value,"NX","PX",过期时间)来做分布式锁&＃xff0c;因为你鬼知道它在执行setnx的时候是不是刚好系统崩溃了&＃xff0c;这样expire就未执行&＃xff0c;结果大家都清楚这个分布式锁就永远锁定了。