SpringBoot：基于redis自定义注解实现后端接口防重复提交校验

转x33g5p2x  于2022-02-07 转载在 Spring  
字(16.9k)|赞(0)|评价(0)|浏览(516)

SpringBoot：基于redis自定义注解实现后端接口防重复提交校验

一、添加依赖

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-redis</artifactId>
  4.             <version>1.4.4.RELEASE</version>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>redis.clients</groupId>
  8.             <artifactId>jedis</artifactId>
  9.             <version>3.6.3</version>
  10.         </dependency>
  11. 		<dependency>
  12.             <groupId>com.alibaba</groupId>
  13.             <artifactId>fastjson</artifactId>
  14.             <version>1.2.75</version>
  15.         </dependency>

二、代码实现

1.构建可重复读取inputStream的request

  1. package com.hl.springbootrepetitionsubmit.servlet;
  2.  
  3.  
  4. import javax.servlet.*;
  5. import javax.servlet.http.*;
  6. import java.io.*;
  7. import java.nio.charset.StandardCharsets;
  9. /**
  10.  * 构建可重复读取inputStream的request
  11.  */
  12. public class RepeatedlyRequestWrapper extends HttpServletRequestWrapper {
  13.     private final String body;
  14.  
  15.     public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws IOException {
  16.         super(request);
  17.         request.setCharacterEncoding("UTF-8");
  18.         response.setCharacterEncoding("UTF-8");
  19.  
  20.         body = getBodyString(request);
  21.     }
  22.  
  23.     @Override
  24.     public BufferedReader getReader() throws IOException {
  25.         return new BufferedReader(new InputStreamReader(getInputStream()));
  26.     }
  27.  
  28.     public String getBody() {
  29.         return body;
  30.     }
  31.  
  32.     @Override
  33.     public ServletInputStream getInputStream() throws IOException {
  34.         final ByteArrayInputStream bais = new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8));
  35.         return new ServletInputStream() {
  36.             @Override
  37.             public int read() throws IOException {
  38.                 return bais.read();
  39.             }
  40.  
  41.             @Override
  42.             public int available() throws IOException {
  43.                 return body.length();
  44.             }
  45.  
  46.             @Override
  47.             public boolean isFinished() {
  48.                 return false;
  49.             }
  50.  
  51.             @Override
  52.             public boolean isReady() {
  53.                 return false;
  54.             }
  55.  
  56.             @Override
  57.             public void setReadListener(ReadListener readListener) {
  58.  
  59.             }
  60.         };
  61.     }
  62.  
  63.     /**
  64.      * 获取Request请求body内容
  65.      *
  66.      * @param request
  67.      * @return
  68.      */
  69.     private String getBodyString(ServletRequest request) {
  70.         StringBuilder sb = new StringBuilder();
  71.         BufferedReader reader = null;
  72.         try (InputStream inputStream = request.getInputStream()) {
  73.             reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8));
  74.             String line = "";
  75.             while ((line = reader.readLine()) != null) {
  76.                 sb.append(line);
  77.             }
  78.         } catch (IOException e) {
  79.             e.printStackTrace();
  80.         } finally {
  81.             if (reader != null) {
  82.                 try {
  83.                     reader.close();
  84.                 } catch (IOException e) {
  85.                     e.printStackTrace();
  86.                 }
  87.             }
  88.         }
  89.         return sb.toString();
  90.     }
  91. }

2.重写request

  1. package com.hl.springbootrepetitionsubmit.filter;
  2.  
  4. import com.hl.springbootrepetitionsubmit.servlet.RepeatedlyRequestWrapper;
  5. import org.springframework.http.MediaType;
  6. import org.springframework.util.StringUtils;
  7.  
  8. import javax.servlet.*;
  9. import javax.servlet.http.HttpServletRequest;
  10. import java.io.IOException;
  11.  
  12. /**
  13.  * 过滤器（重写request）
  14.  */
  15. public class RepeatableFilter implements Filter {
  16.     @Override
  17.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  18.         ServletRequest requestWrapper = null;
  19.         //将原生的request变为可重复读取inputStream的request
  20.         if (request instanceof HttpServletRequest
  21.                 && StringUtils.startsWithIgnoreCase(request.getContentType(), MediaType.APPLICATION_JSON_VALUE)) {
  22.             requestWrapper = new RepeatedlyRequestWrapper((HttpServletRequest) request, response);
  23.         }
  24.         if (null == requestWrapper) {
  25.             chain.doFilter(request, response);
  26.         } else {
  27.             chain.doFilter(requestWrapper, response);
  28.         }
  29.     }
  30. }

3.自定义注解

  1. /**
  2.  * 自定义注解防止表单重复提交
  3.  */
  4. @Inherited
  5. @Target(ElementType.METHOD)
  6. @Retention(RetentionPolicy.RUNTIME)
  7. @Documented
  8. public @interface RepeatSubmit {
  9. }

4.创建防止重复提交拦截器

  1. package com.hl.springbootrepetitionsubmit.interceptor;
  2.  
  3. import cn.hutool.core.util.StrUtil;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.hl.springbootrepetitionsubmit.annotation.RepeatSubmit;
  6. import com.hl.springbootrepetitionsubmit.config.RedisUtil;
  7. import com.hl.springbootrepetitionsubmit.servlet.RepeatedlyRequestWrapper;
  8. import org.springframework.beans.factory.annotation.*;
  9. import org.springframework.stereotype.Component;
  10. import org.springframework.web.method.HandlerMethod;
  11. import org.springframework.web.servlet.HandlerInterceptor;
  12.  
  13. import javax.servlet.http.*;
  14. import java.io.IOException;
  15. import java.lang.reflect.Method;
  16. import java.util.*;
  17. import java.util.concurrent.TimeUnit;
  18.  
  19. /**
  20.  * 防止重复提交拦截器
  21.  */
  22. @Component
  23. public class RepeatSubmitInterceptor implements HandlerInterceptor {
  24.     public final String REPEAT_PARAMS = "repeatParams";
  25.  
  26.     public final String REPEAT_TIME = "repeatTime";
  27.     /**
  28.      * 防重提交 redis key
  29.      */
  30.     public final String REPEAT_SUBMIT_KEY = "repeat_submit:";
  31.  
  32.     // 令牌自定义标识
  33.     @Value("${token.header}")
  34.     private String header;
  35.  
  36.     @Autowired
  37.     private RedisUtil redisUtil;
  38.  
  39.     /**
  40.      * 间隔时间，单位:秒
  41.      * <p>
  42.      * 两次相同参数的请求，如果间隔时间大于该参数，系统不会认定为重复提交的数据
  43.      */
  44.     @Value("${repeatSubmit.intervalTime}")
  45.     private int intervalTime;
  46.  
  47.     @Override
  48.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  49.         if (handler instanceof HandlerMethod) {
  50.             HandlerMethod handlerMethod = (HandlerMethod) handler;
  51.             Method method = handlerMethod.getMethod();
  52.             RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
  53.             if (annotation != null) {
  54.                 if (this.isRepeatSubmit(request)) {
  55.                     //返回重复提交提示
  56.                     Map<String, Object> resultMap = new HashMap<>();
  57.                     resultMap.put("code", "500");
  58.                     resultMap.put("msg", request.getRequestURI() + "不允许重复提交，请稍后再试");
  59.                     try {
  60.                         response.setStatus(200);
  61.                         response.setContentType("application/json");
  62.                         response.setCharacterEncoding("utf-8");
  63.                         response.getWriter().print(JSONObject.toJSONString(resultMap));
  64.                     } catch (IOException e) {
  65.                         e.printStackTrace();
  66.                     }
  67.                     return false;
  68.                 }
  69.             }
  70.             return true;
  71.         } else {
  72.             return preHandle(request, response, handler);
  73.         }
  74.     }
  75.  
  76.     /**
  77.      * 验证是否重复提交由子类实现具体的防重复提交的规则
  78.      */
  79.     public boolean isRepeatSubmit(HttpServletRequest request) {
  80.         String nowParams = "";
  81.         if (request instanceof RepeatedlyRequestWrapper) {
  82.             RepeatedlyRequestWrapper repeatedlyRequest = (RepeatedlyRequestWrapper) request;
  83.             nowParams = repeatedlyRequest.getBody();
  84.         }
  85.         // body参数为空，获取Parameter的数据
  86.         if (StrUtil.isBlank(nowParams)) {
  87.             nowParams = JSONObject.toJSONString(request.getParameterMap());
  88.         }
  89.         Map<String, Object> nowDataMap = new HashMap<String, Object>();
  90.         nowDataMap.put(REPEAT_PARAMS, nowParams);
  91.         nowDataMap.put(REPEAT_TIME, System.currentTimeMillis());
  92.  
  93.         // 请求地址（作为存放cache的key值）
  94.         String url = request.getRequestURI();
  95.  
  96.         // 唯一值（没有消息头则使用请求地址）
  97.         String submitKey = request.getHeader(header);
  98.         if (StrUtil.isBlank(submitKey)) {
  99.             submitKey = url;
  100.         }
  101.  
  102.         // 唯一标识（指定key + 消息头）
  103.         String cacheRepeatKey = REPEAT_SUBMIT_KEY + submitKey;
  104.  
  105.         Object sessionObj = redisUtil.getCacheObject(cacheRepeatKey);
  106.         if (sessionObj != null) {
  107.             Map<String, Object> sessionMap = (Map<String, Object>) sessionObj;
  108.             if (sessionMap.containsKey(url)) {
  109.                 Map<String, Object> preDataMap = (Map<String, Object>) sessionMap.get(url);
  110.                 if (compareParams(nowDataMap, preDataMap) && compareTime(nowDataMap, preDataMap)) {
  111.                     return true;
  112.                 }
  113.             }
  114.         }
  115.         Map<String, Object> cacheMap = new HashMap<String, Object>();
  116.         cacheMap.put(url, nowDataMap);
  117.         redisUtil.setCacheObject(cacheRepeatKey, cacheMap, intervalTime, TimeUnit.SECONDS);
  118.         return false;
  119.     }
  120.  
  121.     /**
  122.      * 判断参数是否相同
  123.      */
  124.     private boolean compareParams(Map<String, Object> nowMap, Map<String, Object> preMap) {
  125.         String nowParams = (String) nowMap.get(REPEAT_PARAMS);
  126.         String preParams = (String) preMap.get(REPEAT_PARAMS);
  127.         return nowParams.equals(preParams);
  128.     }
  129.  
  130.     /**
  131.      * 判断两次间隔时间
  132.      */
  133.     private boolean compareTime(Map<String, Object> nowMap, Map<String, Object> preMap) {
  134.         long time1 = (Long) nowMap.get(REPEAT_TIME);
  135.         long time2 = (Long) preMap.get(REPEAT_TIME);
  136.         if ((time1 - time2) < (this.intervalTime * 1000L)) {
  137.             return true;
  138.         }
  139.         return false;
  140.     }
  141.  
  142.  
  143. }

5.redis配置

  1. package com.hl.springbootrepetitionsubmit.config;
  3. import org.springframework.cache.CacheManager;
  4. import org.springframework.cache.annotation.CachingConfigurerSupport;
  5. import org.springframework.cache.interceptor.KeyGenerator;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  9. import org.springframework.data.redis.cache.RedisCacheManager;
  10. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
  11. import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
  12. import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  13. import org.springframework.data.redis.core.RedisTemplate;
  14. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
  15. import org.springframework.data.redis.serializer.RedisSerializationContext;
  16. import org.springframework.data.redis.serializer.StringRedisSerializer;
  17. import redis.clients.jedis.JedisPool;
  18. import redis.clients.jedis.JedisPoolConfig;
  19. import java.time.Duration;
  21. @Configuration
  22. public class RedisConfig extends CachingConfigurerSupport {
  24.     //配置redis的过期时间
  25.     private static final Duration TIME_TO_LIVE = Duration.ZERO;
  27.     @Bean(name = "jedisPoolConfig")
  28.     public JedisPoolConfig jedisPoolConfig() {
  29.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
  30.         //控制一个pool可分配多少个jedis实例
  31.         jedisPoolConfig.setMaxTotal(500);
  32.         //最大空闲数
  33.         jedisPoolConfig.setMaxIdle(200);
  34.         //每次释放连接的最大数目，默认是3
  35.         jedisPoolConfig.setNumTestsPerEvictionRun(1024);
  36.         //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
  37.         jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
  38.         //连接的最小空闲时间 默认1800000毫秒(30分钟)
  39.         jedisPoolConfig.setMinEvictableIdleTimeMillis(-1);
  40.         jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(10000);
  41.         //最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
  42.         jedisPoolConfig.setMaxWaitMillis(1500);
  43.         jedisPoolConfig.setTestOnBorrow(true);
  44.         jedisPoolConfig.setTestWhileIdle(true);
  45.         jedisPoolConfig.setTestOnReturn(false);
  46.         jedisPoolConfig.setJmxEnabled(true);
  47.         jedisPoolConfig.setBlockWhenExhausted(false);
  48.         return jedisPoolConfig;
  49.     }
  51.     @Bean("connectionFactory")
  52.     public JedisConnectionFactory connectionFactory() {
  53.         RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
  54.         redisStandaloneConfiguration.setHostName("127.0.0.1");
  55.         redisStandaloneConfiguration.setDatabase(0);
  56. //        redisStandaloneConfiguration.setPassword(RedisPassword.of("123456"));
  57.         redisStandaloneConfiguration.setPort(6379);
  58.         //获得默认的连接池构造器
  59.         JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
  60.                 (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
  61.         //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！）
  62.         jpcb.poolConfig(jedisPoolConfig());
  63.         //通过构造器来构造jedis客户端配置
  64.         JedisClientConfiguration jedisClientConfiguration = jpcb.build();
  65.         //单机配置 + 客户端配置 = jedis连接工厂
  66.         return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
  67.     }
  69.     @Bean("jedisPool")
  70.     public JedisPool jedisPool(){
  71.         return new JedisPool(jedisPoolConfig(),"127.0.0.1",6379);
  72.     }
  74.     @Bean
  75.     public RedisTemplate<Object, Object> redisTemplate(JedisConnectionFactory connectionFactory) {
  76.         RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
  77.         redisTemplate.setConnectionFactory(connectionFactory);
  79.         GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  80.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  81.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  82.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  83.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  85.         //初始化参数和初始化工作
  86.         redisTemplate.afterPropertiesSet();
  87.         return redisTemplate;
  88.     }
  90.     /**
  91.      * 缓存对象集合中，缓存是以key-value形式保存的,
  92.      * 当不指定缓存的key时，SpringBoot会使用keyGenerator生成Key。
  93.      */
  94.     @Override
  95.     @Bean
  96.     public KeyGenerator keyGenerator() {
  97.         return (target, method, params) -> {
  98.             StringBuilder sb = new StringBuilder();
  99.             //类名+方法名
  100.             sb.append(target.getClass().getName());
  101.             sb.append(method.getName());
  102.             for (Object obj : params) {
  103.                 sb.append(obj.toString());
  104.             }
  105.             return sb.toString();
  106.         };
  107.     }
  109.     /**
  110.      * 缓存管理器
  111.      * @param connectionFactory 连接工厂
  112.      * @return  cacheManager
  113.      */
  114.     @Bean
  115.     public CacheManager cacheManager(JedisConnectionFactory connectionFactory) {
  116.         //新建一个Jackson2JsonRedis的redis存储的序列化方式
  117.         GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
  118.         //解决查询缓存转换异常的问题
  119.         // 配置序列化（解决乱码的问题）
  120.         //entryTtl设置过期时间
  121.         //serializeValuesWith设置redis存储的序列化方式
  122.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
  123.                 .entryTtl(TIME_TO_LIVE)
  124.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
  125.                 .disableCachingNullValues();
  126.         //定义要返回的redis缓存管理对象
  127.         return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).build();
  128.     }
  129. }

6.redis工具类

  1. package com.hl.springbootrepetitionsubmit.config;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.BoundSetOperations;
  5. import org.springframework.data.redis.core.HashOperations;
  6. import org.springframework.data.redis.core.RedisTemplate;
  7. import org.springframework.data.redis.core.ValueOperations;
  8. import org.springframework.stereotype.Component;
  9.  
  10. import java.util.*;
  11. import java.util.concurrent.TimeUnit;
  12.  
  13. @Component
  14. public class RedisUtil {
  16.     @Autowired
  17.     private RedisTemplate redisTemplate;
  18.  
  19.     /**
  20.      * 缓存基本的对象，Integer、String、实体类等
  21.      *
  22.      * @param key   缓存的键值
  23.      * @param value 缓存的值
  24.      */
  25.     public <T> void setCacheObject(final String key, final T value) {
  26.         redisTemplate.opsForValue().set(key, value);
  27.     }
  28.  
  29.     /**
  30.      * 缓存基本的对象，Integer、String、实体类等
  31.      *
  32.      * @param key      缓存的键值
  33.      * @param value    缓存的值
  34.      * @param timeout  时间
  35.      * @param timeUnit 时间颗粒度
  36.      */
  37.     public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
  38.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  39.     }
  40.  
  41.     /**
  42.      * 设置有效时间
  43.      *
  44.      * @param key     Redis键
  45.      * @param timeout 超时时间
  46.      * @return true=设置成功；false=设置失败
  47.      */
  48.     public boolean expire(final String key, final long timeout) {
  49.         return expire(key, timeout, TimeUnit.SECONDS);
  50.     }
  51.  
  52.     /**
  53.      * 设置有效时间
  54.      *
  55.      * @param key     Redis键
  56.      * @param timeout 超时时间
  57.      * @param unit    时间单位
  58.      * @return true=设置成功；false=设置失败
  59.      */
  60.     public boolean expire(final String key, final long timeout, final TimeUnit unit) {
  61.         return redisTemplate.expire(key, timeout, unit);
  62.     }
  63.  
  64.     /**
  65.      * 获得缓存的基本对象。
  66.      *
  67.      * @param key 缓存键值
  68.      * @return 缓存键值对应的数据
  69.      */
  70.     public <T> T getCacheObject(final String key) {
  71.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  72.         return operation.get(key);
  73.     }
  74.  
  75.     /**
  76.      * 删除单个对象
  77.      *
  78.      * @param key
  79.      */
  80.     public boolean deleteObject(final String key) {
  81.         return redisTemplate.delete(key);
  82.     }
  83.  
  84.     /**
  85.      * 删除集合对象
  86.      *
  87.      * @param collection 多个对象
  88.      * @return
  89.      */
  90.     public long deleteObject(final Collection collection) {
  91.         return redisTemplate.delete(collection);
  92.     }
  93.  
  94.     /**
  95.      * 缓存List数据
  96.      *
  97.      * @param key      缓存的键值
  98.      * @param dataList 待缓存的List数据
  99.      * @return 缓存的对象
  100.      */
  101.     public <T> long setCacheList(final String key, final List<T> dataList) {
  102.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  103.         return count == null ? 0 : count;
  104.     }
  105.  
  106.     /**
  107.      * 获得缓存的list对象
  108.      *
  109.      * @param key 缓存的键值
  110.      * @return 缓存键值对应的数据
  111.      */
  112.     public <T> List<T> getCacheList(final String key) {
  113.         return redisTemplate.opsForList().range(key, 0, -1);
  114.     }
  115.  
  116.     /**
  117.      * 缓存Set
  118.      *
  119.      * @param key     缓存键值
  120.      * @param dataSet 缓存的数据
  121.      * @return 缓存数据的对象
  122.      */
  123.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
  124.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  125.         Iterator<T> it = dataSet.iterator();
  126.         while (it.hasNext()) {
  127.             setOperation.add(it.next());
  128.         }
  129.         return setOperation;
  130.     }
  131.  
  132.     /**
  133.      * 获得缓存的set
  134.      *
  135.      * @param key
  136.      * @return
  137.      */
  138.     public <T> Set<T> getCacheSet(final String key) {
  139.         return redisTemplate.opsForSet().members(key);
  140.     }
  141.  
  142.     /**
  143.      * 缓存Map
  144.      *
  145.      * @param key
  146.      * @param dataMap
  147.      */
  148.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
  149.         if (dataMap != null) {
  150.             redisTemplate.opsForHash().putAll(key, dataMap);
  151.         }
  152.     }
  153.  
  154.     /**
  155.      * 获得缓存的Map
  156.      *
  157.      * @param key
  158.      * @return
  159.      */
  160.     public <T> Map<String, T> getCacheMap(final String key) {
  161.         return redisTemplate.opsForHash().entries(key);
  162.     }
  163.  
  164.     /**
  165.      * 往Hash中存入数据
  166.      *
  167.      * @param key   Redis键
  168.      * @param hKey  Hash键
  169.      * @param value 值
  170.      */
  171.     public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
  172.         redisTemplate.opsForHash().put(key, hKey, value);
  173.     }
  174.  
  175.     /**
  176.      * 获取Hash中的数据
  177.      *
  178.      * @param key  Redis键
  179.      * @param hKey Hash键
  180.      * @return Hash中的对象
  181.      */
  182.     public <T> T getCacheMapValue(final String key, final String hKey) {
  183.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  184.         return opsForHash.get(key, hKey);
  185.     }
  186.  
  187.     /**
  188.      * 获取多个Hash中的数据
  189.      *
  190.      * @param key   Redis键
  191.      * @param hKeys Hash键集合
  192.      * @return Hash对象集合
  193.      */
  194.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
  195.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  196.     }
  197.  
  198.     /**
  199.      * 获得缓存的基本对象列表
  200.      *
  201.      * @param pattern 字符串前缀
  202.      * @return 对象列表
  203.      */
  204.     public Collection<String> keys(final String pattern) {
  205.         return redisTemplate.keys(pattern);
  206.     }
  207. }

7.配置拦截器

  1. /**
  2.  * 防重复提交配置
  3.  */
  4. @Configuration
  5. public class RepeatSubmitConfig implements WebMvcConfigurer {
  7.     @Autowired
  8.     private RepeatSubmitInterceptor repeatSubmitInterceptor;
  9.     /**
  10.      * 添加防重复提交拦截
  11.      */
  12.     @Override
  13.     public void addInterceptors(InterceptorRegistry registry) {
  14.         registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("/**");
  15.     }
  16.  
  17.     /**
  18.      * 生成防重复提交过滤器（重写request）
  19.      * @return FilterRegistrationBean
  20.      */
  21.     @SuppressWarnings({ "rawtypes", "unchecked" })
  22.     @Bean
  23.     public FilterRegistrationBean<?> createRepeatableFilter() {
  24.         FilterRegistrationBean registration = new FilterRegistrationBean();
  25.         registration.setFilter(new RepeatableFilter());
  26.         registration.addUrlPatterns("/*");
  27.         registration.setName("repeatableFilter");
  28.         registration.setOrder(FilterRegistrationBean.LOWEST_PRECEDENCE);
  29.         return registration;
  30.     }
  31. }

8.controller

  1. @RestController
  2. @RequestMapping("/repeatSubmit")
  3. public class RepeatSubmitController {
  4.     /**
  5.      * 保存Param
  6.      * @param name
  7.      * @return
  8.      */
  9.     @RepeatSubmit
  10.     @PostMapping("/saveParam/{name}")
  11.     public String saveParam(@PathVariable("name")String name){
  12.         return "保存Param成功";
  13.     }
  14.     /**
  15.      * 保存Param
  16.      * @param name
  17.      * @return
  18.      */
  19.     @RepeatSubmit
  20.     @PostMapping("/saveBody")
  21.     public String saveBody(@RequestBody List<String> name){
  22.         return "保存Body成功";
  23.     }
  24. }

三、测试

param传参：

body传参：

项目源码

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/weixin_43296313/article/details/122626305

内容来源于网络，如有侵权，请联系作者删除！

redisspringboot后端

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com