Redis中的Jedis，SpringBoot整合Redis

Jedis的使用： 

    Jedis通过java操作redis：

            1：开区端口号6379放行
                    开启端口号：firewall-cmd --permanent  --add-port=6379/tcp
             2、重启防火墙：firewall-cmd --reload
            3、查看端口号是否打开：firewall-cmd  --query-port=6379/tcp

        

测试连接是否成功

 
public static void main(String[] args) {
//     创建Jedis对象   填入虚拟机主机地址，Redis端口号
        Jedis jedis = new Jedis("192.168.131.100",6379);

        //测试
        System.out.println(jedis.ping());
        jedis.close();

    }

    调用Jedis中的api对Redis进行操作，方法和linux操作相同

：实例测试:
    1,输入手机号，点击发送验证码，随机生成六位数的验证码，两分钟有效
    2.输入验证码，点击验证，返回成功或失败
    3.每个手机号只能输入三次

public class PhoneDemo {

    public static void main(String[] args) {
        String phone = "17673027336";
        //设置过期时间，+每天只能输入三次
        setCodeTimeOut(phone);

        //验证码校验
        getRedisCode(phone,"2134123");


    }

    //3.验证码校验
    public static void getRedisCode(String phone,String code){
        Jedis jedis = new Jedis("192.168.131.100",6379);
        //验证码的key
        String codeKey = "codeKey";
        //判断验证次数的key
        String PhoneNum = phone+"count";


        String count = jedis.get(PhoneNum);
        if (Integer.parseInt(count)<=3){
            //发送次数+1
            jedis.incr(PhoneNum);
            //验证码校验
            String redisCode = jedis.get(codeKey);
            if(redisCode.equals(code)){
                System.out.println("验证码成功");
            }else{
                System.out.println("验证码错误");
            }
        }else{
            System.out.println("输入次数超过上限");
            //关闭jedis
            jedis.close();
        }



        jedis.close();


    }
    //2.将生成的验证码存入redis中，设置过期时间，每个手机只能发送三次
    public static void setCodeTimeOut(String phone){
        Jedis jedis = new Jedis("192.168.131.100",6379);
        //验证码对应的key
        String codeKey = "codeKey";


        //每天只能输入三次,存放的key
        String PhoneNum = phone+"count";
        //获取发送次数，如果为空标识未发送过
        String count = jedis.get(PhoneNum);

        if(count==null){
            jedis.setex(PhoneNum,24*60*60,"1");
        }

        //设置验证码的过期时间
        jedis.set(codeKey,code());
        //设置过期时间
        jedis.expire(codeKey,120);
        //查看过期时间
        System.out.println(jedis.ttl(phone));
        //关闭jedis
        jedis.close();

    }

    //1.生成一个六位验证码
    public static String code(){
        Random random = new Random();
        String code="";
        for (int j = 0; j < 6; j++) {
            int rand = random.nextInt(10);
            code += rand;
        }
        return code;
    }
}

SpringBoot中整合Redis：

        步骤一：创建SpringBoot工程，添加依赖

        <!-- redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--   spring2.x集成redis所需的 commons-pool2（连接池）    -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

         二:在application中添加配置：

#Redis服务器地址
spring.redis.host=虚拟机的IP地址
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

        三：创建一个Redis的配置类（SpringBoot中集成了redisTemplate）

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
//key序列化方式
        template.setKeySerializer(redisSerializer);
//value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
//value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

        

        四：创建controller进行测试

@RestController
@RequestMapping("/RedisTest")
public class RedisSBText {

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/test")
    public String redisTest(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","dongge");
        //获取redis中的值
        String name = (String) redisTemplate.opsForValue().get("name");
        return name;
    }
}

测试结果：