PIG框架学习3——Redisson 实现业务接口幂等

零、前言

​ 业务接口幂等问题是在开发中遇到的,如果对业务接口代码不进行幂等控制,并且在前端没有对请求进行限制的情况下,可能会出现多次对接口调用,导致错误异常的发生。就上述情况,对PIGX自带的业务接口幂等实现进行了相关的学习,相关具体内容可以参考官方文档,本文章只是作为学习笔记。

一、接口幂等概念

幂等性原本是数学上的概念,在数学中表示对同一操作的多次执行,产生的结果与仅执行一次的结果相同。

用在接口上就可以理解为:同一个接口,多次发出同一个请求,必须保证操作只执行一次。 调用接口发生异常并且重复尝试时,总是会造成系统所无法承受的损失,所以必须阻止这种现象的发生。

实现接口幂等性通常需要考虑以下几个方面:

①请求参数:确保接口请求中的所有参数都是唯一的,不能重复。比如,在生成订单编号时可以使用时间戳或随机数等方式来保证唯一性

②接口设计:接口应该设计为“幂等性操作”,即无论调用多少次,结果都应该相同。例如,修改密码的接口应该设计为只能修改一次,多次修改的请求会被忽略。

③数据库操作:如果接口需要对数据库进行操作,需要确保每次操作都是幂等的。可以通过添加唯一索引或使用乐观锁等方式来避免重复操作

④错误处理:当请求出现异常时,接口应该处理异常并返回相应的错误信息。例如,当订单已经存在时,接口应该返回订单已存在的错误信息,而不是尝试再次创建订单

二、PIGX中具体实现方式

1、依赖的引入

情况①:

如果是其他项目,可以从中央仓库中引入PIGX提供的实现接口幂等的依赖

 <dependency>
     <groupId>com.pig4cloud.plugingroupId>
     <artifactId>idempotent-spring-boot-starterartifactId>
     <version>0.4.0version>
 dependency>

引入后的包内容如下所示
PIG框架学习3——Redisson 实现业务接口幂等_第1张图片

情况②:

如果项目中原先使用的就是pigx框架,那么在基础平台中的pigx-common-idempotent就已经自带
PIG框架学习3——Redisson 实现业务接口幂等_第2张图片

我们只需要引入pigx-common服务,就可以将实现接口幂等的依赖引入

2、Redis的配置

在配置文件中进行Redis的配置,设置redis存为我们的缓存中间件

通过如下配置,Spring框架会自动启用Redis作为缓存,并将Redis服务器的连接信息配置为指定的主机名和端口号

spring:
  cache:
    type: redis
  data:
    redis:
      host: 127.0.0.1
      port: 6379

spring.cache 对应的配置类是CacheProperties,这个配置项用来指定缓存的类型。在上述示例中,我们将缓存类型设置为Redis,表示使用Redis作为缓存。

spring.data.redis:这个配置项用来指定连接Redis所需的参数。在上述示例中,我们指定了Redis服务器的主机名为127.0.0.1,端口号为`6379

3、具体使用示例

pigx主要是通过AOP去实现业务接口幂等,其最核心的就是其Idempotent注解,其使用示例如下:

@Idempotent(key = "#demo.username", expireTime = 3, info = "请勿重复查询")
@GetMapping("/test")
public String test(Demo demo) {
    return "success";
}

通过使用@Idempotent注解,当多次请求进入test方法时,框架会根据key生成的唯一标识符判断是否已经执行过相同的请求。如果已经执行过,则直接返回之前的结果;如果没有执行过,则继续执行业务逻辑。

这样可以避免重复查询或操作带来的额外开销,并确保系统在重复请求时的一致性和可靠性。

三、原理分析

1、目录结构说明

对于PIGX自带的幂等插件idempotent的目录结构如下所示:

PIG框架学习3——Redisson 实现业务接口幂等_第3张图片

各目录内容说明如下:

- annotation     // 关于@Idempotent注解的声明
	- @Idempotent
- aspect		 // 关于AOP的切面方法
	- IdempotentAspect
- exception		 // 自定义异常类
	- IdempotentException
- expression	 // sqel表达式的解析工具
	- ExpressionResolver
	- KeyResolver
- IdempotentAutoConfiguration   //幂等插件配置文件

- org.springframework.boot.autoconfigure.AutoConfiguration.imports   //springboot自动配置文件
2、@idempotent 注解 配置详细说明
2.1、@idempotent注解源码
@Inherited
@Target(ElementType.METHOD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Idempotent {

	/**
	 * 幂等操作的唯一标识,使用spring el表达式 用#来引用方法参数
	 * @return Spring-EL expression
	 */
	String key() default "";

	/**
	 * 有效期 默认:1 有效期要大于程序执行时间,否则请求还是可能会进来
	 * @return expireTime
	 */
	int expireTime() default 1;

	/**
	 * 时间单位 默认:s
	 * @return TimeUnit
	 */
	TimeUnit timeUnit() default TimeUnit.SECONDS;

	/**
	 * 提示信息,可自定义
	 * @return String
	 */
	String info() default "重复请求,请稍后重试";

	/**
	 * 是否在业务完成后删除key true:删除 false:不删除
	 * @return boolean
	 */
	boolean delKey() default false;

}

key

key参数用于生成幂等性的唯一标识符,用于识别不同的请求或操作.具体来说,当多个请求或操作需要进行幂等性处理时,每个请求或操作需要有一个唯一的标识符来区分。这个标识符可以是请求参数、请求头信息、用户ID等等,根据实际场景而定。

在示例中,我们使用了SpEL表达式#demo.username作为唯一标识符,表示使用Demo对象的username属性作为标识符。也就是说,当多个请求的demo对象的username属性相同时,这些请求被认为是重复的,并且只有第一个请求会被执行,后续的请求会直接返回上次执行的结果。

expireTime

幂等性键过期时间,单位为秒

timeUnit

用于设置幂等性键过期时间的单位,默认是秒

info

用于描述幂等性操作的提示信息,在某些情况下,当出现重复请求时,我们需要向客户端返回一些提示信息,告知客户端该请求已经被处理过,不能重复提交。因此,通过设置info参数,我们可以自定义提示信息,以便更好地向客户端反馈信息。

delKey

是否在业务完成后删除key true:删除 false:不删除, 默认为false。

3、IdempotentAspect
3.1、IdempotentAspect源码及相关解析:
/**
 * The Idempotent Aspect
 *
 * @author ITyunqing
 */

//Spring框架中用于声明切面(Aspect)的注解
//通过在类上添加@Aspect注解,将其标识为一个切面类。切面类中可以包含各种通知(advice)和切点(pointcut),用于定义切面的具体行为和拦截规则
@Aspect
public class IdempotentAspect {
	//通过slf4j的LoggerFactory(日志工厂)创建一个Logger对象,用于在IdempotentAspect类中记录日志信息
	private static final Logger LOGGER = LoggerFactory.getLogger(IdempotentAspect.class);

    //创建一个名为THREAD_CACHE的私有的静态常量ThreadLocal对象
    //指定了泛型类型为Map,表示该ThreadLocal对象存储的值是一个键值对的映射
    //通过ThreadLocal类的withInitial方法,传入一个Supplier接口实例,该Supplier接口用于提供初始值。在这里,使用HashMap::new作为Supplier接口的实现,创建一个新的HashMap作为初始值。
	private static final ThreadLocal<Map<String, Object>> THREAD_CACHE = ThreadLocal.withInitial(HashMap::new);

    //定义了一个常量字符串变量RMAPCACHE_KEY,表示缓存中的键名,用于在缓存中存储幂等性相关的数据
	private static final String RMAPCACHE_KEY = "idempotent";

    //定义了一个常量字符串变量KEY,表示幂等性数据的键名,用于在幂等性相关的数据中标识唯一的幂等性请求
	private static final String KEY = "key";

    //定义了一个常量字符串变量DELKEY,表示删除缓存数据的键名,用于在缓存中标识需要删除的幂等性数据
	private static final String DELKEY = "delKey";

    //通过spring的自动装配功能,将Redisson对象注入到当前类中
	@Autowired
	private Redisson redisson;

    //通过spring的自动装配功能,将KeyResolver对象注入到当前类中
	@Autowired
	private KeyResolver keyResolver;

    //通过spring的自动装配功能,将一个Optional对象注入到当前类中
	//KeyStrResolver的一个可选注入项,它可以包含一个非空的值,也可以为空
    @Autowired
	private Optional<KeyStrResolver> keyStrResolverOptional;

    //该注解表示定义一个切入点,使用@annotation表达式来匹配被指定注解标记的方法。在这里,切入点匹配的条件是被com.pig4cloud.pigx.common.idempotent.annotation.Idempotent注解标记的方法
	@Pointcut("@annotation(com.pig4cloud.pigx.common.idempotent.annotation.Idempotent)")
	//这是一个空方法体,作为切入点的定义。它没有任何实际的逻辑操作,只是用来定义一个切入点的名称
    public void pointCut() {
	}

    
    //切面的前置通知(@Before):它在切入点方法执行之前被调用
	@Before("pointCut()")
	public void beforePointCut(JoinPoint joinPoint) {
		//通过RequestContextHolder类可以获取当前线程的RequestAttributes对象
        //将获取到的RequestAttributes对象强制转换为ServletRequestAttributes类型。ServletRequestAttributes是RequestAttributes的子接口,扩展了一些与Servlet请求相关的方法和属性
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
				.getRequestAttributes();
        
        //获取当前请求的 HttpServletRequest 对象
		HttpServletRequest request = requestAttributes.getRequest();
	
        //将 joinPoint 转换为 MethodSignature 对象
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		//通过 MethodSignature 对象获取到当前方法的 Method 对象
        Method method = signature.getMethod();
        //如果当前方法上没有使用注解@Idempotent,则return返回
		if (!method.isAnnotationPresent(Idempotent.class)) {
			return;
		}
        //如果当前方法上有使用注解@Idempotent,获得该注解信息
        //通过调用 getAnnotation() 方法并传入 Idempotent.class 作为参数,可以获取到该方法上的 Idempotent 注解的实例对象
		Idempotent idempotent = method.getAnnotation(Idempotent.class);
		
		String key;

		// 若没有配置 幂等 标识编号,则使用 url + 参数列表作为区分(作为生成幂等性的唯一标识符)
		if (!StringUtils.hasLength(idempotent.key())) {
			String url = request.getRequestURL().toString();
			String argString = Arrays.asList(joinPoint.getArgs()).toString();
			key = url + argString;
		}
		else {
			// 使用jstl 规则区分(具体会在expression中进行讲解)
			key = keyResolver.resolver(idempotent, joinPoint);
		}

        //StrUtil.COLON:字符串常量:冒号 {@code ":"}
        //如果keyStrResolverOptional存在,则设置key的值为KeyStrResolver调用extract(key, StrUtil.COLON)方法的结果值
        //即在原先key的基础的前面加上租户id:
		if (keyStrResolverOptional.isPresent()) {
			key = keyStrResolverOptional.get().extract(key, StrUtil.COLON);
		}

        //获取注解idempotent的有效期
		long expireTime = idempotent.expireTime();
        //获取注解idempotent的提示信息
		String info = idempotent.info();
        //获取注解idempotent的时间单位
		TimeUnit timeUnit = idempotent.timeUnit();
        //获取注解idempotent的是否在业务完成后删除key
		boolean delKey = idempotent.delKey();

		// do not need check null
        //RMapCache 是 Redisson 提供的一个接口,用于表示一个带有过期时间的分布式 Map 缓存,RMapCache 继承自 RMap 接口,提供了一些额外的方法,可以设置和获取缓存的过期时间,以及进行相关的缓存操作
        //通过 redisson 对象调用 getMapCache(RMAPCACHE_KEY) 方法,传入参数 RMAPCACHE_KEY 来获取对应的缓存对象
        //RMAPCACHE_KEY 是表示缓存的键值,可能是一个字符串或其他适当的类型
		RMapCache<String, Object> rMapCache = redisson.getMapCache(RMAPCACHE_KEY);
		//获取当前系统的时间,并将其转化为字符串,将其中的T替换为“ ”
        String value = LocalDateTime.now().toString().replace("T", " ");
		
        Object v1;
        //如果当前对应的键key已经有缓存对象,则抛出异常,异常信息为"[idempotent]:" + info
		if (null != rMapCache.get(key)) {
			// had stored
			throw new IdempotentException("[idempotent]:" + info);
		}
        //使用 synchronized 关键字来对代码块进行同步,确保在多线程环境下的安全性
        //通过 synchronized(this) 来锁定当前对象,以保证同一时间只有一个线程可以进入这个代码块
		synchronized (this) {
        	//将键值对放入缓存中
            //该方法会返回之前关联到 key 上的值,如果该值为 null,则表示插入成功
			v1 = rMapCache.putIfAbsent(key, value, expireTime, timeUnit);
			//如果 v1 不为 null,即 putIfAbsent 返回了一个非空值,说明之前已经存在相同的键值对,此时抛出一个 IdempotentException 异常,表示幂等性校验失败
            if (null != v1) {
				throw new IdempotentException("[idempotent]:" + info);
			}
            //如果 v1 为 null,表示 putIfAbsent 成功插入了新的键值对,记录一条日志信息,并打印当前存储的 key、value、过期时间等信息
			else {
				LOGGER.info("[idempotent]:has stored key={},value={},expireTime={}{},now={}", key, value, expireTime,
						timeUnit, LocalDateTime.now().toString());
			}
		}
        
        //在当前线程中使用 ThreadLocal 来创建一个线程本地的 Map 对象,并将 key 和 delKey 存储到其中
		//通过 THREAD_CACHE.get() 方法获取当前线程绑定的 Map 对象,存储到 map 变量中
		Map<String, Object> map = THREAD_CACHE.get();
		//将键值对 KEY 和对应的变量 key 存储到 map 中
        map.put(KEY, key);
        //将键值对 DELKEY 和对应的变量 delKey 存储到 map 中
		map.put(DELKEY, delKey);
	}

    //切面的后置通知(@After):它在切入点方法执行之后被调用
	@After("pointCut()")
	public void afterPointCut(JoinPoint joinPoint) {
        //从当前线程中获取之前存储的 map 对象,并将其存储到 map 变量中
		Map<String, Object> map = THREAD_CACHE.get();
		
        //判断 map 是否为空,如果为空,则直接返回,不执行后续操作
        if (CollectionUtils.isEmpty(map)) {
			return;
		}
		//获取一个名为 RMAPCACHE_KEY 的 RMapCache 实例
		RMapCache<Object, Object> mapCache = redisson.getMapCache(RMAPCACHE_KEY);
		//判断该 RMapCache 是否为空。如果为空,则直接返回,不执行后续操作
        if (mapCache.size() == 0) {
			return;
		}
		//从 map 中获取 key ,并将 key 转换为字符串类型保存到 key 变量中
		String key = map.get(KEY).toString();
        //从 map 中获取 delKey, 将 delKey 强制转换为布尔型保存到 delKey 变量中
		boolean delKey = (boolean) map.get(DELKEY);
		//delKey为真,则调用 mapCache.fastRemove(key) 方法从 RMapCache 中删除指定的键值对,并记录一条日志信息
		if (delKey) {
			mapCache.fastRemove(key);
			LOGGER.info("[idempotent]:has removed key={}", key);
		}
        //从当前线程中删除 map 对象。这样做是为了避免在下次请求时出现数据混淆的情况
		THREAD_CACHE.remove();
	}

}

3.2、相关内容补充

① ThreadLocal

ThreadLocal 是一个 Java 类,它提供了线程局部变量的支持。每个线程都可以独立地访问和修改自己的线程局部变量,而不会干扰其他线程的变量。

使用 ThreadLocal 可以解决多线程并发访问共享变量时可能出现的线程安全问题。通过将数据存储在 ThreadLocal 对象中,每个线程都有自己独立的副本,线程之间的数据互不干扰。

在使用 ThreadLocal 时,通常的做法是创建一个 ThreadLocal 对象,并使用 set() 方法来设置当前线程的变量值,使用 get() 方法来获取当前线程的变量值。可以通过 remove() 方法来清除当前线程的变量值。

② Redisson

Redisson是一个Java Redis客户端,提供了简单易用的API接口,支持分布式锁、分布式集合、分布式对象等功能。它基于Redis客户端(Jedis、Lettuce)封装了一系列的分布式操作接口,使得Java开发者可以方便地使用Redis实现分布式应用程序。

Redisson的主要特点如下:

  • 对Redis的高效封装:Redisson对Redis客户端进行了高效的封装,提供了简单易用的API接口,使得Java开发者可以方便地实现复杂的分布式应用程序。
  • 分布式锁:Redisson提供了分布式锁的实现,支持可重入锁、公平锁、联锁、红锁等多种类型的锁,并且保证了锁的正确性和高可用性。
  • 分布式集合:Redisson支持分布式Set、List、Queue、Deque、Map、SortedSet等集合类型的操作,可以方便地实现分布式计算、消息队列等功能。
  • 分布式对象:Redisson支持分布式ExecutorService、ScheduledExecutorService、Semaphore、CountDownLatch、ReadWriteLock等对象类型的操作,可以方便地实现分布式任务调度、并发控制等功能。

③MethodSignature

在 Spring AOP 中,joinPoint 是一个连接点(即程序执行过程中能够插入额外代码的点),它封装了当前方法的相关信息,包括方法名、参数等。

MethodSignature 是 JoinPoint 的一个子类,它用于表示方法签名,即方法名和参数类型等信息。通过 MethodSignature 对象,我们可以获取到当前方法的 Method 对象,进而获取该方法的返回值类型、参数列表等信息。

④KeyStrResolver

其是一个接口,源码如下

public interface KeyStrResolver {

	/**
	 * 字符串加工
	 * @param in 输入字符串
	 * @param split 分割符
	 * @return 输出字符串
	 */
	String extract(String in, String split);

	/**
	 * 字符串获取
	 * @return 模块返回字符串
	 */
	String key();
}

其具体实现类TenantKeyStrResolver的源码如下所示

/**
 * @author lengleng
 * @date 2020/9/29
 * 

* 租户字符串处理(方便其他模块获取) */ public class TenantKeyStrResolver implements KeyStrResolver { /** * 传入字符串增加 租户编号:in * @param in 输入字符串 * @param split 分割符 * @return */ @Override public String extract(String in, String split) { return TenantContextHolder.getTenantId() + split + in; } /** * 返回当前租户ID * @return */ @Override public String key() { return String.valueOf(TenantContextHolder.getTenantId()); } }

4、IdempotentException自定义异常类
4.1、IdempotentException自定义异常类源码
//RuntimeException 运行时异常的实现类
public class IdempotentException extends RuntimeException {

    //无参构造器
	public IdempotentException() {
		super();
	}

    //有参构造器1
	public IdempotentException(String message) {
		super(message);
	}

    //有参构造器2
	public IdempotentException(String message, Throwable cause) {
		super(message, cause);
	}

    //有参构造器3
	public IdempotentException(Throwable cause) {
		super(cause);
	}

    //有参构造器4
	protected IdempotentException(String message, Throwable cause, boolean enableSuppression,
			boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}

}

5、唯一标志处理器KeyResolver
5.1、 KeyResolver源码及解析

其中定义了一个解析处理key的抽象方法

public interface KeyResolver {

	/**
	 * 解析处理 key
	 * @param idempotent 接口注解标识
	 * @param point 接口切点信息
	 * @return 处理结果
	 */
	String resolver(Idempotent idempotent, JoinPoint point);

}

5.2、ExpressionResolver源码及其解析

ExpressionResolverKeyResolver的实现类,其主要的作用就是进行key的抽取,优先根据 spel 处理

/**
 * @author lengleng
 * 

* 默认key 抽取, 优先根据 spel 处理 * @date 2020-09-25 */ public class ExpressionResolver implements KeyResolver { //创建一个 SpEL 表达式解析器实例SpelExpressionParser private static final SpelExpressionParser PARSER = new SpelExpressionParser(); //创建一个 LocalVariableTableParameterNameDiscoverer 对象,用于获取方法参数的名称 private static final LocalVariableTableParameterNameDiscoverer DISCOVERER = new LocalVariableTableParameterNameDiscoverer(); //重写父类keyResolver的resolver方法 @Override public String resolver(Idempotent idempotent, JoinPoint point) { //通过 point.getArgs() 获取方法的参数数组 Object[] arguments = point.getArgs(); // 获取方法参数的名称数组 String[] params = DISCOVERER.getParameterNames(getMethod(point)); //创建一个 StandardEvaluationContext 对象,用于提供表达式求值的上下文环境 StandardEvaluationContext context = new StandardEvaluationContext(); //如果方法参数的名称数组不为空且长度大于 0,则遍历参数名称数组,将参数名和对应的参数值存储到 context 中 if (params != null && params.length > 0) { for (int len = 0; len < params.length; len++) { context.setVariable(params[len], arguments[len]); } } //使用 PARSER.parseExpression(idempotent.key()) 解析 idempotent.key() 字符串为一个 SpEL 表达式,并返回一个 Expression 对象 Expression expression = PARSER.parseExpression(idempotent.key()); //调用 Expression 对象的 getValue() 方法,传入 context 和期望的结果类型 String.class,以获取表达式的求值结果 return expression.getValue(context, String.class); } /** * 根据切点解析方法信息 * @param joinPoint 切点信息 * @return Method 原信息 */ private Method getMethod(JoinPoint joinPoint) { //通过 joinPoint.getSignature() 获取切入点的方法签名,然后将其转换为 MethodSignature 类型,并赋值给 signature 变量 MethodSignature signature = (MethodSignature) joinPoint.getSignature(); //从方法签名中获取切入点方法,并赋值给 method 变量 Method method = signature.getMethod(); //判断切入点方法所在的类是否是一个接口。如果是接口,则执行以下代码块 if (method.getDeclaringClass().isInterface()) { try { //通过 joinPoint.getTarget().getClass() 获取切入点目标对象的类,并使用该类调用 getDeclaredMethod() 方法来获取具体实现类中与切入点方法相同名称和参数类型的方法,并将得到的方法赋值给 method 变量 method = joinPoint.getTarget().getClass().getDeclaredMethod(joinPoint.getSignature().getName(), method.getParameterTypes()); } catch (SecurityException | NoSuchMethodException e) { //如果在获取具体实现类中的方法时抛出了 SecurityException 或 NoSuchMethodException 异常,会捕获并抛出一个具有该异常的 RuntimeException 异常 throw new RuntimeException(e); } } //返回获取到的方法对象 return method; } }

6、幂等插件配置文件IdempotentAutoConfiguration
6.1、配置文件源码
//标记该类为配置类
//proxyBeanMethods = false,表示Spring 将不会为配置类的方法生成代理对象,这样可以避免额外的代理开销
@Configuration(proxyBeanMethods = false)
//指定在特定自动配置类RedisAutoConfiguration之后进行自动配置
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class IdempotentAutoConfiguration {

	/**
	 * 生成IdempotentAspect切面类的bean实例
	 * 切面 拦截处理所有 @Idempotent
	 * @return Aspect
	 */
	@Bean
	public IdempotentAspect idempotentAspect() {
		return new IdempotentAspect();
	}

	/**
	 * 生成key 解析器的bean实例
	 * key 解析器
	 * @return KeyResolver
	 */
	@Bean
	@ConditionalOnMissingBean(KeyResolver.class)
	public KeyResolver keyResolver() {
		return new ExpressionResolver();
	}

}
7、AutoConfiguration.imports
7.1、源码
com.pig4cloud.pigx.common.idempotent.IdempotentAutoConfiguration
7.2、作用

org.springframework.boot.autoconfigure.AutoConfiguration.imports 是一个 Spring Boot 的属性,用于指定需要在自动配置类中导入的其他配置类。

在 Spring Boot 中,自动配置是一种机制,它根据应用程序的依赖和配置信息,自动创建并配置相应的 Bean 实例。而 AutoConfiguration.imports 属性则提供了一种扩展机制,允许开发人员在自动配置类中导入其他配置类,以实现更为灵活和定制化的自动配置。

具体来说,AutoConfiguration.imports 属性是一个字符串数组,每个元素表示一个需要导入的配置类的全限定名。在自动配置过程中,Spring Boot 会自动加载这些配置类,并将它们合并到当前上下文中,以实现更全面的自动配置。

8、补充

1.请求开始前,根据key查询 查到结果:报错 | 未查到结果:存入key-value-expireTime

2.请求结束后,直接删除key ,不管key是否存在,直接删除 是否删除,可配置

3.expireTime过期时间,防止一个请求卡死,会一直阻塞,超过过期时间,自动删除

过期时间要大于业务执行时间,需要大概评估下;

4.此方案直接切的是接口请求层面。

5.过期时间需要大于业务执行时间,否则业务请求1进来还在执行中,前端未做遮罩,或者用户跳转页面后再回来做重复请求2,在业务层面上看,结果依旧是不符合预期的。

6.建议delKey = false。即使业务执行完,也不删除key,强制锁expireTime的时间。预防5的情况发生。

7.实现思路:同一个请求ip和接口,相同参数的请求,在expireTime内多次请求,只允许成功一次。

8.页面做遮罩,数据库层面的唯一索引,先查询再添加,等处理方式应该都处理下。

9.此注解只用于幂等,不用于锁,100个并发这种压测,会出现问题,在这种场景下也没有意义,实际中用户也不会出现1s或者3s内手动发送了50个或者100个重复请求,或者弱网下有100个重复请求;

你可能感兴趣的:(从零开始的PIG框架学习生活,学习,java)