• spring boot整合redis—邮箱验证码

    redis简介

            Redis 是一个高性能的开源的、C语言写的Nosql（非关系型数据库），数据保存在内存中。

            Redis 是以key-value形式存储，和传统的关系型数据库不一样。不一定遵循传统数据库的一些基本要求，比如 说，不遵循sql标准，事务，表结构等等，非关系型数据库严格上不是一种数据库，应该是一种数据结构化存储方 法的集合。

            Java中数据结构：String,数组，list，set map…

            Redis提供了很多的方法，可以用来存取各种数据结构的数据

    什么是NoSql

            NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，它泛指非关系型的数据库。随着互联网2003年之后 web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的交友类型的web2.0纯动 态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅 速的发展。

    为什么用redis

            1.数据保存在内存，存取速度快，并发能力强

            2.它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、 zset(sorted set --有序集合)和 hash（哈希类型）。

            3.redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库（如 MySQL）起到很好的补充作用。

            4.它提供了Java，C/C++，C#，PHP，JavaScript等客户端，使用很方便。

            5.Redis支持集群（主从同步）。数据可以主服务器向任意数量从的从服务器上同步，从服务器可以是关联其他从 服务器的主服务器。

            6.支持持久化，可以将数据保存在硬盘的文件中

    Redis使用场景

            1:缓存，毫无疑问这是Redis当今最为人熟知的使用场景。再提升服务器性能方面非常有效。

            2:排行榜，在使用传统的关系型数据库（mysql oracle 等）来做这个事儿，非常的麻烦，而利用Redis的 SortSet(有序集合)数据结构能够简单的搞定。

            3:利用Redis中原子性的自增操作，我们可以统计类似用户点赞数、用户访问数等，这类操作如果用MySQL，频 繁的读写会带来相当大的压力；限速器比较典型的使用场景是限制某个用户访问某个API的频率，常用的有抢购 时，防止用户疯狂点击带来不必要的压力；

            4: 一些频繁被访问的数据，经常被访问的数据如果放在关系型数据库，每次查询的开销都会很大，而放在redis 中，因为redis 是放在内存中的可以很高效的访问

    spring boot整合redis—邮箱验证码

    一、springboot整合redis 环境搭建

    1 导入依赖

    1.         !-- !redis-->
    2.         <dependency>
    3.             <groupId>org.springframework.bootgroupId>
    4.             <artifactId>spring-boot-starter-data-redisartifactId>
    5.         dependency>

    2 加入配置

    1. #=======redis连接池配置============== #
    2. # Redis数据库索引（默认为0）
    3.  spring.redis.database=0
    4. # Redis服务器地址
    5.  spring.redis.host=127.0.0.1
    6. # Redis服务器连接端口
    7.  spring.redis.port=6379
    8. # Redis服务器连接密码（默认为空）
    9.  spring.redis.password=
    10. # 连接池最大连接数（使用负值表示没有限制）
    11.  spring.redis.jedis.pool.max-active=20
    12. # 连接池最大阻塞等待时间（使用负值表示没有限制）
    13.  spring.redis.jedis.pool.max-wait=-1
    14. # 连接池中的最大空闲连接
    15.  spring.redis.jedis.pool.max-idle=10
    16. # 连接池中的最小空闲连接
    17.  spring.redis.jedis.pool.min-idle=0
    18. # 连接超时时间（毫秒）
    19.  spring.redis.timeout=5000

    3 创建redis配置类RedisConfig

    1. @Configuration
    2. @EnableCaching // 启用缓存，使用 Lettuce，自动注入配置的方式
    3. @AutoConfigureAfter(RedisAutoConfiguration.class)
    4. public class RedisConfig extends CachingConfigurerSupport {
    5.     //缓存管理器
    6.     @Bean
    7.     @SuppressWarnings("all")
    8.     public CacheManager cacheManager(LettuceConnectionFactory factory) {
    9.         RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
    10.         RedisSerializationContext.SerializationPair pair =
    11.                 RedisSerializationContext.SerializationPair.fromSerializer(
    12.                         new Jackson2JsonRedisSerializer(Object.class));
    13.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
    14.         return new RedisCacheManager(writer, config);
    15.     }
    16.  
    17.     @Bean
    18.     public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
    19.         RedisTemplate redisTemplate = new RedisTemplate<>();
    20.         redisTemplate.setConnectionFactory(connectionFactory);
    21.         // String 序列化方式
    22.         StringRedisSerializer stringSerializer = new StringRedisSerializer();
    23.         // 使用Jackson2JsonRedisSerialize替换默认序列化
    24.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
    25.                 Jackson2JsonRedisSerializer(Object.class);
    26.         ObjectMapper objectMapper = new ObjectMapper();
    27.         objectMapper.setVisibility(PropertyAccessor.ALL,
    28.                 JsonAutoDetect.Visibility.ANY);
    29.         objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    30.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    31.         // 设置key的序列化规则
    32.         redisTemplate.setKeySerializer(stringSerializer);
    33.         redisTemplate.setHashKeySerializer(stringSerializer);
    34.         // 设置value的序列化规则
    35.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    36.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    37.         return redisTemplate;
    38.     }
    39.  
    40.  
    41.     // 重新定义缓存 key 的生成策略
    42.     @Bean
    43.     @Override
    44.     public KeyGenerator keyGenerator() {
    45.         return new KeyGenerator() {
    46.             @Override public Object generate(Object target, Method method, Object... params){
    47.                 StringBuilder sb = new StringBuilder();
    48.                 sb.append(target.getClass().getName());
    49.                 sb.append(method.getName());
    50.                 for(Object obj:params){
    51.                     sb.append(obj.toString());
    52.                 }
    53.                 return sb.toString();
    54.             }
    55.         };
    56.     }
    57. }

    二、验证码发送和验证

    在serviceImpl中注入redis

     

    1.  //注入redis
    2.     @Autowired
    3.     RedisTemplate redisTemplate;

    1.验证码发送

    1.1 后端，在项目-01 的基础上修改

    1.1.1   优化发送验证码方法sendCode，30-34行

    • 在验证码发送成功后，将”code：email“作为键，code作为值，并设置失效时间是1分钟
    • 将键、值、时间使用redisTemplate.opsForValue().set保存进去
    • 当失效时间到了后，redis会自动清楚这个键值。
    1. @Override
    2.     public ResultVo sendCode(String email) {
    3.         ResultVo rv = new ResultVo();
    4.  
    5.         try {
    6.  
    7.             //创建邮件对象
    8.             SimpleMailMessage message = new SimpleMailMessage();
    9.  
    10.             //定义收件人邮箱
    11.             message.setTo(email);
    12.  
    13.             //定义发件人邮箱
    14.             message.setFrom(sendEmail);
    15.  
    16.             //定义邮件标题
    17.             message.setSubject("xxx公司验证码");
    18.  
    19.             //定义邮件正文
    20.             Random random = new Random();
    21.             int code = random.nextInt(10000);
    22.             message.setText("你的验证码是"+code);
    23.  
    24.             //发送邮件
    25.             javaMailSender.send(message);
    26.             System.out.println("发送成功");
    27.             rv.setSuccess(true);
    28.             rv.setInfo("发送成功");
    29.  
    30.             //发送成功放入redis
    31.             //1.定义redis的键名
    32.             String key = "code:"+email;
    33.             //2.存入验证码并设置失效时间,分钟
    34.             redisTemplate.opsForValue().set(key,code+"",1, TimeUnit.MINUTES);
    35.         } catch (Exception e) {
    36.             e.printStackTrace();
    37.             System.out.println("发送失败");
    38.             rv.setInfo("发送失败");
    39.         }
    40.  
    41.         return rv;
    42.     }

    1.2 前端，绑定按钮，并倒计时

            绑定发送验证码按钮，要做到一分钟一次请求，发送验证码后，一分钟后才能再次发送验证码

    1.2.1 绑定按钮

    1.2.2 计时器和禁用按钮实现

            重要的方法：计时器方法

    var time = setInterval(function() {}

    2.验证邮箱验证码

    2.1.后端，写实现类和控制器接口

    2.1.1.编写邮箱验证码验证方法validateCode

    • 1.先把传进来的userInfo对象的email拿出了，组成键名，然后去redis中获取改键的值
    • 2.如果值为空，则时间已经到了，失效了
    • 3.不为空，就判断传进来的userInfo对象的code是否等于redis中获取带的值，等于则输入正确，然后返回true
    • 4.否则输入错误
    1. @Override
    2.     public ResultVo validateCode(UserInfo userInfo) {
    3.         ResultVo rv = new ResultVo();
    4.         //判断验证码是否失效
    5.         //1.定义键名
    6.         String key = "code:"+userInfo.getEmail();
    7.         Object  obj = redisTemplate.opsForValue().get(key);
    8.         //2.判断这个key是否存在，如果时间有效则存在
    9.         if (obj == null){
    10.             rv.setInfo("验证码失效");
    11.         }else {
    12.             //3.验证码未失效，比较验证码
    13.             if (userInfo.getCode().equals(obj)){
    14.                 rv.setInfo("输入正确");
    15.                 rv.setSuccess(true);
    16.             }else {
    17.                 rv.setInfo("验证码输入错误");
    18.             }
    19.         }
    20.         return rv;
    21.     }

    2.1.2.写验证邮箱验证码的控制器接口

            使用的是post请求，因为要提交的是表单的数据包装的userInfo

    1. @RestController
    2. @RequestMapping("/userInfo")
    3. public class UserInfoController {
    4.  
    5.     //注入service
    6.     @Autowired
    7.     private UserInfoService userInfoService;
    8.  
    9.     //定义修改密码
    10.     @GetMapping("/updatePwd")
    11.     public ResultVo updatePwd(String email){
    12.         return userInfoService.sendCode(email);
    13.     }
    14.  
    15.     //验证输入的验证码是否失效或正确
    16.     @PostMapping("/validateCode")
    17.     public ResultVo validateCode(UserInfo userInfo){
    18.         return userInfoService.validateCode(userInfo);
    19.     }
    20. }

    2.2 前端，绑定按钮，并验证

    2.

    3.发送验证码和验证的代码

    3.1 后端

    userInfoServerImpl.java

    1. @Service
    2. public class UserInfoServiceImpl implements UserInfoService {
    3.  
    4.     //注入邮件发送服务类
    5.     @Autowired
    6.     JavaMailSender javaMailSender;
    7.     @Value("${spring.mail.username}")
    8.     String sendEmail;
    9.  
    10.     //注入redis
    11.     @Autowired
    12.     RedisTemplate redisTemplate;
    13.  
    14.     @Override
    15.     public ResultVo sendCode(String email) {
    16.         ResultVo rv = new ResultVo();
    17.  
    18.         try {
    19.  
    20.             //创建邮件对象
    21.             SimpleMailMessage message = new SimpleMailMessage();
    22.  
    23.             //定义收件人邮箱
    24.             message.setTo(email);
    25.  
    26.             //定义发件人邮箱
    27.             message.setFrom(sendEmail);
    28.  
    29.             //定义邮件标题
    30.             message.setSubject("xxx公司验证码");
    31.  
    32.             //定义邮件正文
    33.             Random random = new Random();
    34.             int code = random.nextInt(10000);
    35.             message.setText("你的验证码是"+code);
    36.  
    37.             //发送邮件
    38.             javaMailSender.send(message);
    39.             System.out.println("发送成功");
    40.             rv.setSuccess(true);
    41.             rv.setInfo("发送成功");
    42.  
    43.             //发送成功放入redis
    44.             //1.定义redis的键名
    45.             String key = "code:"+email;
    46.             //2.存入验证码并设置失效时间,分钟
    47.             redisTemplate.opsForValue().set(key,code+"",1, TimeUnit.MINUTES);
    48.         } catch (Exception e) {
    49.             e.printStackTrace();
    50.             System.out.println("发送失败");
    51.             rv.setInfo("发送失败");
    52.         }
    53.  
    54.         return rv;
    55.     }
    56.  
    57.     @Override
    58.     public ResultVo validateCode(UserInfo userInfo) {
    59.         ResultVo rv = new ResultVo();
    60.         //判断验证码是否失效
    61.         //1.定义键名
    62.         String key = "code:"+userInfo.getEmail();
    63.         Object  obj = redisTemplate.opsForValue().get(key);
    64.         //2.判断这个key是否存在，如果时间有效则存在
    65.         if (obj == null){
    66.             rv.setInfo("验证码失效");
    67.         }else {
    68.             //3.验证码未失效，比较验证码
    69.             if (userInfo.getCode().equals(obj)){
    70.                 rv.setInfo("输入正确");
    71.                 rv.setSuccess(true);
    72.             }else {
    73.                 rv.setInfo("验证码输入错误");
    74.             }
    75.         }
    76.         return rv;
    77.     }
    78. }

    UserInfoService.java

    1.  
    2. public interface UserInfoService {
    3.  
    4.     //邮件发送验证码
    5.     ResultVo sendCode(String email);
    6.  
    7.     //验证验证码是否输入正确
    8.     ResultVo validateCode(UserInfo userInfo);
    9.  
    10. }

    UserInfoController.java

    1. @RestController
    2. @RequestMapping("/userInfo")
    3. public class UserInfoController {
    4.  
    5.     //注入service
    6.     @Autowired
    7.     private UserInfoService userInfoService;
    8.  
    9.     //定义修改密码
    10.     @GetMapping("/updatePwd")
    11.     public ResultVo updatePwd(String email){
    12.         return userInfoService.sendCode(email);
    13.     }
    14.  
    15.     //验证输入的验证码是否失效或正确
    16.     @PostMapping("/validateCode")
    17.     public ResultVo validateCode(UserInfo userInfo){
    18.         return userInfoService.validateCode(userInfo);
    19.     }
    20. }

    3.2 前端

    testEmailVaildate.vue组件

    2.  
    4.

    index.js

    1. import Vue from 'vue'
    2. import Router from 'vue-router'
    3. /*  配置地址，叫组件
    4.     第一种：导入hello组件
    5. */
    6.  
    7. import hello from  '@/components/demo/hello'
    8. import testEmailVaildate from '../components/project/testEmailVaildate.vue'
    9. import testUpdatePwd from '../components/project/testUpdatePwd.vue'
    10. Vue.use(Router)
    11.  
    12. export default new Router({
    13.   // 切换到history模式
    14.   mode:"history",
    15.   routes: [
    16.     {
    17.       /* 斜杠：代表项目的默认地址 */
    18.       path: '/',
    19.       name: 'hello',  /* 组件名称：保持名称唯一性 */
    20.       component: hello  /*  引入组件的别名   */
    21.     },
    22.     {
    23.       path: '/testEmailVaildate',  //*，通配所有的错误地址
    24.       name: 'testEmailVaildate',
    25.       component: testEmailVaildate
    26.     },
    27.     {
    28.       path: '/testUpdatePwd',  //*，通配所有的错误地址
    29.       name: 'testUpdatePwd',
    30.       component: testUpdatePwd
    31.     },
    32.   ]
    33. })
    34.  
    35.

    三、修改密码

            涉及了后端数据交互、使用了全自动的框架mybatis plus,引入了shiro权限认证，以及加密工具

    1、导包

    导入了mybatis plus,shrio的依赖

    1.  
    2.         
    3.             com.baomidou
    4.             mybatis-plus-boot-starter
    5.             3.3.2
    6.         
    7.         
    8.             mysql
    9.             mysql-connector-java
    10.             5.1.17
    11.         
    12.         
    13.         
    14.             org.apache.velocity
    15.             velocity-engine-core
    16.             2.2
    17.         
    18.         
    19.         
    20.             com.baomidou
    21.             mybatis-plus-generator
    22.             3.3.2
    23.         
    24.  
    25.  
    26.         
    27.         
    28.             org.apache.shiro
    29.             shiro-spring
    30.             1.2.2
    31.

    2.引入加密工具类

    1. @Component
    2. public class MDFive {
    3.     /**
    4.      *
    5.      * @param password 要加密的密码
    6.      * @param saltValue 盐值
    7.      * @return
    8.      */
    9.     public String encrypt(String password,String saltValue){
    10.         //创建一个MD5的盐值对象
    11.         Object salt = new Md5Hash(saltValue);
    12.         //生成加密的字符串
    13.         Object result = new SimpleHash("MD5", password, salt, 1024);
    14.  
    15.         return result+"";
    16.     }
    17.  
    18. }

    3.根据user_info表完善实体类userInfo

    📎user_info.sqlicon-default.png?t=M85Bhttps://www.yuque.com/attachments/yuque/0/2022/sql/32505142/1662716539576-2cdc64e2-f912-490d-8744-b20646ac8914.sql

    1. @Data
    2. @TableName("user_info")
    3. public class UserInfo {
    4.     //主键
    5.     @TableId(value = "user_id",type = IdType.AUTO)
    6.     private Integer userId;
    7.  
    8.     //用户名
    9.     private String userName;
    10.  
    11.     //密码
    12.     private String passPwd;
    13.  
    14.     //盐值
    15.     private String salt;
    16.  
    17.     //邮箱
    18.     private String email;
    19.  
    20.     //电话
    21.     private String phone;
    22.  
    23.     //验证码
    24.     @TableField(exist = false)
    25.     private String code;
    26. }

    4.使用mybatis plus来接管到

    4.1.在基础包下新建dao包，并建立UserInfoDao接口

    4.2.继承BaseMapper

    1. public interface UserInfoDao extends BaseMapper {
    2. }

    4.3.在启动类上扫描dao

    1. @SpringBootApplication
    2. @MapperScan("com.hqyj.dao")
    3. public class IdeaVueApplication {
    4.  
    5.     public static void main(String[] args) {
    6.         SpringApplication.run(IdeaVueApplication.class, args);
    7.     }
    8.  
    9. }

    5.写修改密码实现接口类

    1. public interface UserInfoService {
    2.  
    3.     //邮件发送验证码
    4.     ResultVo sendCode(String email);
    5.  
    6.     //验证验证码是否输入正确
    7.     ResultVo validateCode(UserInfo userInfo);
    8.  
    9.     //修改密码
    10.     ResultVo updatePwd(UserInfo userInfo);
    11.  
    12. }

    使用UUID来作为盐值，唯一性

    1. @Service
    2. public class UserInfoServiceImpl implements UserInfoService {
    3.  
    4.     //注入邮件发送服务类
    5.     @Autowired
    6.     JavaMailSender javaMailSender;
    7.     @Value("${spring.mail.username}")
    8.     String sendEmail;
    9.     //注入redis
    10.     @Autowired
    11.     RedisTemplate redisTemplate;
    12.     //注入加密工具
    13.     @Autowired
    14.     private MDFive mdFive;
    15.     @Autowired
    16.     private UserInfoDao userInfoDao;
    17.  
    18.  
    19.     @Override
    20.     public ResultVo sendCode(String email) {
    21.         ResultVo rv = new ResultVo();
    22.  
    23.         try {
    24.  
    25.             //创建邮件对象
    26.             SimpleMailMessage message = new SimpleMailMessage();
    27.  
    28.             //定义收件人邮箱
    29.             message.setTo(email);
    30.  
    31.             //定义发件人邮箱
    32.             message.setFrom(sendEmail);
    33.  
    34.             //定义邮件标题
    35.             message.setSubject("xxx公司验证码");
    36.  
    37.             //定义邮件正文
    38.             Random random = new Random();
    39.             int code = random.nextInt(10000);
    40.             message.setText("你的验证码是"+code);
    41.  
    42.             //发送邮件
    43.             javaMailSender.send(message);
    44.             System.out.println("发送成功");
    45.             rv.setSuccess(true);
    46.             rv.setInfo("发送成功");
    47.  
    48.             //发送成功放入redis
    49.             //1.定义redis的键名
    50.             String key = "code:"+email;
    51.             //2.存入验证码并设置失效时间,分钟
    52.             redisTemplate.opsForValue().set(key,code+"",1, TimeUnit.MINUTES);
    53.         } catch (Exception e) {
    54.             e.printStackTrace();
    55.             System.out.println("发送失败");
    56.             rv.setInfo("发送失败");
    57.         }
    58.  
    59.         return rv;
    60.     }
    61.  
    62.     @Override
    63.     public ResultVo validateCode(UserInfo userInfo) {
    64.         ResultVo rv = new ResultVo();
    65.         //判断验证码是否失效
    66.         //1.定义键名
    67.         String key = "code:"+userInfo.getEmail();
    68.         Object  obj = redisTemplate.opsForValue().get(key);
    69.         //2.判断这个key是否存在，如果时间有效则存在
    70.         if (obj == null){
    71.             rv.setInfo("验证码失效");
    72.         }else {
    73.             //3.验证码未失效，比较验证码
    74.             if (userInfo.getCode().equals(obj)){
    75.                 rv.setInfo("输入正确");
    76.                 rv.setSuccess(true);
    77.             }else {
    78.                 rv.setInfo("验证码输入错误");
    79.             }
    80.         }
    81.         return rv;
    82.     }
    83.  
    84.     @Override
    85.     public ResultVo updatePwd(UserInfo userInfo) {
    86.         ResultVo rv = new ResultVo();
    87.         //生成盐值,使用UUID,生成唯一的
    88.         String salt = UUID.randomUUID()+"";
    89.         //记录盐值
    90.         userInfo.setSalt(salt);
    91.  
    92.         //生成加密的字符串
    93.         String pwd = mdFive.encrypt(userInfo.getUserPwd(),salt);
    94.         //记录加密的密码
    95.         userInfo.setUserPwd(pwd);
    96.  
    97.         //创建条件构造器
    98.         QueryWrapper queryWrapper = new QueryWrapper<>();
    99.         queryWrapper.eq("email", userInfo.getEmail());
    100.         int num = userInfoDao.update(userInfo, queryWrapper);
    101.         if (num > 0 ){
    102.             rv.setSuccess(true);
    103.             rv.setInfo("修改成功");
    104.         }else {
    105.             rv.setInfo("修改失败");
    106.         }
    107.         return rv;
    108.     }
    109. }

    6.写修改密码的控制器接口

    1. @RestController
    2. @RequestMapping("/userInfo")
    3. public class UserInfoController {
    4.  
    5.     //注入service
    6.     @Autowired
    7.     private UserInfoService userInfoService;
    8.  
    9.     //定义修改密码
    10.     @GetMapping("/updatePwd")
    11.     public ResultVo updatePwd(String email){
    12.         return userInfoService.sendCode(email);
    13.     }
    14.  
    15.     //验证输入的验证码是否失效或正确
    16.     @PostMapping("/validateCode")
    17.     public ResultVo validateCode(UserInfo userInfo){
    18.         return userInfoService.validateCode(userInfo);
    19.     }
    20.  
    21.     //验证输入的验证码是否失效或正确
    22.     @PostMapping("/updatePwd")
    23.     public ResultVo updatePwd(UserInfo userInfo){
    24.         return userInfoService.updatePwd(userInfo);
    25.     }
    26. }

    7.测试

     

     

     

    这里前提是数据表中有当前邮箱的数据，否则找不到

  • 相关阅读:
    基于微信旅游景区景点购票小程序设计与实现 开题报告
    Unity基于EventSystem让SpriteRenderer支持点击事件
    合并区间（排序、贪心）
    正点原子 核心板IMX6ULL IIC RTC驱动 PCF8563
    【Kubernetes快速实战】
    初识RabbitMQ-概念、安装和使用
    解密Prompt7. 偏好对齐RLHF-OpenAI·DeepMind·Anthropic对比分析
    Android ViewBinding和DataBinding的几个使用方式 - 上
    HashMap 的哈希函数
    openmmlab教程3-MMSeg 使用
  • 原文地址：https://blog.csdn.net/weixin_46048259/article/details/126800242