Spring Boot通过Redis和自定义注解实现api幂等处理

1、简述

为了实现同一时间段，同样的请求（请求url和请求参数相同），只能成功一次，其余被拒绝，需实现幂等处理。

本示例实现原理：

通过自定义注解并配合切点切面实现请求验证功能。其中验证功能通过redis实现，当第一次获取请求时，根据请求url、controller层调用方法、请求参数生成MD5值，将其作为redis的key和value值，并设置失效时间，当在失效时间之内再次请求时，根据是否已存在key值来判断接收还是拒绝请求来实现拦截。

2、pom.xml依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<exclusion>
			<groupId>io.lettuce</groupId>
			<artifactId>lettuce-core</artifactId>
		</exclusion>
	</exclusions>
	<version>2.0.6.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.8.9</version>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.1</version>
</dependency>
<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
	<version>2.6.0</version>
</dependency>
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>fastjson</artifactId>
	<version>1.2.31</version>
</dependency>

注:在spring-boot-starter-data-redis中排除lettuce-core，并添加jedis依赖是因为SpringBoot2.0中默认使用Lettuce来集成Redis服务，Spring-boot-starter-data-redis默认只引入了Lettuce包，并没有引入jedis包（redis操作需使用其中的类）支持。另外commons-pool2、fastjson（json格式化类）和aspectjweaver（增加切面支持）依赖也需添加。

3、Redis配置

在application.yml中添加（当然在application.properties添加也可以，按规范即可）:

spring:

  redis:

    database: 0

    host: XXX

    port: 6379

    password: XXX

    timeout: 1000

    pool:

      max-active: 1

      max-wait: 10

      max-idle: 2

      min-idle: 50

4、幂等处理代码

（1）自定义异常类IdempotentException

package com.demo.controller;
public class IdempotentException extends RuntimeException {
	public IdempotentException(String message) {
		super(message);
	}
	
	@Override
	public String getMessage() {
		return super.getMessage();
	}
}

（2）自定义注解

package com.demo.controller;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Idempotent {
	// redis的key值一部分
	String value();
	// 过期时间
	long expireMillis();
}

（3）自定义切面

package com.demo.controller;

import java.lang.reflect.Method;
import java.util.Objects;

import javax.annotation.Resource;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import redis.clients.jedis.JedisCommands;

@Component
@Aspect
@ConditionalOnClass(RedisTemplate.class)
public class IdempotentAspect {
	private static final String KEY_TEMPLATE = "idempotent_%s";

	@Resource
	private RedisTemplate<String, String> redisTemplate;

	// @annotation中包路径根据实际填写
	@Pointcut("@annotation(com.demo.controller.Idempotent)")
	public void executeIdempotent() {

	}

	@Around("executeIdempotent()")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
		Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
		Idempotent idempotent = method.getAnnotation(Idempotent.class);
		String key = String.format(KEY_TEMPLATE,
				idempotent.value() + "_" + KeyUtil.generate(method, joinPoint.getArgs()));
		String redisRes = redisTemplate
				.execute((RedisCallback<String>) conn -> ((JedisCommands) conn.getNativeConnection()).set(key, key,
						"NX", "PX", idempotent.expireMillis()));
		if (Objects.equals("OK", redisRes)) {
			return joinPoint.proceed();
		} else {
			throw new IdempotentException("Idempotent hits, key=" + key);
		}
	}
}

（4）Key生成工具类

package com.demo.controller;

import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import com.alibaba.fastjson.JSON;

public class KeyUtil {
	public static String generate(Method method, Object... args) throws UnsupportedEncodingException {
		StringBuilder sb = new StringBuilder(method.toString());
		for (Object arg : args) {
			sb.append(toString(arg));
		}
		return md5(sb.toString());
	}

	private static String toString(Object object) {
		if (object == null) {
			return "null";
		}
		if (object instanceof Number) {
			return object.toString();
		}
		return JSON.toJSONString(object);
	}

	public static String md5(String str) {
		StringBuilder buf = new StringBuilder();
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			md.update(str.getBytes());
			byte b[] = md.digest();
			int i;
			for (int offset = 0; offset < b.length; offset++) {
				i = b[offset];
				if (i < 0)
					i += 256;
				if (i < 16)
					buf.append(0);
				buf.append(Integer.toHexString(i));
			}
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return buf.toString();
	}

（5）在Controller中标记注解

package com.demo.controller;

import javax.annotation.Resource;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DemoController {
	@Resource
	private RedisTemplate<String, String> redisTemplate;
	
	@PostMapping("/redis")
	@Idempotent(value = "/redis", expireMillis = 5000L)
	public String redis(@RequestBody User user) {
		return "redis access ok:" + user.getUserName() + " " + user.getUserAge();
	}
}

（6）运行调用

运行SpringBoot，然后通过接口调用工具连续两次调用，显示如下：

 

参考文章： https://blog.csdn.net/hanchao5272/article/details/92073405，https://blog.csdn.net/thewaiting/article/details/89679132