devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot防止重复提交自定义注解_springboot自定义注解防止表单重复提交

作者：知新_RL | 2024-05-07 19:14:51

赞

踩

springboot自定义注解防止表单重复提交

先看效果：

相关代码 

 配置redis

  1. server:
  2.   port: 8282
  3.  
  4. spring:
  5.   # redis 配置
  6.   redis:
  7.     # 地址
  8.     host: 192.168.1.7
  9.     # 密码
  10.     password: 123456
  11.     # 端口，默认为6379
  12.     port: 6379
  13.     # 数据库索引
  14.     database: 0
  15.     # 连接超时时间
  16.     timeout: 10s
  17.     lettuce:
  18.       pool:
  19.         # 连接池中的最小空闲连接
  20.         min-idle: 0
  21.         # 连接池中的最大空闲连接
  22.         max-idle: 8
  23.         # 连接池的最大数据库连接数
  24.         max-active: 8
  25.         # #连接池最大阻塞等待时间（使用负值表示没有限制）
  26.         max-wait: -1ms

pom文件

  1. <dependency>
  2.       <groupId>org.springframework.boot</groupId>
  3.       <artifactId>spring-boot-starter-web</artifactId>
  4.     </dependency>
  5.     <!-- aop切面 -->
  6.     <dependency>
  7.       <groupId>org.springframework.boot</groupId>
  8.       <artifactId>spring-boot-starter-aop</artifactId>
  9.     </dependency>
  10.  
  11.     <dependency>
  12.       <groupId>org.springframework.boot</groupId>
  13.       <artifactId>spring-boot-starter-data-redis</artifactId>
  14.     </dependency>
  15.     <dependency>
  16.       <groupId>cn.hutool</groupId>
  17.       <artifactId>hutool-all</artifactId>
  18.       <version>5.8.5</version>
  19.     </dependency>
  20.     <dependency>
  21.       <groupId>org.apache.commons</groupId>
  22.       <artifactId>commons-pool2</artifactId>
  23.       <version>2.0</version>
  24.     </dependency>

具体代码，拿去就可以用

  1. package org.example.repeatsubmit;
  2.  
  3. import cn.hutool.core.convert.Convert;
  4.  
  5. /**
  6.  * 类型转换工具类
  7.  */
  8. public class ConvertUtils extends Convert {
  9.  
  10. }
  1. package org.example.repeatsubmit;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4.  
  5. import javax.servlet.ServletRequest;
  6. import java.io.BufferedReader;
  7. import java.io.IOException;
  8. import java.io.InputStream;
  9. import java.io.InputStreamReader;
  10. import java.nio.charset.StandardCharsets;
  11.  
  12. /**
  13.  * 通用http工具封装
  14.  */
  15. @Slf4j
  16. public class HttpHelperUtils {
  17.  
  18.     /**
  19.      * 获取请求Body
  20.      *
  21.      * @param request 请求
  22.      * @return 目标字符串
  23.      */
  24.     public static String getBodyString(ServletRequest request) {
  25.         try (InputStream inputStream = request.getInputStream();
  26.              BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
  27.             String line;
  28.             StringBuilder sb = new StringBuilder();
  29.  
  30.             while (StringUtils.isNotEmpty(line = reader.readLine())) {
  31.                 sb.append(line);
  32.             }
  33.  
  34.             return sb.toString();
  35.         } catch (IOException e) {
  36.             log.warn("getBodyString出现异常：！", e);
  37.         }
  38.  
  39.         return StringUtils.EMPTY;
  40.     }
  41.  
  42. }

  1. package org.example.repeatsubmit;
  2.  
  3. public class JsonConvertException extends RuntimeException {
  4.  
  5.     private static final long serialVersionUID = 1L;
  6.  
  7.     protected final String message;
  8.  
  9.     public JsonConvertException(String message) {
  10.         this.message = message;
  11.     }
  12.  
  13.     public JsonConvertException(String message, Throwable e) {
  14.         super(message, e);
  15.         this.message = message;
  16.     }
  17.  
  18.     @Override
  19.     public String getMessage() {
  20.         return message;
  21.     }
  22.  
  23. }
  1. package org.example.repeatsubmit;
  2.  
  3. import cn.hutool.json.JSONUtil;
  4. import com.fasterxml.jackson.core.JsonProcessingException;
  5. import com.fasterxml.jackson.core.type.TypeReference;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.example.rate.SpringUtils;
  9.  
  10. import java.io.IOException;
  11.  
  12. @Slf4j
  13. public class JSONUtils extends JSONUtil {
  14.  
  15.     private final static ObjectMapper OBJECT_MAPPER;
  16.  
  17.     static {
  18.         OBJECT_MAPPER = SpringUtils.getBean(ObjectMapper.class);
  19.     }
  20.  
  21.     /**
  22.      * jackson
  23.      * <p>
  24.      * 传入对象直接返回Json
  25.      *
  26.      * @param object 待转换对象
  27.      * @return json字符串
  28.      */
  29.     public static <T> String serialize(T object) {
  30.         try {
  31.             return OBJECT_MAPPER.writeValueAsString(object);
  32.         } catch (JsonProcessingException e) {
  33.             log.error("JSON序列化异常：", e);
  34.             throw new JsonConvertException("JSON序列化异常！");
  35.         }
  36.     }
  37.  
  38.     /**
  39.      * jackson
  40.      * <p>
  41.      * 传入Json字符串直接返回bean对象
  42.      *
  43.      * @param json  待转换Json字符
  44.      * @param clazz 待转换对象类型
  45.      * @return bean对象
  46.      */
  47.     public static <T> T deserialize(String json, Class<T> clazz) {
  48.         try {
  49.             return OBJECT_MAPPER.readValue(json, clazz);
  50.         } catch (JsonProcessingException e) {
  51.             log.error("JSON反序列化异常：", e);
  52.             throw new JsonConvertException("JSON反序列化异常！");
  53.         } catch (IOException e) {
  54.             e.printStackTrace();
  55.             throw new JsonConvertException("JSON反序列化异常！");
  56.         }
  57.     }
  58.  
  59.     /**
  60.      * jackson
  61.      * json转bean或list
  62.      *
  63.      * @param str           带转换字符串
  64.      * @param typeReference 转换类型
  65.      * @return T 转换后对象
  66.      */
  67.     public static <T> T getTypeReference(String str, TypeReference<T> typeReference) {
  68.         try {
  69.             return OBJECT_MAPPER.readValue(str, typeReference);
  70.         } catch (JsonProcessingException e) {
  71.             log.error("JSON反序列化异常：", e);
  72.             throw new JsonConvertException("JSON反序列化异常！");
  73.         } catch (IOException e) {
  74.             e.printStackTrace();
  75.             throw new JsonConvertException("JSON反序列化异常！");
  76.         }
  77.     }
  78.  
  79. }

  1. package org.example.repeatsubmit;
  2.  
  3. import cn.hutool.core.map.MapUtil;
  4.  
  5. public class MapUtils extends MapUtil {
  6.  
  7. }
  1. package org.example.repeatsubmit;
  2.  
  3. import cn.hutool.core.lang.TypeReference;
  4. import org.example.rate.ConvertUtils;
  5. import org.example.rate.SpringUtils;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.core.ValueOperations;
  8. import org.springframework.data.redis.core.script.RedisScript;
  9.  
  10. import java.util.List;
  11. import java.util.concurrent.TimeUnit;
  12.  
  13. public class RedisUtils {
  14.  
  15.     /**
  16.      * redisTemplate名称
  17.      */
  18.     public static final String REDIS_TEMPLATE_NAME = "redisTemplate";
  19.  
  20.     private final static RedisTemplate<Object, Object> redisTemplate;
  21.  
  22.     static {
  23.         redisTemplate = org.example.rate.ConvertUtils.convert(new TypeReference<RedisTemplate<Object, Object>>() {},
  24.                 SpringUtils.getBean(REDIS_TEMPLATE_NAME, RedisTemplate.class));
  25.     }
  26.  
  27.     /**
  28.      * 缓存基本的对象，Integer、String、实体类等
  29.      *
  30.      * @param key   缓存的键值
  31.      * @param value 缓存的值
  32.      */
  33.     public static <T> void setCacheObject(final String key, final T value) {
  34.         redisTemplate.opsForValue().set(key, value);
  35.     }
  36.  
  37.     /**
  38.      * 缓存基本的对象，Integer、String、实体类等
  39.      *
  40.      * @param key      缓存的键值
  41.      * @param value    缓存的值
  42.      * @param timeout  时间
  43.      * @param timeUnit 时间颗粒度
  44.      */
  45.     public static <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
  46.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  47.     }
  48.  
  49.     /**
  50.      * 获得缓存的基本对象。
  51.      *
  52.      * @param key 缓存键值
  53.      * @return 缓存键值对应的数据
  54.      */
  55.     public static <T> T getCacheObject(final String key) {
  56.         ValueOperations<String, T> operation = ConvertUtils.convert(new TypeReference<ValueOperations<String, T>>() {},
  57.                 redisTemplate.opsForValue());
  58.         return operation.get(key);
  59.     }
  60.  
  61.     /**
  62.      * 删除单个对象
  63.      *
  64.      * @param key 缓存键值
  65.      */
  66.     public static boolean deleteObject(final String key) {
  67.         return Boolean.TRUE.equals(redisTemplate.delete(key));
  68.     }
  69.  
  70.     /**
  71.      * redis 原生脚本执行
  72.      *
  73.      * @param script RedisScript脚本
  74.      * @param keys   缓存键值
  75.      * @param args   参数
  76.      */
  77.     public static <T> T execute(RedisScript<T> script, List<Object> keys, Object... args) {
  78.         return redisTemplate.execute(script, keys, args);
  79.     }
  80.  
  81. }
  1. package org.example.repeatsubmit;
  2.  
  3. import javax.servlet.ReadListener;
  4. import javax.servlet.ServletInputStream;
  5. import javax.servlet.ServletResponse;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletRequestWrapper;
  8. import java.io.BufferedReader;
  9. import java.io.ByteArrayInputStream;
  10. import java.io.IOException;
  11. import java.io.InputStreamReader;
  12. import java.nio.charset.StandardCharsets;
  13.  
  14. /**
  15.  * 构建可重复读取inputStream的request
  16.  *
  17.  */
  18. public class RepeatedlyRequestWrapper extends HttpServletRequestWrapper {
  19.  
  20.     private final byte[] body;
  21.  
  22.     public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws IOException {
  23.         super(request);
  24.         request.setCharacterEncoding(StandardCharsets.UTF_8.name());
  25.         response.setCharacterEncoding(StandardCharsets.UTF_8.name());
  26.         body = HttpHelperUtils.getBodyString(request).getBytes(StandardCharsets.UTF_8.name());
  27.     }
  28.  
  29.     @Override
  30.     public BufferedReader getReader() {
  31.         return new BufferedReader(new InputStreamReader(getInputStream()));
  32.     }
  33.  
  34.     @Override
  35.     public ServletInputStream getInputStream() {
  36.         final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body);
  37.  
  38.         return new ServletInputStream() {
  39.             @Override
  40.             public int read() {
  41.                 return byteArrayInputStream.read();
  42.             }
  43.  
  44.             @Override
  45.             public int available() {
  46.                 return body.length;
  47.             }
  48.  
  49.             @Override
  50.             public boolean isFinished() {
  51.                 return false;
  52.             }
  53.  
  54.             @Override
  55.             public boolean isReady() {
  56.                 return false;
  57.             }
  58.  
  59.             @Override
  60.             public void setReadListener(ReadListener readListener) {
  61.  
  62.             }
  63.         };
  64.     }
  65. }
  1. package org.example.repeatsubmit;
  2.  
  3. import java.lang.annotation.*;
  4.  
  5. /**
  6.  * 防止表单重复提交注解
  7.  */
  8. @Inherited
  9. @Documented
  10. @Target(ElementType.METHOD)
  11. @Retention(RetentionPolicy.RUNTIME)
  12. public @interface RepeatSubmit {
  13.  
  14.     /**
  15.      * 间隔时间(ms)，小于此时间视为重复提交
  16.      */
  17.     int interval() default 5000;
  18.  
  19.     /**
  20.      * 提示消息
  21.      */
  22.     String message() default "不允许重复提交，请稍候再试";
  23.  
  24. }
  1. package org.example.repeatsubmit;
  2.  
  3. import org.springframework.lang.NonNull;
  4. import org.springframework.web.method.HandlerMethod;
  5. import org.springframework.web.servlet.HandlerInterceptor;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8. import java.lang.reflect.Method;
  9. import java.util.Objects;
  10.  
  11. public abstract class RepeatSubmitInterceptor implements HandlerInterceptor {
  12.  
  13.     @Override
  14.     public boolean preHandle(@NonNull HttpServletRequest request, @NonNull HttpServletResponse response, @NonNull Object handler) {
  15.         if (handler instanceof HandlerMethod) {
  16.             HandlerMethod handlerMethod = (HandlerMethod) handler;
  17.             Method method = handlerMethod.getMethod();
  18.             RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
  19.  
  20.             if (Objects.nonNull(annotation)) {
  21.                 if (this.isRepeatSubmit(request, annotation)) {
  22.                     Response<String> result = Response.fail(ResponseCode.FAIL, annotation.message());
  23.                     ServletUtils.responseJson(response, result);
  24.                     return false;
  25.                 }
  26.             }
  27.         }
  28.  
  29.         return true;
  30.     }
  31.  
  32.     /**
  33.      * 验证是否重复提交由子类实现具体的防重复提交的规则
  34.      *
  35.      * @param request 请求
  36.      * @param annotation 重复提交注解
  37.      * @return 是否是重复提交
  38.      */
  39.     public abstract boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit annotation);
  40.  
  41. }
  1. package org.example.repeatsubmit;
  2.  
  3. import java.io.Serializable;
  4.  
  5. public class Response<T> implements Serializable {
  6.  
  7.     private Integer code;
  8.  
  9.     private String message;
  10.  
  11.     private T data;
  12.  
  13.     private Response() {
  14.  
  15.     }
  16.  
  17.     public Integer getCode() {
  18.         return code;
  19.     }
  20.  
  21.     public void setCode(Integer code) {
  22.         this.code = code;
  23.     }
  24.  
  25.     public String getMessage() {
  26.         return message;
  27.     }
  28.  
  29.     public void setMessage(String message) {
  30.         this.message = message;
  31.     }
  32.  
  33.     public T getData() {
  34.         return data;
  35.     }
  36.  
  37.     public void setData(T data) {
  38.         this.data = data;
  39.     }
  40.  
  41.     public static <T> Response<T> ok() {
  42.         return createResult(ResponseCode.SUCCESS.getCode(), ResponseCode.SUCCESS.getMessage(), null);
  43.     }
  44.  
  45.     public static <T> Response<T> ok(T data) {
  46.         return createResult(ResponseCode.SUCCESS.getCode(), ResponseCode.SUCCESS.getMessage(), data);
  47.     }
  48.  
  49.     public static <T> Response<T> ok(String message) {
  50.         return createResult(ResponseCode.SUCCESS.getCode(), message, null);
  51.     }
  52.  
  53.     public static <T> Response<T> ok(T data, String message) {
  54.         return createResult(ResponseCode.SUCCESS.getCode(), message, data);
  55.     }
  56.  
  57.     public static <T> Response<T> fail() {
  58.         return createResult(ResponseCode.FAIL.getCode(), ResponseCode.FAIL.getMessage(), null);
  59.     }
  60.  
  61.     public static <T> Response<T> fail(String message) {
  62.         return createResult(null, message, null);
  63.     }
  64.  
  65.     public static <T> Response<T> fail(Integer code, String message) {
  66.         return createResult(code, message, null);
  67.     }
  68.  
  69.     public static <T> Response<T> fail(ResponseCode responseCode) {
  70.         return createResult(responseCode.getCode(), responseCode.getMessage(), null);
  71.     }
  72.  
  73.     public static <T> Response<T> fail(ResponseCode responseCode, T data) {
  74.         return createResult(responseCode.getCode(), responseCode.getMessage(), data);
  75.     }
  76.  
  77.     public static <T> Response<T> fail(ResponseCode responseCode, String message) {
  78.         return createResult(responseCode.getCode(), String.format("%s，%s", responseCode.getMessage(), message), null);
  79.     }
  80.  
  81.     private static <T> Response<T> createResult(Integer code, String message, T data) {
  82.         Response<T> response = new Response<>();
  83.         response.setCode(code);
  84.         response.setMessage(message);
  85.         response.setData(data);
  86.         return response;
  87.     }
  88.  
  89. }
  1. package org.example.repeatsubmit;
  2.  
  3. public enum ResponseCode {
  4.  
  5.     /**
  6.      * 成功
  7.      */
  8.     SUCCESS(200, "成功"),
  9.  
  10.     /**
  11.      * 失败
  12.      */
  13.     FAIL(201, "失败"),
  14.  
  15.     /**
  16.      * 未授权
  17.      */
  18.     UNAUTHORIZED(202, "未授权"),
  19.  
  20.     /**
  21.      * 服务器运行异常
  22.      */
  23.     RUN_TIME_EXCEPTION(500, "服务器运行异常");
  24.  
  25.     ResponseCode(Integer code, String message) {
  26.         this.code = code;
  27.         this.message = message;
  28.     }
  29.  
  30.     /**
  31.      * code
  32.      */
  33.     final Integer code;
  34.  
  35.     /**
  36.      * message desc
  37.      */
  38.     final String message;
  39.  
  40.     public Integer getCode() {
  41.         return code;
  42.     }
  43.  
  44.     public String getMessage() {
  45.         return message;
  46.     }
  47.  
  48. }
  1. package org.example.repeatsubmit;
  2.  
  3. import cn.hutool.core.lang.TypeReference;
  4. import lombok.RequiredArgsConstructor;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Component;
  7. import org.springframework.web.context.request.NativeWebRequest;
  8. import org.springframework.web.context.request.RequestAttributes;
  9. import org.springframework.web.context.request.ServletWebRequest;
  10. import org.springframework.web.servlet.HandlerMapping;
  11. import javax.servlet.http.HttpServletRequest;
  12. import java.util.HashMap;
  13. import java.util.Map;
  14. import java.util.Objects;
  15. import java.util.concurrent.TimeUnit;
  16.  
  17. /**
  18.  * 判断请求url和数据是否和上一次相同，
  19.  * 如果和上次相同，则是重复提交表单。 有效时间为10秒内。
  20.  */
  21. @Component
  22. @RequiredArgsConstructor(onConstructor_ = {@Autowired})
  23. public class SameUrlDataInterceptor extends RepeatSubmitInterceptor {
  24.  
  25.  
  26.     /**
  27.      * 防重提交 redis key
  28.      */
  29.     public static final String REPEAT_SUBMIT_KEY = "repeat_submit:";
  30.  
  31.     /**
  32.      * 重复提交参数key
  33.      */
  34.     public static final String REPEAT_PARAMS = "repeatParams";
  35.  
  36.     /**
  37.      * 重复提交时间key
  38.      */
  39.     public static final String REPEAT_TIME = "repeatTime";
  40.  
  41.     @Override
  42.     public boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit annotation) {
  43.         String nowParams = StringUtils.EMPTY;
  44.  
  45.         if (request instanceof RepeatedlyRequestWrapper) {
  46.             RepeatedlyRequestWrapper repeatedlyRequest = (RepeatedlyRequestWrapper) request;
  47.             nowParams = HttpHelperUtils.getBodyString(repeatedlyRequest);
  48.         }
  49.  
  50.         // body参数为空，获取Parameter的数据
  51.         if (StringUtils.isEmpty(nowParams)) {
  52.             if (MapUtils.isNotEmpty(request.getParameterMap())) {
  53.                 nowParams = JSONUtils.serialize(request.getParameterMap());
  54.             }
  55.         }
  56.  
  57.         // Parameter参数为空，获取@PathVariable的数据
  58.         if (StringUtils.isEmpty(nowParams)) {
  59.             NativeWebRequest webRequest = new ServletWebRequest(request);
  60.             Map<String, Object> mapParams = ConvertUtils.convert(new TypeReference<Map<String, Object>>() {},
  61.                     webRequest.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST));
  62.  
  63.             if (MapUtils.isNotEmpty(mapParams)) {
  64.                 nowParams = JSONUtils.serialize(mapParams);
  65.             }
  66.         }
  67.  
  68.         Map<String, Object> nowDataMap = new HashMap<>(2);
  69.         nowDataMap.put(REPEAT_PARAMS, nowParams);
  70.         nowDataMap.put(REPEAT_TIME, System.currentTimeMillis());
  71.  
  72.         // 请求地址（作为存放cache的key值）
  73.         String url = request.getRequestURI();
  74.  
  75.         // 唯一值（没有消息头则使用请求地址）--------系统可以自定义，目前这里定义：Authorization
  76.         String submitKey = StringUtils.trimToEmpty(request.getHeader("Authorization"));
  77.  
  78.         // 唯一标识（指定key + url + 消息头）
  79.         String cacheRepeatKey = REPEAT_SUBMIT_KEY + url + submitKey;
  80.  
  81.         Object sessionObj = RedisUtils.getCacheObject(cacheRepeatKey);
  82.  
  83.         if (Objects.nonNull(sessionObj)) {
  84.             Map<String, Object> sessionMap = ConvertUtils.convert(new TypeReference<Map<String, Object>>() {}, sessionObj);
  85.  
  86.             if (sessionMap.containsKey(url)) {
  87.                 Map<String, Object> preDataMap = ConvertUtils.convert(new TypeReference<Map<String, Object>>() {}, sessionMap.get(url));
  88.  
  89.                 if (compareParams(nowDataMap, preDataMap) && compareTime(nowDataMap, preDataMap, annotation.interval())) {
  90.                     return true;
  91.                 }
  92.             }
  93.         }
  94.  
  95.         Map<String, Object> cacheMap = new HashMap<>(1);
  96.         cacheMap.put(url, nowDataMap);
  97.         RedisUtils.setCacheObject(cacheRepeatKey, cacheMap, annotation.interval(), TimeUnit.MILLISECONDS);
  98.         return false;
  99.     }
  100.  
  101.     /**
  102.      * 判断参数是否相同
  103.      */
  104.     private boolean compareParams(Map<String, Object> nowMap, Map<String, Object> preMap) {
  105.         String nowParams = (String) nowMap.get(REPEAT_PARAMS);
  106.         String preParams = (String) preMap.get(REPEAT_PARAMS);
  107.         return nowParams.equals(preParams);
  108.     }
  109.  
  110.     /**
  111.      * 判断两次间隔时间
  112.      */
  113.     private boolean compareTime(Map<String, Object> nowMap, Map<String, Object> preMap, int interval) {
  114.         long time1 = (Long) nowMap.get(REPEAT_TIME);
  115.         long time2 = (Long) preMap.get(REPEAT_TIME);
  116.         return (time1 - time2) < interval;
  117.     }
  118.  
  119. }
  1. package org.example.repeatsubmit;
  2.  
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.http.MediaType;
  5. import org.springframework.web.context.request.RequestAttributes;
  6. import org.springframework.web.context.request.RequestContextHolder;
  7. import org.springframework.web.context.request.ServletRequestAttributes;
  8.  
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import javax.servlet.http.HttpSession;
  12. import java.io.PrintWriter;
  13. import java.io.UnsupportedEncodingException;
  14. import java.net.URLDecoder;
  15. import java.net.URLEncoder;
  16. import java.nio.charset.StandardCharsets;
  17. import java.util.Objects;
  18.  
  19. /**
  20.  * 客户端响应工具类
  21.  */
  22. @Slf4j
  23. public class ServletUtils {
  24.  
  25.     /**
  26.      * 获取String参数
  27.      */
  28.     public static String getParameter(String name) {
  29.         return getRequest().getParameter(name);
  30.     }
  31.  
  32.     /**
  33.      * 获取String参数
  34.      */
  35.     public static String getHeader(String name) {
  36.         return getRequest().getHeader(name);
  37.     }
  38.  
  39.     /**
  40.      * 获取String参数
  41.      */
  42.     public static String getParameter(String name, String defaultValue) {
  43.         return ConvertUtils.toStr(getRequest().getParameter(name), defaultValue);
  44.     }
  45.  
  46.     /**
  47.      * 获取Integer参数
  48.      */
  49.     public static Integer getParameterToInt(String name) {
  50.         return ConvertUtils.toInt(getRequest().getParameter(name));
  51.     }
  52.  
  53.     /**
  54.      * 获取Integer参数
  55.      */
  56.     public static Integer getParameterToInt(String name, Integer defaultValue) {
  57.         return ConvertUtils.toInt(getRequest().getParameter(name), defaultValue);
  58.     }
  59.  
  60.     /**
  61.      * 获取Boolean参数
  62.      */
  63.     public static Boolean getParameterToBool(String name) {
  64.         return ConvertUtils.toBool(getRequest().getParameter(name));
  65.     }
  66.  
  67.     /**
  68.      * 获取Boolean参数
  69.      */
  70.     public static Boolean getParameterToBool(String name, Boolean defaultValue) {
  71.         return ConvertUtils.toBool(getRequest().getParameter(name), defaultValue);
  72.     }
  73.  
  74.     /**
  75.      * 获取request
  76.      */
  77.     public static HttpServletRequest getRequest() {
  78.         return getRequestAttributes().getRequest();
  79.     }
  80.  
  81.     /**
  82.      * 获取response
  83.      */
  84.     public static HttpServletResponse getResponse() {
  85.         return getRequestAttributes().getResponse();
  86.     }
  87.  
  88.     /**
  89.      * 获取session
  90.      */
  91.     public static HttpSession getSession() {
  92.         return getRequest().getSession();
  93.     }
  94.  
  95.     public static ServletRequestAttributes getRequestAttributes() {
  96.         RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
  97.         return (ServletRequestAttributes) attributes;
  98.     }
  99.  
  100.     /**
  101.      * 将字符串渲染到客户端
  102.      *
  103.      * @param response 渲染对象
  104.      * @param failed   响应消息
  105.      */
  106.     public static void responseJson(HttpServletResponse response, Response<String> failed) {
  107.         if (Objects.isNull(failed)) {
  108.             return;
  109.         }
  110.  
  111.         response.setCharacterEncoding(StandardCharsets.UTF_8.name());
  112.         response.setContentType(MediaType.APPLICATION_JSON_VALUE);
  113.  
  114.         try (PrintWriter writer = response.getWriter()) {
  115.             String json = JSONUtils.serialize(failed);
  116.             writer.write(json);
  117.             writer.flush();
  118.         } catch (Exception e) {
  119.             log.info("响应失败：", e);
  120.         }
  121.     }
  122.  
  123.     /**
  124.      * 内容编码
  125.      *
  126.      * @param str 内容
  127.      * @return 编码后的内容
  128.      */
  129.     public static String urlEncode(String str) {
  130.         try {
  131.             return URLEncoder.encode(str, StandardCharsets.UTF_8.name());
  132.         } catch (UnsupportedEncodingException e) {
  133.             log.info("内容编码失败：", e);
  134.             return StringUtils.EMPTY;
  135.         }
  136.     }
  137.  
  138.     /**
  139.      * 内容解码
  140.      *
  141.      * @param str 内容
  142.      * @return 解码后的内容
  143.      */
  144.     public static String urlDecode(String str) {
  145.         try {
  146.             return URLDecoder.decode(str, StandardCharsets.UTF_8.name());
  147.         } catch (UnsupportedEncodingException e) {
  148.             log.info("内容解码失败：", e);
  149.             return StringUtils.EMPTY;
  150.         }
  151.     }
  152.  
  153. }
  1. package org.example.repeatsubmit;
  2.  
  3. import cn.hutool.core.text.StrFormatter;
  4. import org.springframework.util.AntPathMatcher;
  5.  
  6. import java.util.Collection;
  7. import java.util.List;
  8. import java.util.Objects;
  9.  
  10. public class StringUtils extends org.apache.commons.lang3.StringUtils {
  11.  
  12.     /**
  13.      * 斜杠
  14.      */
  15.     public static final String SLASH = "/";
  16.  
  17.     /**
  18.      * 点
  19.      */
  20.     public static final String SPOT = ".";
  21.  
  22.     /**
  23.      * 逗号
  24.      */
  25.     public static final String COMMA = ",";
  26.  
  27.     /**
  28.      * 星号
  29.      */
  30.     public static final String ASTERISK = "*";
  31.  
  32.     /**
  33.      * 与符号
  34.      */
  35.     public static final String AMPERSAND = "&";
  36.  
  37.     /**
  38.      * 等号
  39.      */
  40.     public static final String EQUAL = "=";
  41.  
  42.     /**
  43.      * 横杠
  44.      */
  45.     public static final String TRANSVERSE = "-";
  46.  
  47.     /**
  48.      * 下划线
  49.      */
  50.     public static final String SEPARATOR = "_";
  51.  
  52.     /**
  53.      * 空格
  54.      */
  55.     public static final String SPACE = " ";
  56.  
  57.     /**
  58.      * 冒号
  59.      */
  60.     public static final String COLON = ":";
  61.  
  62.     /**
  63.      * * 判断一个对象数组是否为空
  64.      *
  65.      * @param objects 要判断的对象数组
  66.      *                * @return true：为空 false：非空
  67.      */
  68.     public static boolean isEmpty(Object[] objects) {
  69.         return isNull(objects) || (objects.length == 0);
  70.     }
  71.  
  72.     /**
  73.      * * 判断一个对象是否为空
  74.      *
  75.      * @param object Object
  76.      * @return true：为空 false：非空
  77.      */
  78.     public static boolean isNull(Object object) {
  79.         return object == null;
  80.     }
  81.  
  82.     /**
  83.      * * 判断一个Collection是否为空， 包含List，Set，Queue
  84.      *
  85.      * @param coll 要判断的Collection
  86.      * @return true：为空 false：非空
  87.      */
  88.     public static boolean isEmpty(Collection<?> coll) {
  89.         return Objects.isNull(coll) || coll.isEmpty();
  90.     }
  91.  
  92.     /**
  93.      * 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
  94.      *
  95.      * @param str        指定字符串
  96.      * @param characters 需要检查的字符串数组
  97.      * @return 是否匹配
  98.      */
  99.     public static boolean matches(String str, List<String> characters) {
  100.         if (isEmpty(str) || isEmpty(characters)) {
  101.             return false;
  102.         }
  103.  
  104.         for (String pattern : characters) {
  105.             if (isMatch(pattern, str)) {
  106.                 return true;
  107.             }
  108.         }
  109.  
  110.         return false;
  111.     }
  112.  
  113.     /**
  114.      * 判断url是否与规则配置:
  115.      * ? 表示单个字符;
  116.      * * 表示一层路径内的任意字符串，不可跨层级;
  117.      * ** 表示任意层路径;
  118.      *
  119.      * @param pattern 匹配规则
  120.      * @param url     需要匹配的url
  121.      * @return 是否与规则配置结果
  122.      */
  123.     public static boolean isMatch(String pattern, String url) {
  124.         AntPathMatcher matcher = new AntPathMatcher();
  125.         return matcher.match(pattern, url);
  126.     }
  127.  
  128.     /**
  129.      * 格式化文本, {} 表示占位符<br>
  130.      * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
  131.      * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
  132.      * 例：<br>
  133.      * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
  134.      * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
  135.      * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
  136.      *
  137.      * @param template 文本模板，被替换的部分用 {} 表示
  138.      * @param params   参数值
  139.      * @return 格式化后的文本
  140.      */
  141.     public static String format(String template, Object... params) {
  142.         if (isEmpty(params) || isEmpty(template)) {
  143.             return template;
  144.         }
  145.  
  146.         return StrFormatter.format(template, params);
  147.     }
  148.  
  149.  
  150.     /**
  151.      * 驼峰转下划线命名
  152.      */
  153.     public static String toUnderScoreCase(String str) {
  154.         if (Objects.isNull(str)) {
  155.             return null;
  156.         }
  157.  
  158.         StringBuilder sb = new StringBuilder();
  159.         // 前置字符是否大写
  160.         boolean preCharIsUpperCase;
  161.         // 当前字符是否大写
  162.         boolean currentCharIsUpperCase;
  163.         // 下一字符是否大写
  164.         boolean nextCharIsUpperCase = true;
  165.  
  166.         for (int i = 0; i < str.length(); i++) {
  167.             char c = str.charAt(i);
  168.  
  169.             if (i > 0) {
  170.                 preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
  171.             } else {
  172.                 preCharIsUpperCase = false;
  173.             }
  174.  
  175.             currentCharIsUpperCase = Character.isUpperCase(c);
  176.  
  177.             if (i < (str.length() - 1)) {
  178.                 nextCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
  179.             }
  180.  
  181.             if (preCharIsUpperCase && currentCharIsUpperCase && !nextCharIsUpperCase) {
  182.                 sb.append(SEPARATOR);
  183.             } else if ((i != 0 && !preCharIsUpperCase) && currentCharIsUpperCase) {
  184.                 sb.append(SEPARATOR);
  185.             }
  186.  
  187.             sb.append(Character.toLowerCase(c));
  188.         }
  189.  
  190.         return sb.toString();
  191.     }
  192.  
  193. }
  1. package org.example.rate;
  2.  
  3. import org.springframework.aop.framework.AopContext;
  4. import org.springframework.beans.BeansException;
  5. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
  6. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
  7. import org.springframework.context.ApplicationContext;
  8. import org.springframework.context.ApplicationContextAware;
  9. import org.springframework.lang.NonNull;
  10. import org.springframework.stereotype.Component;
  11.  
  12. /**
  13.  * spring 工具类
  14.  */
  15. @Component
  16. public class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware {
  17.  
  18.     /**
  19.      * Spring应用上下文环境
  20.      */
  21.     private static ConfigurableListableBeanFactory beanFactory;
  22.  
  23.     private static ApplicationContext applicationContext;
  24.  
  25.     @Override
  26.     public void postProcessBeanFactory(@NonNull ConfigurableListableBeanFactory beanFactory) throws BeansException {
  27.         SpringUtils.beanFactory = beanFactory;
  28.     }
  29.  
  30.     /**
  31.      * private static ConfigurableListableBeanFactory beanFactory;
  32.      * SpringUtils.applicationContext = applicationContext;
  33.      */
  34.     @Override
  35.     public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException {
  36.         SpringUtils.applicationContext = applicationContext;
  37.     }
  38.  
  39.     /**
  40.      * 获取对象
  41.      *
  42.      * @param name  bean名称
  43.      * @param clazz 待获取类型
  44.      * @return Object 一个以所给名字注册的bean的实例
  45.      */
  46.     public static <T> T getBean(String name, Class<T> clazz) {
  47.         return beanFactory.getBean(name, clazz);
  48.     }
  49.  
  50.     /**
  51.      * 获取类型为requiredType的对象
  52.      *
  53.      * @param clz 类型
  54.      * @return Object 一个以所给类型注册的bean的实例
  55.      */
  56.     public static <T> T getBean(Class<T> clz) {
  57.         return beanFactory.getBean(clz);
  58.     }
  59.  
  60.     /**
  61.      * 发布一个事件
  62.      *
  63.      * @param event 事件
  64.      */
  65.     public static void publishEvent(Object event) {
  66.         applicationContext.publishEvent(event);
  67.     }
  68.  
  69.     /**
  70.      * 获取当前代理bean
  71.      * @param t 待获取bean类型
  72.      * @param <T> 泛型
  73.      * @return 当前代理bean
  74.      */
  75.     public static <T> T getCurrentProxyBean(Class<T> t) {
  76.        return ConvertUtils.convert(t, AopContext.currentProxy());
  77.     }
  78.  
  79. }

最后写springmvc拦截

  1. package org.example.repeatsubmit;
  2.  
  3. import lombok.RequiredArgsConstructor;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.http.MediaType;
  7. import org.springframework.http.converter.HttpMessageConverter;
  8. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
  9. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  10. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  11.  
  12. import java.nio.charset.StandardCharsets;
  13. import java.util.ArrayList;
  14. import java.util.List;
  15.  
  16. @Configuration
  17. @RequiredArgsConstructor(onConstructor_ = {@Autowired})
  18. public class WebMvcConfig implements WebMvcConfigurer {
  19.  
  20.     private final RepeatSubmitInterceptor repeatSubmitInterceptor;
  21.  
  22.     /**
  23.      * 解决低版本ie @ResponseBody返回json的时候提示下载问题 Jackson处理
  24.      */
  25.     public MappingJackson2HttpMessageConverter customJackson2HttpMessageConverter() {
  26.         MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
  27.         List<MediaType> supportedMediaTypes = new ArrayList<>();
  28.         MediaType media = new MediaType(MediaType.TEXT_PLAIN, StandardCharsets.UTF_8);
  29.         supportedMediaTypes.add(media);
  30.         jsonConverter.setSupportedMediaTypes(supportedMediaTypes);
  31.         return jsonConverter;
  32.     }
  33.  
  34.     @Override
  35.     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  36.         converters.add(customJackson2HttpMessageConverter());
  37.     }
  38.  
  39.     /**
  40.      * 自定义拦截规则
  41.      */
  42.     @Override
  43.     public void addInterceptors(InterceptorRegistry registry) {
  44.         registry.addInterceptor(repeatSubmitInterceptor)
  45.                 .addPathPatterns("/**");
  46.     }
  47.  
  48. }

测试代码

  1.     @RepeatSubmit(interval = 1000)
  2.     @PostMapping("/repeatSubmit")
  3.     public String repeatSubmit(@RequestParam String test){
  4.         log.info("repeatSubmit--test--->"+test);
  5.         return "ok";
  6.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/550763
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号