Java防止频繁请求、重复提交的操作代码(后端防抖操作)

Java防止频繁请求、重复提交的操作代码(后端防抖操作)

在客户端网络慢或者服务器响应慢时，用户有时是会频繁刷新页面或重复提交表单的，这样是会给服务器造成不小的负担的，同时在添加数据时有可能造成不必要的麻烦。所以我们在后端也有必要进行防抖操作。

1.自定义注解

/**

* @author Tzeao

*/

@Target(ElementType.METHOD) // 作用到方法上

@Retention(RetentionPolicy.RUNTIME) // 运行时有效

public @interface NoRepeatSubmit {

//名称，如果不给就是要默认的

String name() default "name";

}

2.使用AOP实现该注解

/**

* @author Tzeao

*/

@Aspect

@Component

@Slf4j

public class NoRepeatSubmitAop {

@Autowired

private RedisService redisService;

/**

* 切入点

*/

@Pointcut("@annotation(com.qwt.part_time_admin_api.common.validation.NoRepeatSubmit)")

public void pt() {

}

@Around("pt()")

public Object arround(ProceedingJoinPoint joinPoint) throws Throwable {

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

assert attributes != null;

HttpServletRequest request = attributes.getRequest();

//这里是唯一标识 根据情况而定

String key = "1" + "-" + request.getServletPath();

// 如果缓存中有这个url视为重复提交

if (!redisService.haskey(key)) {

//通过，执行下一步

Object o = joinPoint.proceed();

//然后存入redis 并且设置15s倒http://计时

redisService.setCacheObject(key, 0, 15, TimeUnit.SECONDS);

//返回结果

return o;

} else {

return Result.fail(400, "请勿重复提交或者操作过于频繁！");

}

}

}

3.serice，也可以放在工具包里面，这里我们使用到了Redis来对key和标识码进行存储和倒计时,所以在使用时还需要连接一下Redis

package com.qwt.part_time_admin_api.service;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.*;

import org.springframework.stereotype.Component;

import java.util.*;

import java.util.concurrent.TimeUnit;

/**

* @author Tzeao

*/

@CompCSMOHGfPHkonent

public class RedisService {

@Autowired

public RedisTemplate redisTemplate;

/**

* 缓存基本的对象，Integer、String、实体类等

*

* @param key 缓存的键值

* @param value 缓存的值

* @return 缓存的对象

*/

public ValueOperations setCacheObject(String key, T value) {

ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, value);

return operation;

}

/**

* 缓存基本的对象，Integer、String、实体类等

*

* @param key 缓存的键值

* @param value 缓存的值

* @param timeout 时间

* @param timeUnit 时间颗粒度

* @return 缓存的对象

*/

public ValueOperations setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) {

ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, value, timeout, timeUnit);

return operation;

}

/**

* 获得缓存的基本对象。

*

* @param key 缓存键值

* @return 缓存键值对应的数据

*/

public T getCacheObject(String key) {

ValueOperations operation = redisTemplate.opsForValue();

return operation.get(key);

}

/**

* 删除单个对象

*

* @param key

*/

public void deleteObject(String key) {

redisTemplate.delete(key);

}

/**

* 删除集合对象

*

* @param collection

*/

public void deleteObject(Collection collection) {

redisTemplate.delete(collection);

}

/**

* 缓存List数据

*

* @param key 缓存的键值

* @param dataList 待缓存的List数据

* @return 缓存的对象

*/

public ListOperations setCacheList(String key, List dataList) {

ListOperations listOperation = redisTemplate.opsForList();

if (null != dataList) {

int size = dataList.size();

for (int i = 0; i < size; i++) {

listOperation.leftPush(key, dataList.get(i));

}

}

return listOperation;

}

/**

* 获得缓存的list对象

*

* @param key 缓存的键值

* @return 缓存键值对应的数据

*/

public List getCacheList(String key) {

List dataList = new ArrayList<>();

ListOperations listOperation = redisTemplate.opsForList();

Long size = listOperation.size(key);

for (int i = 0; i < size; i++) {

dataList.add(listOperation.index(key, i));

}

return dataList;

}

/**

* 缓存Set

*

* @param key 缓存键值

* @param dataSet 缓存的数据

* @return 缓存数据的对象

*/

public BoundSetOperations setCacheSet(String key, Set dataSet) {

BoundSetOperations setOperation = redisTemplate.boundSetOps(key);

Iterator it = dataSet.iterator();

while (it.hasNext()) {

setOperation.add(it.next());

}

return setOperation;

}

/**

* 获得缓存的set

*

* @param key

* @return

*/

public Set getCacheSet(String key) {

Set dataSet = new HashSet<>();

BoundSetOperations operation = redisTemplate.boundSetOps(key);

dataSet = operation.members();

return dataSet;

}

/**

* 缓存Map

*

* @param key

* @param dataMap

* @return

*/

public HashOperations setCacheMap(String key, Map dataMap) {

HashOperations hashOperations = redisTemplate.opsForHash();

if (null != dataMap) {

for (Map.Entry entry : dataMap.entrySet()) {

hashOperations.put(key, entry.getKey(), entry.getValue());

}

}

return hashOperations;

}

/**

* 获得缓存的Map

*

* @param key

* @return

*/

public Map getCacheMap(String key) {

Map map = redisTemplate.opsForHash().entries(key);

return map;

}

/**

* 获得缓存的基本对象列表

*

* @param pattern 字符串前缀

* @return 对象列表

*/

public Collection keys(String pattern) {

return redisTemplate.keys(pattern);

}

/**

* @param key

* @return

*/

public boolean haskey(String key) {

return redisTemplate.hasKey(key);

}

public Long getExpire(String key) {

return redisTemplate.getExpire(key);

}

public ValueOperations setBillObject(String key, List

ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, (T) value);

return operation;

}

/**

* 缓存list

*

* @param key 缓存的键值

* @param value 缓存的值

* @param timeout 时间

* @param timeUnit 时间颗粒度

* @return 缓存的对象

*/

public ValueOperations setBillObject(String key, List

ValueOperations operation = redisTemplate.opsForValue();

operation.set(key, (T) value, timeout, timeUnit);

return operation;

}

/**

* 缓存Map

*

* @param key

* @param dataMap

* @return

*/

public HashOperations setCKdBillMap(String key, Map dataMap) {

HashOperations hashOperations = redisTemplate.opsForHash();

if (null != dataMap) {

for (Map.Entry entry : dataMap.entrySet()) {

hashOperations.put(key, entry.getKey(), entry.getValue());

}

}

return hashOperations;

}

}

4.测试

@NoRepeatSubmit(name = "test") // 也可以不给名字，这样就会走默认名字

@GetMapping("test")

public Result test() {

return Result.success("测试阶段！");

}

15秒内重复点击就会给提示

这样就完成了一个防止重复提交、频繁申请的程序

参考：

https://blog.csdn.net/chengmin123456789/article/details/107982095

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。