Redis相关--Springboot整合Jedis，并完成手机验证码Demo

1.Jedis实现手机验证码操作

1.输入手机号，随机生成6位验证码，2分钟有效
2.输入验证码，返回成功或失败
3.每个手机号每天只能输入3次--incr 每次发送 +1

创建一个空白maven项目，引入Jedis

<!--        引入Jedis-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>

public class PhoneCode {
    public static void main(String[] args) {
        //模拟验证码发送
        String code = getCode();
        verifyCode("18810115900",code);
        getRedisCode("18810115900","866009");
    }
    //1.生成6位数字验证码
    public static String getCode(){
        Random random = new Random();
        String code = "";
        for (int i = 0; i < 6; i++) {
            int rand = random.nextInt(10);
            code += rand;
        }
        return code;
    }
    //2 每个手机只能发送三次，验证码放到redis，设置过期时间
    public static void verifyCode(String phone,String code){
        Jedis jedis = new Jedis("101.43.152.64",6379);
        jedis.auth("123456");
        //手机发送次数key
        String countKey = "VerifyCode" + phone + ":count";
        //验证码key
        String codeKey =  "VerifyCode" + phone + ":code";
        //每天发送三次
        String count = jedis.get(countKey);
        System.out.println(count);
        if (count == null){
            //第一次发送，设置发送次数
            jedis.setex(countKey,24*60*60,"1");
        }else if (Integer.parseInt(count) <= 2){
            //发送次数+1
            jedis.incr(countKey);
        }else if (Integer.parseInt(count) > 2){
            //发送三次，不能发送
            System.out.println("今天发送次数超过3次，不能再发送");
            jedis.close();
        }
        //发送验证码到redis，设置过期时间2分钟
        jedis.setex(codeKey,120,getCode());
        jedis.close();
    }
    //3.验证码校验
    public static void getRedisCode(String phone,String code){
        Jedis jedis = new Jedis("101.43.152.64",6379);
        jedis.auth("123456");
        String codeKey =  "VerifyCode" + phone + ":code";
        String codeSaved = jedis.get(codeKey);
        if (code.equals(codeSaved)){
            System.out.println("验证成功");
        }else {
            System.out.println("验证失败");
        }
    }
}

2.Springboot整合Jedis

<!--        引入redis、common-pool2-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.6.0</version>
        </dependency>

配置文件，固定写法

redis:
  host: *
  port: 6379
  password: *
  database: 1
  # 如果使用的jedis 则将lettuce改成jedis即可
  lettuce:
    pool:
      max-active: 15 # 最大活跃链接数 默认8
      max-idle: 8 # 最大空闲连接数 默认8
      min-idle: 0 # 最小空闲连接数 默认0

编写config

@Configuration
public class RedisConfig {
    //配置自定义redisTemplate
    @Bean(name = "redisTemplate")
    RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);

        mapper.registerModule(new Jdk8Module())
                .registerModule(new JavaTimeModule());
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        serializer.setObjectMapper(mapper);

        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
    // 配置缓存的时间
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(1*60*60), // 默认策略，未配置的 key 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 key 策略
        );
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        // 指定其他cacheName的过期时间,在下方添加
        redisCacheConfigurationMap.put("wx_account", this.getRedisCacheConfigurationWithTtl(3000));

        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }
}