devbox
数据结构灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot集成图片验证+redis缓存一步到位_spring boot 图片拖坠验证码实现

作者：数据结构灵魂 | 2024-01-30 12:38:50

赞

踩

spring boot 图片拖坠验证码实现

1.图片验证与缓存依赖：

  1.     <dependencies>
  2. <!--        验证码-->
  3.         <dependency>
  4.             <groupId>com.github.whvcse</groupId>
  5.             <artifactId>easy-captcha</artifactId>
  6.             <version>1.6.2</version>
  7.         </dependency>
  8. <!--        redis-->
  9.         <dependency>
  10.             <groupId>org.springframework.boot</groupId>
  11.             <artifactId>spring-boot-starter-data-redis</artifactId>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>org.apache.commons</groupId>
  15.             <artifactId>commons-pool2</artifactId>
  16.         </dependency>
  17.     </dependencies>

2.redis配置:在application.properties中加入配置

  1. spring.redis.host=localhost
  2. spring.redis.port=6379
  3. spring.redis.database= 0
  4. spring.redis.timeout=1800000
  5. spring.redis.lettuce.pool.max-active=20
  6. spring.redis.lettuce.pool.max-wait=-1
  7. #最大阻塞等待时间(负数表示没限制)
  8. spring.redis.lettuce.pool.max-idle=5
  9. spring.redis.lettuce.pool.min-idle=0
  10. #最小空闲

3.redis工具类：

        注意之所以每加static是因为咱们是注入形式调用的，而不是通过类名调用，这里是通过spring对象帮我们调用。注意！！！同时@component注解不要忘记加！

  1. package com.laoyang.educms.utils;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.util.CollectionUtils;
  7.  
  8. import javax.annotation.Resource;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Set;
  12. import java.util.concurrent.TimeUnit;
  13.  
  14. /**
  15.  * @author:Kevin
  16.  * @create: 2022-10-05 14:30
  17.  * @Description:
  18.  */
  19. @Component
  20. public class redisutils {
  21.     @Autowired
  22.     private  RedisTemplate<String, Object> redisTemplate;
  23.  
  24.     // =============================common============================
  25.  
  26.     /**
  27.      * 指定缓存失效时间
  28.      *
  29.      * @param key  键
  30.      * @param time 时间(秒)
  31.      */
  32.     public   boolean expire(String key, long time) {
  33.         try {
  34.             if (time > 0) {
  35.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  36.             }
  37.             return true;
  38.         } catch (Exception e) {
  39.             e.printStackTrace();
  40.             return false;
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * 根据key 获取过期时间
  46.      *
  47.      * @param key 键 不能为null
  48.      * @return 时间(秒) 返回0代表为永久有效
  49.      */
  50.     public  long getExpire(String key) {
  51.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  52.     }
  53.  
  54.  
  55.     /**
  56.      * 判断key是否存在
  57.      *
  58.      * @param key 键
  59.      * @return true 存在 false不存在
  60.      */
  61.     public  boolean hasKey(String key) {
  62.         try {
  63.             return redisTemplate.hasKey(key);
  64.         } catch (Exception e) {
  65.             e.printStackTrace();
  66.             return false;
  67.         }
  68.     }
  69.  
  70.  
  71.     /**
  72.      * 删除缓存
  73.      *
  74.      * @param key 可以传一个值 或多个
  75.      */
  76.     @SuppressWarnings("unchecked")
  77.     public  void del(String... key) {
  78.         if (key != null && key.length > 0) {
  79.             if (key.length == 1) {
  80.                 redisTemplate.delete(key[0]);
  81.             } else {
  82.                 redisTemplate.delete(CollectionUtils.arrayToList(key));
  83.             }
  84.         }
  85.     }
  86.  
  87.  
  88.     // ============================String=============================
  89.  
  90.     /**
  91.      * 普通缓存获取
  92.      *
  93.      * @param key 键
  94.      * @return 值
  95.      */
  96.     public  Object get(String key) {
  97.         return key == null ? null : redisTemplate.opsForValue().get(key);
  98.     }
  99.  
  100.     /**
  101.      * 普通缓存放入
  102.      *
  103.      * @param key   键
  104.      * @param value 值
  105.      * @return true成功 false失败
  106.      */
  107.  
  108.     public  boolean set(String key, Object value) {
  109.         try {
  110.             redisTemplate.opsForValue().set(key, value);
  111.             return true;
  112.         } catch (Exception e) {
  113.             e.printStackTrace();
  114.             return false;
  115.         }
  116.     }
  117.  
  118.  
  119.     /**
  120.      * 普通缓存放入并设置时间
  121.      *
  122.      * @param key   键
  123.      * @param value 值
  124.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
  125.      * @return true成功 false 失败
  126.      */
  127.  
  128.     public  boolean set(String key, Object value, long time) {
  129.         try {
  130.             if (time > 0) {
  131.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  132.             } else {
  133.                 set(key, value);
  134.             }
  135.             return true;
  136.         } catch (Exception e) {
  137.             e.printStackTrace();
  138.             return false;
  139.         }
  140.     }
  141.  
  142.  
  143.     /**
  144.      * 递增
  145.      *
  146.      * @param key   键
  147.      * @param delta 要增加几(大于0)
  148.      */
  149.     public  long incr(String key, long delta) {
  150.         if (delta < 0) {
  151.             throw new RuntimeException("递增因子必须大于0");
  152.         }
  153.         return redisTemplate.opsForValue().increment(key, delta);
  154.     }
  155.  
  156.  
  157.     /**
  158.      * 递减
  159.      *
  160.      * @param key   键
  161.      * @param delta 要减少几(小于0)
  162.      */
  163.     public  long decr(String key, long delta) {
  164.         if (delta < 0) {
  165.             throw new RuntimeException("递减因子必须大于0");
  166.         }
  167.         return redisTemplate.opsForValue().increment(key, -delta);
  168.     }
  169.  
  170.  
  171.     // ================================Map=================================
  172.  
  173.     /**
  174.      * HashGet
  175.      *
  176.      * @param key  键 不能为null
  177.      * @param item 项 不能为null
  178.      */
  179.     public  Object hget(String key, String item) {
  180.         return redisTemplate.opsForHash().get(key, item);
  181.     }
  182.  
  183.     /**
  184.      * 获取hashKey对应的所有键值
  185.      *
  186.      * @param key 键
  187.      * @return 对应的多个键值
  188.      */
  189.     public  Map<Object, Object> hmget(String key) {
  190.         return redisTemplate.opsForHash().entries(key);
  191.     }
  192.  
  193.     /**
  194.      * HashSet
  195.      *
  196.      * @param key 键
  197.      * @param map 对应多个键值
  198.      */
  199.     public  boolean hmset(String key, Map<String, Object> map) {
  200.         try {
  201.             redisTemplate.opsForHash().putAll(key, map);
  202.             return true;
  203.         } catch (Exception e) {
  204.             e.printStackTrace();
  205.             return false;
  206.         }
  207.     }
  208.  
  209.  
  210.     /**
  211.      * HashSet 并设置时间
  212.      *
  213.      * @param key  键
  214.      * @param map  对应多个键值
  215.      * @param time 时间(秒)
  216.      * @return true成功 false失败
  217.      */
  218.     public  boolean hmset(String key, Map<String, Object> map, long time) {
  219.         try {
  220.             redisTemplate.opsForHash().putAll(key, map);
  221.             if (time > 0) {
  222.                 expire(key, time);
  223.             }
  224.             return true;
  225.         } catch (Exception e) {
  226.             e.printStackTrace();
  227.             return false;
  228.         }
  229.     }
  230.  
  231.  
  232.     /**
  233.      * 向一张hash表中放入数据,如果不存在将创建
  234.      *
  235.      * @param key   键
  236.      * @param item  项
  237.      * @param value 值
  238.      * @return true 成功 false失败
  239.      */
  240.     public  boolean hset(String key, String item, Object value) {
  241.         try {
  242.             redisTemplate.opsForHash().put(key, item, value);
  243.             return true;
  244.         } catch (Exception e) {
  245.             e.printStackTrace();
  246.             return false;
  247.         }
  248.     }
  249.  
  250.     /**
  251.      * 向一张hash表中放入数据,如果不存在将创建
  252.      *
  253.      * @param key   键
  254.      * @param item  项
  255.      * @param value 值
  256.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  257.      * @return true 成功 false失败
  258.      */
  259.     public  boolean hset(String key, String item, Object value, long time) {
  260.         try {
  261.             redisTemplate.opsForHash().put(key, item, value);
  262.             if (time > 0) {
  263.                 expire(key, time);
  264.             }
  265.             return true;
  266.         } catch (Exception e) {
  267.             e.printStackTrace();
  268.             return false;
  269.         }
  270.     }
  271.  
  272.  
  273.     /**
  274.      * 删除hash表中的值
  275.      *
  276.      * @param key  键 不能为null
  277.      * @param item 项 可以使多个 不能为null
  278.      */
  279.     public  void hdel(String key, Object... item) {
  280.         redisTemplate.opsForHash().delete(key, item);
  281.     }
  282.  
  283.  
  284.     /**
  285.      * 判断hash表中是否有该项的值
  286.      *
  287.      * @param key  键 不能为null
  288.      * @param item 项 不能为null
  289.      * @return true 存在 false不存在
  290.      */
  291.     public  boolean hHasKey(String key, String item) {
  292.         return redisTemplate.opsForHash().hasKey(key, item);
  293.     }
  294.  
  295.  
  296.     /**
  297.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  298.      *
  299.      * @param key  键
  300.      * @param item 项
  301.      * @param by   要增加几(大于0)
  302.      */
  303.     public  double hincr(String key, String item, double by) {
  304.         return redisTemplate.opsForHash().increment(key, item, by);
  305.     }
  306.  
  307.  
  308.     /**
  309.      * hash递减
  310.      *
  311.      * @param key  键
  312.      * @param item 项
  313.      * @param by   要减少记(小于0)
  314.      */
  315.     public  double hdecr(String key, String item, double by) {
  316.         return redisTemplate.opsForHash().increment(key, item, -by);
  317.     }
  318.  
  319.  
  320.     // ============================set=============================
  321.  
  322.     /**
  323.      * 根据key获取Set中的所有值
  324.      *
  325.      * @param key 键
  326.      */
  327.     public  Set<Object> sGet(String key) {
  328.         try {
  329.             return redisTemplate.opsForSet().members(key);
  330.         } catch (Exception e) {
  331.             e.printStackTrace();
  332.             return null;
  333.         }
  334.     }
  335.  
  336.  
  337.     /**
  338.      * 根据value从一个set中查询,是否存在
  339.      *
  340.      * @param key   键
  341.      * @param value 值
  342.      * @return true 存在 false不存在
  343.      */
  344.     public  boolean sHasKey(String key, Object value) {
  345.         try {
  346.             return redisTemplate.opsForSet().isMember(key, value);
  347.         } catch (Exception e) {
  348.             e.printStackTrace();
  349.             return false;
  350.         }
  351.     }
  352.  
  353.  
  354.     /**
  355.      * 将数据放入set缓存
  356.      *
  357.      * @param key    键
  358.      * @param values 值 可以是多个
  359.      * @return 成功个数
  360.      */
  361.     public  long sSet(String key, Object... values) {
  362.         try {
  363.             return redisTemplate.opsForSet().add(key, values);
  364.         } catch (Exception e) {
  365.             e.printStackTrace();
  366.             return 0;
  367.         }
  368.     }
  369.  
  370.  
  371.     /**
  372.      * 将set数据放入缓存
  373.      *
  374.      * @param key    键
  375.      * @param time   时间(秒)
  376.      * @param values 值 可以是多个
  377.      * @return 成功个数
  378.      */
  379.     public  long sSetAndTime(String key, long time, Object... values) {
  380.         try {
  381.             Long count = redisTemplate.opsForSet().add(key, values);
  382.             if (time > 0)
  383.                 expire(key, time);
  384.             return count;
  385.         } catch (Exception e) {
  386.             e.printStackTrace();
  387.             return 0;
  388.         }
  389.     }
  390.  
  391.  
  392.     /**
  393.      * 获取set缓存的长度
  394.      *
  395.      * @param key 键
  396.      */
  397.     public  long sGetSetSize(String key) {
  398.         try {
  399.             return redisTemplate.opsForSet().size(key);
  400.         } catch (Exception e) {
  401.             e.printStackTrace();
  402.             return 0;
  403.         }
  404.     }
  405.  
  406.  
  407.     /**
  408.      * 移除值为value的
  409.      *
  410.      * @param key    键
  411.      * @param values 值 可以是多个
  412.      * @return 移除的个数
  413.      */
  414.  
  415.     public  long setRemove(String key, Object... values) {
  416.         try {
  417.             Long count = redisTemplate.opsForSet().remove(key, values);
  418.             return count;
  419.         } catch (Exception e) {
  420.             e.printStackTrace();
  421.             return 0;
  422.         }
  423.     }
  424.  
  425.     // ===============================list=================================
  426.  
  427.     /**
  428.      * 获取list缓存的内容
  429.      *
  430.      * @param key   键
  431.      * @param start 开始
  432.      * @param end   结束 0 到 -1代表所有值
  433.      */
  434.     public  List<Object> lGet(String key, long start, long end) {
  435.         try {
  436.             return redisTemplate.opsForList().range(key, start, end);
  437.         } catch (Exception e) {
  438.             e.printStackTrace();
  439.             return null;
  440.         }
  441.     }
  442.  
  443.  
  444.     /**
  445.      * 获取list缓存的长度
  446.      *
  447.      * @param key 键
  448.      */
  449.     public  long lGetListSize(String key) {
  450.         try {
  451.             return redisTemplate.opsForList().size(key);
  452.         } catch (Exception e) {
  453.             e.printStackTrace();
  454.             return 0;
  455.         }
  456.     }
  457.  
  458.  
  459.     /**
  460.      * 通过索引 获取list中的值
  461.      *
  462.      * @param key   键
  463.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  464.      */
  465.     public  Object lGetIndex(String key, long index) {
  466.         try {
  467.             return redisTemplate.opsForList().index(key, index);
  468.         } catch (Exception e) {
  469.             e.printStackTrace();
  470.             return null;
  471.         }
  472.     }
  473.  
  474.  
  475.     /**
  476.      * 将list放入缓存
  477.      *
  478.      * @param key   键
  479.      * @param value 值
  480.      */
  481.     public  boolean lSet(String key, Object value) {
  482.         try {
  483.             redisTemplate.opsForList().rightPush(key, value);
  484.             return true;
  485.         } catch (Exception e) {
  486.             e.printStackTrace();
  487.             return false;
  488.         }
  489.     }
  490.  
  491.  
  492.     /**
  493.      * 将list放入缓存
  494.      *
  495.      * @param key   键
  496.      * @param value 值
  497.      * @param time  时间(秒)
  498.      */
  499.     public  boolean lSet(String key, Object value, long time) {
  500.         try {
  501.             redisTemplate.opsForList().rightPush(key, value);
  502.             if (time > 0)
  503.                 expire(key, time);
  504.             return true;
  505.         } catch (Exception e) {
  506.             e.printStackTrace();
  507.             return false;
  508.         }
  509.  
  510.     }
  511.  
  512.  
  513.     /**
  514.      * 将list放入缓存
  515.      *
  516.      * @param key   键
  517.      * @param value 值
  518.      * @return
  519.      */
  520.     public  boolean lSet(String key, List<Object> value) {
  521.         try {
  522.             redisTemplate.opsForList().rightPushAll(key, value);
  523.             return true;
  524.         } catch (Exception e) {
  525.             e.printStackTrace();
  526.             return false;
  527.         }
  528.  
  529.     }
  530.  
  531.  
  532.     /**
  533.      * 将list放入缓存
  534.      *
  535.      * @param key   键
  536.      * @param value 值
  537.      * @param time  时间(秒)
  538.      * @return
  539.      */
  540.     public  boolean lSet(String key, List<Object> value, long time) {
  541.         try {
  542.             redisTemplate.opsForList().rightPushAll(key, value);
  543.             if (time > 0)
  544.                 expire(key, time);
  545.             return true;
  546.         } catch (Exception e) {
  547.             e.printStackTrace();
  548.             return false;
  549.         }
  550.     }
  551.  
  552.  
  553.     /**
  554.      * 根据索引修改list中的某条数据
  555.      *
  556.      * @param key   键
  557.      * @param index 索引
  558.      * @param value 值
  559.      * @return
  560.      */
  561.  
  562.     public  boolean lUpdateIndex(String key, long index, Object value) {
  563.         try {
  564.             redisTemplate.opsForList().set(key, index, value);
  565.             return true;
  566.         } catch (Exception e) {
  567.             e.printStackTrace();
  568.             return false;
  569.         }
  570.     }
  571.  
  572.  
  573.     /**
  574.      * 移除N个值为value
  575.      *
  576.      * @param key   键
  577.      * @param count 移除多少个
  578.      * @param value 值
  579.      * @return 移除的个数
  580.      */
  581.  
  582.     public  long lRemove(String key, long count, Object value) {
  583.         try {
  584.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  585.             return remove;
  586.         } catch (Exception e) {
  587.             e.printStackTrace();
  588.             return 0;
  589.         }
  590.  
  591.     }
  592. }

4.还需要加入配置类，否则启动不起来，一样@component注解不要忘记加！

        

  1. package com.laoyang.educms.config;
  2.  
  3. /**
  4.  * @author:Kevin
  5.  * @create: 2022-10-05 15:38
  6.  * @Description:
  7.  */
  8.  
  9. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  10. import com.fasterxml.jackson.annotation.JsonTypeInfo;
  11. import com.fasterxml.jackson.annotation.PropertyAccessor;
  12. import com.fasterxml.jackson.databind.ObjectMapper;
  13. import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
  14. import org.springframework.context.annotation.Bean;
  15. import org.springframework.data.redis.connection.RedisConnectionFactory;
  16. import org.springframework.data.redis.core.RedisTemplate;
  17. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  18. import org.springframework.data.redis.serializer.StringRedisSerializer;
  19. import org.springframework.stereotype.Component;
  20.  
  21. @Component
  22. public class Config {
  23.  
  24.     @Bean(name = "template")
  25.     public RedisTemplate<String, Object> template(RedisConnectionFactory factory) {
  26.         // 创建RedisTemplate<String, Object>对象
  27.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  28.         // 配置连接工厂
  29.         template.setConnectionFactory(factory);
  30.         // 定义Jackson2JsonRedisSerializer序列化对象
  31.         Jackson2JsonRedisSerializer<Object> jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
  32.         ObjectMapper om = new ObjectMapper();
  33.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
  34.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  35.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会报异常
  36.         om.activateDefaultTyping(
  37.  
  38.                 LaissezFaireSubTypeValidator.instance ,
  39.                 ObjectMapper.DefaultTyping.NON_FINAL,
  40.  
  41.                 JsonTypeInfo.As.WRAPPER_ARRAY);
  42.         jacksonSeial.setObjectMapper(om);
  43.         StringRedisSerializer stringSerial = new StringRedisSerializer();
  44.         // redis key 序列化方式使用stringSerial
  45.         template.setKeySerializer(stringSerial);
  46.         // redis value 序列化方式使用jackson
  47.         template.setValueSerializer(jacksonSeial);
  48.         // redis hash key 序列化方式使用stringSerial
  49.         template.setHashKeySerializer(stringSerial);
  50.         // redis hash value 序列化方式使用jackson
  51.         template.setHashValueSerializer(jacksonSeial);
  52.         template.afterPropertiesSet();
  53.         return template;
  54.     }
  55. }

5.创建service：验证码service：两个方法，一个是生成验证码图片，另一个方法是验证输入的验证码是否正确。

  1. package com.laoyang.educms.service;
  2.  
  3. import javax.servlet.http.HttpServletResponse;
  4. import java.io.IOException;
  5.  
  6. /**
  7.  * @author:Kevin
  8.  * @create: 2022-10-05 13:50
  9.  * @Description:    验证码
  10.  */
  11.  
  12. public interface ValidateCodeService {
  13.     /**
  14.      * 生成验证码
  15.      */
  16.     void create(String key, HttpServletResponse response) throws IOException;
  17.  
  18.     /**
  19.      * 校验验证码
  20.      * @param key   前端上送 key
  21.      * @param value 前端上送待校验值
  22.      */
  23.     boolean check(String key, String value);
  24. }

6.编写验证码service的实现类：注意这里会用到缓存，因为咱们这个redis工具类不是static的，所以这里用的话需要对象注入调用

  1. package com.laoyang.educms.service.impl;
  2.  
  3. import com.laoyang.CommonUtils.Contst.ResultCode;
  4. import com.laoyang.MyException;
  5. import com.laoyang.educms.entity.CacheObject;
  6. import com.laoyang.educms.service.ValidateCodeService;
  7. import com.laoyang.educms.utils.redisutils;
  8. import com.wf.captcha.ArithmeticCaptcha;
  9. import com.wf.captcha.base.Captcha;
  10. import org.apache.commons.lang3.StringUtils;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.http.HttpHeaders;
  13. import org.springframework.http.MediaType;
  14. import org.springframework.stereotype.Service;
  15.  
  16. import javax.servlet.http.HttpServletResponse;
  17. import java.io.IOException;
  18.  
  19. /**
  20.  * @author:Kevin
  21.  * @create: 2022-10-05 13:51
  22.  * @Description:
  23.  */
  24. @Service
  25. public class ValidateCodeServiceImpl implements ValidateCodeService {
  26.  
  27.     @Autowired
  28.     private redisutils redisutils;
  29.  
  30.     /**
  31.      * 生成验证码图片
  32.      * @param key
  33.      * @param response
  34.      * @throws IOException
  35.      */
  36.     @Override
  37.     public void create(String key, HttpServletResponse response) throws IOException {
  38.         if (StringUtils.isBlank(key)) {
  39.             throw new  MyException(ResultCode.ERROR,"验证码不能为空");
  40.         }
  41.  
  42.         response.setContentType(MediaType.IMAGE_PNG_VALUE);
  43.         response.setHeader(HttpHeaders.PRAGMA, "No-cache");
  44.         response.setHeader(HttpHeaders.CACHE_CONTROL, "No-cache");
  45.         response.setDateHeader(HttpHeaders.EXPIRES, 0L);
  46.  
  47.         Captcha captcha = new ArithmeticCaptcha(115, 42);
  48.         captcha.setCharType(2);
  49.  
  50.         String text = captcha.text();
  51.         System.out.println(text);
  52.  
  53.         //设置过期时间为5分种
  54.         redisutils.set(key,text,300);
  55.  
  56.         captcha.out(response.getOutputStream());
  57.  
  58.     }
  59.  
  60.     /**
  61.      * 校验输入的验证码
  62.      * @param key   前端上送 key
  63.      * @param value 前端上送待校验值
  64.      * @return
  65.      */
  66.     @Override
  67.     public boolean check(String key, String value) {
  68.         if (StringUtils.isBlank(value)) {
  69.             throw new MyException(ResultCode.ERROR,"验证码不能为空");
  70.         }
  71.         //根据key从缓存中获取验证码
  72.         String code = (String) redisutils.get(key);
  73.         if (code == null) {
  74.             throw new MyException(ResultCode.ERROR,"验证码已经过期");
  75.         }
  76.         //比对验证码
  77.         if (!StringUtils.equalsIgnoreCase(value,
  78.                 code)) {
  79.             throw new MyException(ResultCode.ERROR,"验证码不正确");
  80.         }
  81.         //验证通过，立即从缓存中删除验证码
  82.         redisutils.del(key);
  83.         return true;
  84.  
  85.     }
  86. }

7.编写一个前端后端数据交互的登录DTO

  1. package com.laoyang.educms.entity;
  2.  
  3. import io.swagger.annotations.ApiModel;
  4. import io.swagger.annotations.ApiModelProperty;
  5. import lombok.*;
  6. import lombok.experimental.Accessors;
  7.  
  8. import javax.validation.constraints.NotEmpty;
  9.  
  10. /**
  11.  * @author:Kevin
  12.  * @create: 2022-10-05 15:00
  13.  * @Description:
  14.  */
  15. @Data
  16. @NoArgsConstructor
  17. @AllArgsConstructor
  18. @Accessors(chain = true)
  19. @ToString(callSuper = true)
  20. @EqualsAndHashCode(callSuper = false)
  21. @Builder
  22. @ApiModel(value = "LoginParamDTO", description = "登录参数")
  23. public class LoginDto {
  24.  
  25.     @ApiModelProperty(value = "验证码KEY")
  26.     @NotEmpty(message = "验证码KEY不能为空")
  27.     private String key;
  28.     @ApiModelProperty(value = "验证码")
  29.     @NotEmpty(message = "验证码不能为空")
  30.     private String code;
  31.     @ApiModelProperty(value = "账号")
  32.     @NotEmpty(message = "账号不能为空")
  33.     private String account;
  34.     @ApiModelProperty(value = "密码")
  35.     @NotEmpty(message = "密码不能为空")
  36.     private String password;
  37.     @ApiModelProperty(value = "电话号码")
  38.     @NotEmpty(message = "电话号码不能为空")
  39.     private String Mobile;
  40. }

8.编写验证码视图类

  1. package com.laoyang.educms.controller;
  2.  
  3.  
  4. import com.laoyang.CommonUtils.R;
  5. import com.laoyang.educms.entity.LoginDto;
  6. import com.laoyang.educms.entity.UcenterMember;
  7. import com.laoyang.educms.service.UcenterMemberService;
  8. import com.laoyang.educms.service.ValidateCodeService;
  9. import io.swagger.annotations.Api;
  10. import io.swagger.annotations.ApiOperation;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.web.bind.annotation.*;
  13.  
  14. import javax.servlet.http.HttpServletResponse;
  15. import java.io.IOException;
  16.  
  17. /**
  18.  * <p>
  19.  * 会员表 前端控制器
  20.  * </p>
  21.  *
  22.  * @author testjava
  23.  * @since 2022-10-05
  24.  */
  25. @RestController
  26. @CrossOrigin
  27. @Api(value = "UcenterMemberController", tags = "登录")
  28. @RequestMapping("/educms/member")
  29. public class UcenterMemberController {
  30.  
  31.  
  32.     @Autowired
  33.     private UcenterMemberService memberService;
  34.  
  35.     @Autowired
  36.     private ValidateCodeService validateCodeService;
  37.  
  38.     /**
  39.      * 登录
  40.      * @param loginDto
  41.      * @return
  42.      */
  43.     @PostMapping("/login")
  44.     public R login(@RequestBody LoginDto loginDto){
  45.         if (validateCodeService.check(loginDto.getKey(), loginDto.getCode())){
  46.             String token =  memberService.login(loginDto);
  47.             return R.ok("登录成功").data("token",token);
  48.         }
  49.         return R.error("登录失败");
  50.  
  51.     }
  52.  
  53.     /**
  54.      * 生成验证码
  55.      */
  56.     @ApiOperation(value = "验证码", notes = "验证码")
  57.     @GetMapping(value = "/captcha", produces = "image/png")
  58.     public void captcha(@RequestParam(value = "key") String key,
  59.                         HttpServletResponse response) throws IOException {
  60.         this.validateCodeService.create(key, response);
  61.  
  62.     }
  63.  
  64.  
  65.  
  66. }
  67.

最终测试实现：

第一个测试生成验证码的接口：

 第二个是从redis缓存中通过传入的key获取数据再和前端用户输入的code值进行判断，如果不对，就从新刷新进行验证

10.前端接受时的写法，否则会乱码，需要加上响应类型为blob

11.前端的js代码获取

 

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

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

  

闽ICP备14008679号