Redis学习之Jedis的操作和使用

1、Jedis的介绍
2、Jedis的应用准备工作
3、操作基本的key
4、操作String类型数据
5、操作List类型
6、操作Hash数据类型
7、操作Set类型数据
8、操作有序集合类型

1、Jedis的介绍

Jedis就是Redis在Java中的实现，所以Jedis就是集成了Redis的一些命令操作，封装了Redis的Java客户端，提供了连接池管理。虽然Jedis是Redis官方推荐的面向Java的操作Redis的客户端，但是我们一般不直接使用Jedis，而是在其上在封装一层，作为业务的使用。所以一般会使用RedisTemplate，RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。所以我们这里简单了解Jedis的使用即可。

回到顶部

2、Jedis的应用准备工作

首先要修改redis.conf配置文件的这两项：

bind 127.0.0.1 注释掉

protected-mode 设置为no

额外还有一点需要注意的是开启对应的端口：

CentOS7下查看防火墙运行访问的端口号：firewall-cmd --list-ports
开启6379端口号：firewall-cmd --zone=public --add-port=6379/tcp --permanent
重启防火墙：firewall-cmd --reload

然后需要导入相关依赖：

<dependencies>
    <!-- Jedis的支持包 -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.3.0</version>
    </dependency>
    <!-- Junit测试包 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <!-- 导入slf4j包 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
        <version>1.7.2</version>
    </dependency>

创建生成Jedis连接的JedisPoolUtil.java工具类，其中：

redis.clients.jedis.JedisPool：加载配置信息创建连接池
redis.clients.jedis.JedisPoolConfig：存放配置信息

package com.thr.redis;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
 
public class JedisPoolUtil {
    private static JedisPool jedisPool;
 
    static {
        //连接池配置信息，不写使用默认值
        JedisPoolConfig config = new JedisPoolConfig();
        //可用最大连接数
        config.setMaxTotal(50);
        //最大空闲连接数
        config.setMaxIdle(5);
        //最长等待时间
        config.setMaxWaitMillis(10000);
        //在获取redis连接时，自动检测连接是否有效
        config.setTestOnBorrow(true);
        //我的redis数据库设置了密码，所以需要密码参数
        ////jedisPool=new JedisPool(config,ADDR,PORT,TIMEOUT,AUTH);
        jedisPool=new JedisPool(config,"192.168.30.102",6379,60000,"123456");
    }
    //获取Redis资源
    public synchronized static Jedis getJedis(){
        try
        {
            if (jedisPool!=null)
            {
                Jedis jedis=jedisPool.getResource();
                return jedis;
            }else {
                return null;
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }
    //释放redis资源
    @SuppressWarnings("deprecation")
    public synchronized static void releaseConn(Jedis jedis){
        if (jedisPool!=null)
        {
            jedisPool.close();
        }
    }
}

然后通过Jedis的ping()方法测试是否成功连接到了redis。

@Test
public void testPing(){
    Jedis jedis = JedisPoolUtil.getJedis();
    //测试是否成功连接redis
    System.out.println(jedis.ping());
}

输出结果如下：

看到输出PONG，则表示连接成功了！下面我们分别来使用Jedis操作Redis的一些命令。

回到顶部

3、操作基本的key

//对key的操作
@Test
public void operateKey()  {
    System.out.println("******对key的操作******");
    Jedis jedis = JedisPoolUtil.getJedis();
    try {
        // 1.flushDB():清空Redis数据库（谨慎操作）
        System.out.println(jedis.flushDB());
        // 2.exists():判断key是否存在
        System.out.println(jedis.exists("key1"));
        jedis.set("key1","value1");
        jedis.set("key2","value2");
        System.out.println(jedis.exists("key1"));
        // 3.keys():查询匹配的key
        // KEYS * 匹配数据库中所有 key 。
        // KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
        // KEYS h*llo 匹配 hllo 和 heeeeello 等。
        // KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
        System.out.println(jedis.keys("*"));
        // 4.expire();设置60秒后该key过期
        jedis.expire("key2", 60);
        // 5.pttl():获取key的剩余生存时间
        System.out.println(jedis.pttl("key2"));
        // 6.persist():移除key的过期时间
        jedis.persist("key");
        // 7.type():获取key的类型, "string", "list", "set". "none" none表示key不存在
        System.out.println("type: " + jedis.type("key2"));
        // 8.renamenx():将key重命名
        jedis.renamenx("key2", "key2_rename");
        System.out.println("key2是否存在: " + jedis.exists("key2"));// 判断是否存在
        System.out.println("key2_rename是否存在: " + jedis.exists("key2_rename"));// 判断是否存在
        // 9.del():删除key
        jedis.del("key2");
        System.out.println(jedis.exists("key2"));
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JedisPoolUtil.releaseConn(jedis);
    }
}

输出结果如下：

回到顶部

4、操作String类型数据

//操作String类型数据
@Test
public void operateString(){
    System.out.println("******对String的操作******");
    Jedis jedis = JedisPoolUtil.getJedis();
    try {
        // 清空Redis数据库（谨慎操作）
        //System.out.println(jedis.flushDB());
        // 1.set():设置键值(key-value)
        jedis.set("hello", "String");
        System.out.println("获取的值为:"+jedis.get("hello"));
        // 2.append():在键值后追加内容
        jedis.append("hello", " This is append String");
        System.out.println("拼接后的值为:"+jedis.get("hello"));
        // 3.mset():同时设置多个key-value
        jedis.mset("a","1","b","2","c","3");
        System.out.println("批量获取值:"+jedis.mget("a", "b", "c"));
        // 4.setex():设置key过期时间
        jedis.setex("hello2",3,"String");
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("key的剩余过期时间:"+jedis.pttl("hello2"));
        // 5.setnx():在键key不存在的情况下，将键key的值设置为value，当且仅当可以存在(这个命令非常重要，可以实现分布式锁的功能）
        // 解释：如果key存在，则SETNX不做任何动作，如果key不存在则相当于进行SET操作
        jedis.setnx("hello","world");
        //jedis.setnx("h","w");
        System.out.println(jedis.get("hello"));
        System.out.println(jedis.keys("*"));
        // 6.incr():如果键key的值是整数可以进行加减操作，其他它类型会报错
        jedis.set("testInt", "0");
        jedis.incr("testInt");
        System.out.println("整数值进行加操作:"+jedis.get("testInt"));
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        JedisPoolUtil.releaseConn(jedis);
    }
}

输出结果如下：

回到顶部

5、操作List类型

//操作List类型
@Test
public void operateList(){
    System.out.println("******对List的操作******");
    Jedis jedis=JedisPoolUtil.getJedis();
    try
    {
        // 清空Redis数据库（谨慎操作）
        System.out.println(jedis.flushDB());
        // 1.lpush():从列表左侧增加元素，lpush()方法参数列表是可变参数
        jedis.lpush("redisList","aaa","bbb","ccc","ddd");
        // 2.lpushx():将值value插入到列表key的前面，仅当key存在并且是同一个List
        // 和LPUSH命令相反，当可以不存在是，LPUSHX命令上面也不做
        // 注意：LPUSHX和RPUSHX只能插入已存在的List中，如果键key不存在就不进行任何操作
        jedis.lpushx("redisList", "AAA","BBB");
        // 3.lrange():返回List列表中key指定区间内的元素，偏移量start-stop,当start是0,stop是-1时表示遍历整个redisList
        System.out.println("List列表的元素："+jedis.lrange("redisList", 0, -1));
        List<String> redisList=jedis.lrange("redisList", 0, -1);
        System.out.print("遍历出来的List元素:");
        for (int i = 0; i < redisList.size(); i++ )
        {
            System.out.print(redisList.get(i)+" ");
        }
        System.out.println();
        // 4.llen():返回List列表的长度
        System.out.println("List列表的长度为:"+jedis.llen("redisList"));
        // 5.linsert():可以在指定值后插入元素，如果该元素有多个，只在第一个后面插入
        jedis.linsert("redisList", ListPosition.AFTER, "AAA", "CCC");
        jedis.linsert("redisList", ListPosition.AFTER, "CCC", "DDD");
        System.out.println(jedis.lrange("redisList", 0, -1));
        // 6.lindex():根据指定索引获取值，索引为正从左往右获取，索引为负从右向左获取
        String index2=jedis.lindex("redisList", 2);
        String index_2=jedis.lindex("redisList", -2);
        System.out.println("从左到右获取索引为2的值为:"+index2);
        System.out.println("从右到左获取索引为2的值为:"+index_2);
        // 7.lset():修改列表指定索引元素，若不存在则报错
        jedis.lset("redisList", 1, "updateValue");
        System.out.println("修改索引为1的值:"+jedis.lindex("redisList", 1));
        System.out.println(jedis.lrange("redisList", 0, -1));
        // 8.lpop():删除列表左侧头部元素
        String lrem=jedis.lpop("redisList");
        System.out.println("删除列表的头部元素:"+lrem);
        // 9.rpop():删除列表右侧头部元素
        String rrem=jedis.rpop("redisList");
        System.out.println("删除列表的尾部元素:"+rrem);
        // 10.ltrim():去除索引范围外的元素
        String ltrim=jedis.ltrim("redisList", 1, 3);
        System.out.println("去除key为redisList,索引在1-3之外的其它元素:"+ltrim);
        System.out.println(jedis.lrange("redisList", 0, -1));
        // 11.lrem():移出指定值的索引位置，如果count>0从左往右删除count个该元素，如果count=0删除列表中与value相同的元素，如果count<0从右往左删除count个该元素
        jedis.lrem("redisList", 1, "CCC");
        System.out.println("移除从左到右key为redisList,值为CCC的一个元素:"+jedis.lrange("redisList", 0, -1));
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
    finally{
        JedisPoolUtil.releaseConn(jedis);
    }
}

输出结果如下：

回到顶部

6、操作Hash数据类型

//操作Hash类型数据
@Test
public void operateHash(){
    System.out.println("******对Hash的操作******");
    Jedis jedis=JedisPoolUtil.getJedis();
    try
    {
        //清空数据库（谨慎操作）
        System.out.println(jedis.flushDB());
        Map<String, String> map=new HashMap<String, String>();
        map.put("username", "张三");
        map.put("password", "123456");
        map.put("age", "24");
        map.put("sex", "男");
        // 1.hmset():批量添加hash类型数据
        jedis.hmset("user", map);
        // 2.hget():获取该键包含的指定键值
        System.out.println("获取指定key的值:"+jedis.hget("user", "username"));
        // 3.hgetAll():获取Hash表中该键包含的所有键值对
        System.out.println("该key中所有的键值对:"+jedis.hgetAll("user"));
        // 4.hexists():判断key是否存在
        boolean isExists=jedis.hexists("user", "address");
        System.out.println("Key address是否存在?"+(isExists?"是":"否"));
        // 5.hlen():获取该散列表包含的键的个数
        long hlen=jedis.hlen("user");
        System.out.println("散列表的key为user的长度为:"+hlen);
        // 6.hset():向散列中添加键值
        jedis.hset("user", "address", "中国深圳");
        // 7.hkeys()/hvals:返回哈希表中key所有的域和域的值。
        System.out.println("哈希表key为user的所有域为:"+jedis.hkeys("user"));
        System.out.println("哈希表key为user的所有域值为:"+jedis.hvals("user"));
        // 8.hincrBy():如果键值是整型，可以加减该键值
        jedis.hincrBy("user", "age",2);
        System.out.println("增加后的age为:"+jedis.hget("user","age"));
        // 9.hdel():删除散列中的键
        jedis.hdel("user", "address");
        isExists=jedis.hexists("user", "address");
        System.out.println("user对象中的address是否还存在?"+(isExists?"是":"否"));
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
    finally{
        JedisPoolUtil.releaseConn(jedis);
    }
}

输出结果如下：

回到顶部

7、操作Set类型数据

//操作Set类型数据
@Test
public void operateSet(){
    System.out.println("******对Set的操作******");
    Jedis jedis=JedisPoolUtil.getJedis();
    try
    {
        //清空数据库（谨慎操作）
        System.out.println(jedis.flushDB());
        // 1.sadd():添加元素，注意与List类型的区别，Set不会存储重复元素
        jedis.sadd("redisSet", "AAA");
        jedis.sadd("redisSet", "AAA","BBB");
        jedis.sadd("redisSet", "AAA","BBB","CCC","DDD");
        // 2.scard():获取集合里面的元素数量
        System.out.println(jedis.scard("Set集合中的数量为:"+"redisSet"));
        // 3.smembers():查询Set集合中的所有元素
        Set<String> redisSet=jedis.smembers("redisSet");
        System.out.println("Set集合中的所有元素:"+redisSet);
        System.out.print("Set集合中遍历出来的所有元素:");
        Iterator<String> iterator=redisSet.iterator();
        while (iterator.hasNext())
        {
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
        // 4.sismember():判断元素是否存在于集合内
        boolean isExists=jedis.sismember("redisSet", "AAA");
        System.out.println("AAA是否在redisSet?"+(isExists?"是":"否"));
        // 5、集合运算（并集、交集、差集）
        // (1)、并集
        jedis.sadd("redisSet2", "aaa","bbb","ccc");
        Set<String> unionSet=jedis.sunion("redisSet","redisSet2");
        System.out.println("交集结果:"+unionSet);
        // 并集结果存入到另一个Set集合,并且只返回集合的数量
        System.out.println("并集结果存入unionSet集合:"+jedis.sunionstore("unionSet", "redisSet","redisSet2"));
        // (2)、交集
        Set<String> interSet=jedis.sinter("redisSet","unionSet");
        System.out.println("交集结果:"+interSet);
        // 交集结果存入到另一个Set集合,并且只返回集合的数量
        System.out.println("交集结果存入interSet集合:"+jedis.sinterstore("interSet", "redisSet","unionSet"));
        // (3)、差集
        Set<String> diffSet=jedis.sdiff("redisSet","redisSet2");
        System.out.println("差集结果:"+diffSet);
        // 差集结果存入到另一个Set集合,并且只返回集合的数量
        System.out.println("差集结果存入diffSet集合:"+jedis.sdiffstore("diffSet","redisSet","redisSet2"));
        // 6.spop():移除并且返回集合中的一个随机元素
        System.out.println(jedis.spop("diffSet"));
        // 7.srem():删除指定集合元素
        System.out.println(jedis.srem("unionSet", "aaa"));
        // 8.smove():将一个集合中的元素移入另一个集合中
        jedis.smove("redisSet", "redisSet2", "AAA");
        System.out.println("redisSet元素为:"+jedis.smembers("redisSet"));
        System.out.println("redisSet2元素为:"+jedis.smembers("redisSet2"));
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
    finally{
        JedisPoolUtil.releaseConn(jedis);
    }
}

输出结果如下：

回到顶部

8、操作有序集合类型

//操作有序集合(SortedSet)类型
@Test
public void operateSortedSet(){
    System.out.println("******对有序集合(SortedSet)的操作******");
    Jedis jedis=JedisPoolUtil.getJedis();
    try
    {
        //清空数据库（谨慎操作）
        System.out.println(jedis.flushDB());
        // 1.zadd():添加元素到有序集合
        jedis.zadd("scores", 69,"张三");
        jedis.zadd("scores", 83,"李四");
        jedis.zadd("scores", 73,"王五");
        //zadd()方法也有重载的传入map类型,分数是Double类型
        Map<String, Double> scoresMap=new HashMap<String, Double>();
        scoresMap.put("赵六", new Double(59));
        scoresMap.put("孙七", new Double(99));
        jedis.zadd("scores",scoresMap);
        // 2.zcard():返回集合中的元素个数
        System.out.println("有序集合中的个数:"+jedis.zcard("scores"));
        // 3.zrange():查询有序集合的元素
        System.out.println("按照分数从低到高查询zrange:"+jedis.zrange("scores", 0, -1));
        System.out.println("按照分数从高到低查询zrange:"+jedis.zrevrange("scores", 0, -1));
        // 4.zrangeWithScores():使用Set存储元组遍历元组内分数和元素
        Set<Tuple> sortSet=jedis.zrangeWithScores("scores", 0, -1);
        Iterator<Tuple>iterator=sortSet.iterator();
        while(iterator.hasNext()){
            Tuple tuple=iterator.next();
            System.out.println(tuple.getScore()+":"+tuple.getElement());
        }
        // 5.zrangeByScore():根据分数范围查询元素(60<=score<=100)
        Set<String> zrangeByScore=jedis.zrangeByScore("scores", new Double(60), new Double(100));
        System.out.print("查询分数范围在(60<=score<=100)之间的元素结果为:");
        for (Iterator<String> it=zrangeByScore.iterator();it.hasNext();)
        {
            System.out.print(it.next()+" ");
        }
        System.out.println();
        // 6.zcount():查询指定分数范围内(60<=score<=100)zset键的元素个数
        long rangeCount=jedis.zcount("scores", 60, 100);
        System.out.println("分数范围在(60<=score<=100)之间键的元素个数:"+rangeCount);
        // 7.zrank():查询指定元素的下标，不存在则返回null
        long zrank=jedis.zrank("scores", "张三");
        System.out.println("查询指定元素的下标为:"+zrank);
        // 8.zscore():查询指定元素的分数，不存在则返回null
        Double zscore=jedis.zscore("scores", "张三");
        System.out.println("查询指定元素的分数为:"+zscore);
        // 9.zincrby():为有序集合的score分数添加一个增量
        Double zincrby=jedis.zincrby("scores", 99, "张三");
        System.out.println("增加后张三的score分数为:"+zincrby);
        // 10.zrem():删除指定元素
        jedis.zrem("scores", "张三");
        // 11.zremrangeByScore():根据分数范围删除元素
        jedis.zremrangeByScore("scores", 60, 80);
        System.out.println("集合的元素为:"+jedis.zrange("scores", 0, -1));
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
    finally{
        JedisPoolUtil.releaseConn(jedis);
    }
}