lua脚本，确保原子性
--获取KEY
local key = KEYS[1]
--获取ARGV内的参数
local expire = tonumber(ARGV[1])
local count = tonumber(ARGV[2])
--获取key的次数
local current = redis.call('get', key)
--如果key的次数存在且大于预设值直接返回当前key的次数
if current and tonumber(current) > count then
return tonumber(current);
end
--进行自增
current = redis.call('incr', key)
--获取key的过期时间
local ttl = redis.call('ttl', key)
--如果是第一次自增，设置过期时间
if tonumber(current) == 1 then
redis.call('expire', key, expire)
else
--如果key过期时间是永久，重新设置过期时间
if ttl and tonumber(ttl) == -1 then
redis.call('expire', key, expire)
end
end
--返回key的次数
return tonumber(current)
限流注解
/**
* @desc 限流注解
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimiter {
/**
* 限流key
*/
String key() default "rate:limiter:";
/**
* 单位时间限制通过请求数
*/
long limit() default 1;
/**
* 过期时间，单位秒
*/
long expire() default 5;
/**
* 限流提示语
*/
String message() default "请勿重复提交";
}
限流处理器
/**
* 限流处理器
*/
@Slf4j
@Aspect
@Component
public class RateLimiterHandler {
@Qualifier(value = "limitRedisTemplate")
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@Autowired
private Environment env;
private DefaultRedisScript<Long> getRedisScript;
public static final String SYS_ENVIRONMENT_DEV = "dev";
@PostConstruct
public void init() {
getRedisScript = new DefaultRedisScript<>();
getRedisScript.setResultType(Long.class);
getRedisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/rateLimiter.lua")));
log.info("RateLimiterHandler[分布式限流处理器]脚本加载完成");
}
// a.b.c.RateLimiter根据自己项目实际包来设置
@Pointcut("@annotation(a.b.c.RateLimiter)")
public void rateLimiter() {
}
@Around("@annotation(rateLimiter)")
public Object around(ProceedingJoinPoint proceedingJoinPoint, RateLimiter rateLimiter) throws Throwable {
log.debug("RateLimiterHandler[分布式限流处理器]开始执行限流操作");
// 限流模块key
String ip = IPUtil.getIpAddress();
MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
Method method = signature.getMethod();
// 目标类、方法
String className = method.getDeclaringClass().getName();
String name = method.getName();
String ipKey = String.format("%s#%s", className, name);
int hashCode = Math.abs(ipKey.hashCode());
String limitKey = rateLimiter.key() + name + ":" + String.format("%s_%d", ip, hashCode);
if (env.acceptsProfiles(Profiles.of(SYS_ENVIRONMENT_DEV))) {
limitKey = "dev:" + limitKey;
}
// 限流阈值
long limitCount = rateLimiter.limit();
// 限流超时时间
long expireTime = rateLimiter.expire();
log.debug("RateLimiterHandler[分布式限流处理器]参数值为：method={},limitKey={},limitCount={},limitTimeout={}", name, limitKey, limitCount, expireTime);
// 执行Lua脚本
List<String> keyList = new ArrayList<>();
// 设置key值为注解中的值
keyList.add(limitKey);
// 调用脚本并执行
Long result = redisTemplate.execute(getRedisScript, keyList, expireTime, limitCount);
log.debug("RateLimiterHandler[分布式限流处理器]限流执行结果-result={}", result);
if (null != result && result > limitCount) {
log.debug("由于超过单位时间={}；允许的请求次数={}[触发限流]", expireTime, limitCount);
// 限流提示语
String message = rateLimiter.message();
throw new RuntimeException(message);
}
return proceedingJoinPoint.proceed();
}
}
redis配置
@Bean
public RedisTemplate<String, Object> limitRedisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
serializer.setObjectMapper(mapper);
template.setValueSerializer(serializer);
// 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer());
template.afterPropertiesSet();
return template;
}
ip工具类
public class IPUtil {
private static final Logger log = LoggerFactory.getLogger(IPUtil.class);
public static String getIpAddress() {
HttpServletRequest request = ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
String ip = null;
String ipAddresses = request.getHeader("X-Forwarded-For");
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ipAddresses = request.getHeader("Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ipAddresses = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ipAddresses = request.getHeader("HTTP_CLIENT_IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ipAddresses = request.getHeader("X-Real-IP");
}
if (ipAddresses != null && ipAddresses.length() != 0) {
ip = ipAddresses.split(",")[0];
}
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ip = request.getRemoteAddr();
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ipAddresses = request.getRemoteAddr();
if (ipAddresses.equals("127.0.0.1") || ipAddresses.equals("0:0:0:0:0:0:0:1")) {
//根据网卡取本机配置的IP
InetAddress inet = null;
try {
inet = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
log.error("获取ip失败 {}", Arrays.asList(e.getStackTrace()));
}
if (inet != null) {
ip = inet.getHostAddress();
} else {
ip = "127.0.0.1";
}
}
}
return ip;
}
}
网友评论