尚硅谷Redis学习笔记（2）-- Jedis的使用

浅浅的花香味﹌ 2023-01-23 03:59 3阅读 0赞

# 一、Jedis测试 #

## 1.Jedis所需的jar包 ##

<dependency>
    	<groupId>redis.clients</groupId>
    	<artifactId>jedis</artifactId>
    	<version>3.2.0</version>
    </dependency>

## 2.连接Redis注意事项 ##

禁用Linux的防火墙：Linux(CentOS7)里执行命令：

systemctl stop/disable firewalld.service

redis.conf中注释掉bind 127.0.0.1，然后 protected-mode no

## 3.创建测试程序 ##

import redis.clients.jedis.Jedis;
    
    public class JedisDemo1 { 
        public static void main(String[] args) { 
            //创建jedis对象
            Jedis jedis = new Jedis("192.168.50.128",6379);
            //连接redis的密码
            jedis.auth("root");
            //测试
            String value = jedis.ping();
            System.out.println(value);
        }
    }

## 4.测试相关数据类型 ##

### 4.1 Jedis-API：Key ###

jedis.set("k1", "v1");
    jedis.set("k2", "v2");
    jedis.set("k3", "v3");
    
    Set<String> keys = jedis.keys("*");
    System.out.println(keys.size());
    
    for (String key : keys) { 
    	System.out.println(key);
    }
    
    System.out.println(jedis.exists("k1"));
    System.out.println(jedis.ttl("k1"));                
    System.out.println(jedis.get("k1"));

### 4.2 Jedis-API：String ###

jedis.mset("str1","v1","str2","v2","str3","v3");
    System.out.println(jedis.mget("str1","str2","str3"));

### 4.3 Jedis-API：list ###

List<String> list = jedis.lrange("mylist",0,-1);
    for (String element : list) { 
    	System.out.println(element);
    }

### 4.4 Jedis-API：set ###

jedis.sadd("orders", "order01");
    jedis.sadd("orders", "order02");
    jedis.sadd("orders", "order03");
    jedis.sadd("orders", "order04");
    
    Set<String> smembers = jedis.smembers("orders");
    
    for (String order : smembers) { 
    	System.out.println(order);
    }
    
    jedis.srem("orders", "order02");

### 4.5 Jedis-API：hash ###

jedis.hset("hash1","userName","lisi");
    System.out.println(jedis.hget("hash1","userName"));
    
    Map<String,String> map = new HashMap<String,String>();
    map.put("telphone","13810169999");
    map.put("address","atguigu");
    map.put("email","abc@163.com");
    
    jedis.hmset("hash2",map);
    
    List<String> result = jedis.hmget("hash2", "telphone","email");
    
    for (String element : result) { 
    	System.out.println(element);
    }

### 4.6 Jedis-API：zset ###

jedis.zadd("zset01", 100d, "z3");
    jedis.zadd("zset01", 90d, "l4");
    jedis.zadd("zset01", 80d, "w5");
    jedis.zadd("zset01", 70d, "z6");
     
    Set<String> zrange = jedis.zrange("zset01", 0, -1);
    
    for (String e : zrange) { 
    	System.out.println(e);
    }

# 二、Jedis实例：手机验证码功能 #

> 要求：  
> 1、输入手机号，点击发送后随机生成6位数字码，2分钟有效  
> 2、输入验证码，点击验证，返回成功或失败  
> 3、每个手机号每天只能输入3次

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2V4b2R1czM_size_16_color_FFFFFF_t_70]

代码展示：

import redis.clients.jedis.Jedis;
        
    import java.util.Random;
    
    public class PhoneCode { 
        public static void main(String[] args) { 
            //模拟验证码发送
            //verifyCode("137000000");
            
            //校验发送的验证码
            //getRedisCode("137000000","验证码");
        }
    
        //1.随即生成一个六位数的验证码
        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){ 
            //连接redis
            Jedis jedis = new Jedis("192.168.50.128", 6379);
            //输入redis连接密码
            jedis.auth("root");
    
            //拼接key
            //手机发送次数key
            String countKey = "VerifyCode" + phone + ":count";
            //验证码key
            String codeKey = "VerifyCode" + phone + ":code";
    
            //每个手机每天只能发送3次
            String count = jedis.get(countKey);
            if (count == null){ 
                //没有发送次数，第一次发送
                //设置发送次数是1
                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中,设置过期时间为120s
            String vcode = getCode();
            jedis.setex(codeKey,120,vcode);
            jedis.close();
        }
    
        //3.验证码校验
        public static void getRedisCode(String phone,String code){ 
            //从redis中获取验证码
            Jedis jedis = new Jedis("192.168.50.128", 6379);
            jedis.auth("root");
    
            //验证码key
            String codeKey = "VerifyCode" + phone + ":code";
            String redisCode = jedis.get(codeKey);
    
            //判断
            if (redisCode.equals(code)){ 
                System.out.println("成功");
            }else { 
                System.out.println("失败");
            }
            jedis.close();
        }
    }

# 三、Redis与SpringBoot整合 #

Spring Boot整合Redis非常简单，只需要按如下步骤整合即可：

1.  在pom.xml文件中引入redis相关依赖

<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>

1.  application.properties配置redis配置

#Redis服务器地址
    spring.redis.host=192.168.50.128
    #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

1.  添加Redis配置类

@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;
        }
    }

1.  测试一下：RedisTestController中添加测试方法

@RestController
    @RequestMapping("/redisTest")
    public class RedisTestController { 
        @Autowired
        private RedisTemplate redisTemplate;
    
        @GetMapping
        public String testRedis() { 
            //设置值到redis
            redisTemplate.opsForValue().set("name","lucy");
            //从redis获取值
            String name = (String)redisTemplate.opsForValue().get("name");
            return name;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2V4b2R1czM_size_16_color_FFFFFF_t_70]: /images/20221004/cf9ba7b763274c59a78f818d74e9d7de.png