Reddis客户端之Jedis

Jedis简介

简单来说就是Java与redis连接服务

Helloworld（Jedis版）

创建maven工程

<dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.7.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

在test文件下创建文件，同时打开redis.server

package test;

import org.junit.Test;
import redis.clients.jedis.Jedis;


public class JedisTest {
    @Test
    public void testJedis() {
        //1.连接redis
        Jedis jedisTest = new Jedis("127.0.0.1", 6379);
        //2.操作redis
        //先set方法，后注释掉，再get方法
//        jedisTest.set("name","HelloWorld");
        String name = jedisTest.get("name");
        System.out.println(name);
        //3.关闭连接
        jedisTest.close();
    }
}

jedis读写redis数据

测试list

@Test
    public void testJedis() {
        //1.连接redis
        Jedis jedisTest = new Jedis("127.0.0.1", 6379);
        //2.操作redis
        jedisTest.lpush("list1", "a", "b","c");
        jedisTest.lpush("list1","x");

        List<String> list1 = jedisTest.lrange("list1", 0, -1);
        for (String s : list1) {
            System.out.println(s);
        }
        //llen返回列表的长度
        System.out.println(jedisTest.llen("list1"));

        System.out.println();
        //3.关闭连接
        jedisTest.close();
    }

测试hash

@Test
    public void testJedis() {
        //1.连接redis
        Jedis jedisTest = new Jedis("127.0.0.1", 6379);
        //2.操作redis
        jedisTest.hset("hash1","a1","a1");
        jedisTest.hset("hash1","a2","a2");
        jedisTest.hset("hash1","a3","a3");

        Map<String,String> hash1=jedisTest.hgetAll("hash1");

        System.out.println(hash1);

        System.out.println(jedisTest.hlen("hash1"));
        //3.关闭连接
        jedisTest.close();
    }

案例：模拟验证码发送

{
    public static void main(String[] args) {
    //模拟验证码发送
        verifyCode("123456","1");
    }

    //验证码校验
    public static void getRedisCode(String phone,String code){
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        //验证码key
        String  codeKey="VerifyCode"+phone+":code";
        String s = jedis.get(codeKey);
        //判断
        if(s.equals(code)){
            System.out.println("成功");
        }else{
            System.out.println("失败");
        }
        jedis.close();
    }

    //2、每个手机每天只能发送三次，验证码放在redis中，设置过期时间
    public static void verifyCode(String phone,String code){
        //连接redis
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        //拼接key
        //手机发送次数key
        String countKey="VerifyCode"+phone+":count";
        //验证码key
        String  codeKey="VerifyCode"+phone+":code";

        //每个手机每天只能发送三次
        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("今天已经发送次数超过三次了");
            jedis.close();
        }
        //发送验证码到redis里面去
        String code1 = getCode();
        jedis.setex(codeKey,120,code1);
        jedis.close();
    }

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

在SpringBoot项目中,可以使用Spring Data Redis来简化Redis的操作

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

#Redis相关配置
spring:
  redis:
    host: localhost
    port: 6379
      #password:
    database: 0 #操作的就是默认Redis的0号数据库
    jedis:
      #Redis连接池配置
      pool:
        max-active: 8 #最大连接数
        max-wait: 1ms #连接池最大阻塞等待时间
        max-idle: 4 #连接池的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接

修改测试类

@SpringBootTest
class SpringBootJedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        redisTemplate.opsForValue().set("city","wuhan");
    }
}

运行（记得打开redis-service和redis-cli）

结果却发现keys不是city，而是一堆（第一条），原因是没有配置
添加配置类(放在config包下)

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<Object,Object> redisTemplate=new RedisTemplate<>();

        //默认key序列化器为:JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(redisConnectionFactory);

        return redisTemplate;
    }
}

在运行测试类(修改key为city123)

数字类型操作

@SpringBootTest
class SpringBootJedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test(){
        redisTemplate.opsForValue().set("city123","wuhan");

        String value = (String) redisTemplate.opsForValue().get("city123");
        System.out.println(value);

        redisTemplate.opsForValue().set("key1","value1",10l, TimeUnit.SECONDS);
//修改对应的键值的值
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city123", "shenzhen");
        System.out.println(aBoolean);
    }
}

第一次输入keys *会有key1这个键值，10s后就没了

//操作hash类型数据
    @Test
    public void testHash() {
        HashOperations hashOperations = redisTemplate.opsForHash();

        //存值
        hashOperations.put("001", "name", "xiaoming");
        hashOperations.put("001", "age", "20");
        hashOperations.put("001", "address", "beijing");

        //取值
        String age = (String) hashOperations.get("001", "age");
        System.out.println(age);

        //获取hash结构所有的字段
        Set keys = hashOperations.keys("001");
        for (Object key : keys) {
            System.out.println(key);
        }

        //获取hash结构的所有值
        List values = hashOperations.values("001");
        for (Object value : values) {
            System.out.println(value);
        }
    }

//操作list类型数据
    @Test
    public void testList(){
        ListOperations listOperations = redisTemplate.opsForList();

        //存值
        listOperations.leftPush("myList","a");
        listOperations.leftPushAll("myList","b","c","d");

        //取值
        List myList = listOperations.range("myList", 0, -1);
        for (Object o : myList) {
            System.out.println(o);
        }
        
        //获得列表长度
        Long size = listOperations.size("myList");
        int lsize = size.intValue();
        for (int i = 0; i < lsize; i++) {
            //出队列
            Object myList1 = listOperations.rightPop("myList");
            System.out.println(myList1);
        }
    }

//操作set类型数据
    @Test
    public void testSet(){
        SetOperations setOperations = redisTemplate.opsForSet();
        //存值
        setOperations.add("mySet","a","b");

        //取值
        Set mySet = setOperations.members("mySet");
        for (Object o : mySet) {
            System.out.println(o);
        }

        //删除成员
        setOperations.remove("mySet","a","b");
     }
    }

//操作ZSet
    @Test
    public void testZset(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //存值
        zSetOperations.add("myZset","a",10.0);
        zSetOperations.add("myZset","b",11.0);
        zSetOperations.add("myZset","c",12.0);
        zSetOperations.add("myZset","a",13.0);

        //取值
        Set<String> myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }

        //修改分数
        zSetOperations.incrementScore("myZset","b",20);

        //删除成员
        zSetOperations.remove("myZset","a","b");
    }

通用数据操作

 //通用操作,针对不同数据类型都可以操作
    @Test
    public void testCommon(){
        //获取Redis当中的所有key
        Set keys = redisTemplate.keys("*");
        for (Object key : keys) {
            System.out.println(key);
        }

        //判断某个key是否存在
        Boolean yingcai = redisTemplate.hasKey("yingcai");
        System.out.println(yingcai);

        //删除指定key
        redisTemplate.delete("001");

        //获取指定key对应的value值
        DataType mySet = redisTemplate.type("mySet");
        System.out.println(mySet.name());
    }