Comment Java limite-t-il les requêtes répétées sur le front-end ?

Contexte et objectif

La page frontale est bloquée et l'utilisateur clique à plusieurs reprises sur le bouton d'opération, ce qui entraîne la soumission de l'interface backend plusieurs fois dans un court laps de temps

Étapes de mise en œuvre

Définir les aspects et ajouter des annotations, ce qui fait que l'interface n'est pas appelée à plusieurs reprises dans le délai spécifié

Définir une interfaceNoRepeatSubmit

import java.lang.annotation.*;
/**
 * xzj_2022_8_2
 * 重复请求限制切面
 */
@Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
@Documented //生成文档
public @interface NoRepeatSubmit {
    String name() default "name:";
}

Implémenter la classe

import java.lang.annotation.*;
/**
 * xzj_2022_8_2
 * 重复请求限制切面
 */
@Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
@Documented //生成文档
public @interface NoRepeatSubmit {
    String name() default "name:";
}

Utiliser

    @GetMapping(value = "/test")
    @NoRepeatSubmit
    public void test() {
        System.out.println("test");
        }

Additionnel : Jetons un coup d'œil à Java pour éviter les soumissions répétées sur le front-end

JAVA utilise des verrous locaux personnalisés pour résoudre le problème des soumissions répétées

1. Introduisez les packages jar

<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>31.1-jre</version>
        </dependency>

2 Personnalisez le verrouillage local

package com.hzt.listener;
import java.lang.annotation.*;
/**
 * 自定义-控制重复提交锁
 */
@Target(ElementType.METHOD)     //作用于方法
@Retention(RetentionPolicy.RUNTIME)     //运行时有效
@Documented
@Inherited
public @interface LocalLock {

    String key() default "";
}

3. Aspect d'annotation personnalisé (implémentation de l'intercepteur aop)

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

/**
 * @Desc: 自定义注解拦截器
 * @Author: zmk
 * @Date: 2022/4/2
 */
@Aspect
@Configuration
public class LockMethodInterceptor {
    private final Logger log = LoggerFactory.getLogger(LockMethodInterceptor.class);


    private static final Cache<String, Object> CACHES = CacheBuilder.newBuilder()
            //最大缓存数
            .maximumSize(1000)
            //设置过期时间
            .expireAfterWrite(3, TimeUnit.SECONDS)
            .build();



    @Around(value = "@annotation(localLock)")
    public Object interceptor (ProceedingJoinPoint point, LocalLock localLock) {

        //localLock.key() 这个是获取controller的key属性， point.getArgs()获取key的值
        String key = getKey(localLock.key(), point.getArgs());
        if (StringUtils.isNotBlank(key)) {
            if (CACHES.getIfPresent(key) != null) {
                throw new RuntimeException("请勿重复提交");
            }
            //如果是第一次请求, 将key放入缓存
            CACHES.put(key, key);
        }

        try {
            return point.proceed();
        } catch (Throwable throwable) {
            throw new RuntimeException("服务器异常");
        } finally {
            //标记为无效
//            CACHES.invalidate(key);
        }

    }
    
    /**
     *
     * key 生成策略
     * @param key   key表达式
     * @param args  参数
     * @return  生成的key
     */
    private String getKey(String key, Object[] args) {
        for (int i = 0; i < args.length; i++) {
            key = key.replace("arg[" + i + "]", args[i].toString());
        }
        return key;
    }

4.

Résultat du premier appel :

Résultat du deuxième appel :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!