Redis 笔记之 Java 操作 Redis（Jedis）

╰+哭是因爲堅強的太久メ 2023-02-22 13:37 2阅读 0赞

### Java 操作 Redis ###

*  环境准备
 *   *  引入依赖
     *  创建 jedis 对象
 *  操作 Key 相关 API
 *  操作 String 相关 API
 *  操作 List 相关 API
 *  操作 Set 的相关 API
 *  操作 ZSet 相关 API
 *  操作 Hash 相关 API

# 环境准备 #

## 引入依赖 ##

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

## 创建 jedis 对象 ##

Centos 7 关闭防火墙：

systemctl stop firewalld.service

开启远程连接：详见 [Redis入门之Redis安装、配置及常用指令][Redis_Redis]

/** * 测试 Redis 连接 */
    public class TestRedis { 
        public static void main(String[] args) { 
            // 1.创建 jedis 对象
                // redis服务必须关闭防火墙
                // redis服务必须开始远程连接
            Jedis jedis = new Jedis("192.168.3.65", "6379");
            // 2.执行相关操作
            jedis.select(0); // 选择操作的数据库, 默认0号
            // ......
            // 3.释放资源
            jedis.close();
        }
    }

# 操作 Key 相关 API #

DEL 指令

*  语法 : `DEL key [key ...]`
 *  作用 : 删除给定的一个或多个 key，不存在的 key 会被忽略。
 *  可用版本： >= 1.0.0
 *  返回值： 被删除 key 的数量。

EXISTS 指令

*  语法: `EXISTS key`
 *  作用: 检查给定 key 是否存在。
 *  可用版本： >= 1.0.0
 *  返回值： 若 key 存在，返回1 ，否则返回0。

EXPIRE 指令

*  语法: `EXPIRE key seconds`
 *  作用: 为给定 key 设置生存时间(秒)，当 key 过期时(生存时间为 0)，它会被自动删除。
 *  可用版本： >= 1.0.0
 *  时间复杂度： O(1)
 *  返回值：设置成功返回 1 。

KEYS 指令

*  语法 : `KEYS pattern`
 *  作用 : 查找所有符合给定模式 pattern 的 key 。
 *  语法:  
    `KEYS *`：匹配数据库中所有 key 。  
    `KEYS h?llo`：匹配 hello ，hallo 和 hxllo 等。  
    `KEYS h*llo`：匹配 hllo 和 heeeeello 等。  
    `KEYS h[ae]llo`： 匹配 hello 和 hallo ，但不匹配 hillo 。特殊符号用 `\` 隔开
 *  可用版本： >= 1.0.0
 *  返回值： 符合给定模式的 key 列表。

MOVE 指令

*  语法 : `MOVE key db`
 *  作用 : 将当前数据库的 key 移动到给定的数据库 db 当中。
 *  可用版本： >= 1.0.0
 *  返回值： 移动成功返回 1 ，失败则返回 0 。

PEXPIRE 指令

*  语法 : `PEXPIRE key milliseconds`
 *  作用 : 这个命令和 `EXPIRE` 命令的作用类似，但是它以 **毫秒** 为单位设置 key 的生存时间  
    （`EXPIRE` 以秒为单位)
 *  可用版本： >= 2.6.0
 *  时间复杂度： O(1)
 *  返回值：设置成功，返回1。key 不存在或设置失败，返回0

PEXPIREAT 指令

*  语法 : `PEXPIREAT key milliseconds-timestamp`
 *  作用 : 这个命令和 `EXPIREAT` 命令类似，但它以 **毫秒** 为单位设置 key 的过期 unix 时间戳（`EXPIREAT` 以秒为单位）
 *  可用版本： >= 2.6.0
 *  返回值：如果生存时间设置成功，返回 1 。当 key 不存在或没办法设置生存时间时，返回 0 。  
    (查看EXPIRE 命令获取更多信息)

TTL 指令

*  语法 : `TTL key`
 *  作用 : 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
 *  可用版本： >= 1.0.0
 *  返回值：  
    当 key 不存在时，返回 -2 。  
    当 key 存在但没有设置剩余生存时间时，返回 -1 。  
    否则，以秒为单位，返回 key 的剩余生存时间。
 *  Note : Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

PTTL 指令

*  语法 : `PTTL key`
 *  作用 : 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间  
    （TTL 以秒为单位）
 *  可用版本： >= 2.6.0
 *  返回值： 当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。
 *  否则，以毫秒为单位，返回 key 的剩余生存时间。
 *  注意 : Redis 2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1 。

RANDOMKEY 指令

*  语法 : `RANDOMKEY`
 *  作用 : 从当前数据库中随机返回(不删除) 一个 key 。
 *  可用版本： >= 1.0.0
 *  返回值：当数据库不为空时，返回一个 key 。当数据库为空时，返回 `nil` 。

RENAME 指令

*  语法 : `RENAME key newkey`
 *  作用 : 将 key 改名为 newkey 。  
    当 key 和 newkey 相同，或者 key 不存在时，返回一个错误。  
    当 newkey 已经存在时，`RENAME` 命令将覆盖旧值。
 *  可用版本： >= 1.0.0
 *  返回值： 改名成功时提示OK ，失败时候返回一个错误。

TYPE 指令

*  语法 : `TYPE key`
 *  作用 : 返回 key 所储存的值的类型。
 *  可用版本： >= 1.0.0
 *  返回值：  
    `none`：key 不存在  
    `string`：字符串  
    `list`：列表  
    `set`：集合  
    `zset`：有序集  
    `hash`：哈希表

public class TestKeys { 
        private Jedis jedis;
        @Before
        public void before() { 
        	// 连接开启了redis服务的虚拟机
            jedis = new Jedis("192.168.3.65", 6379);
        }
        @After
        public void after() { 
            jedis.close();
        }
        @Test
        public void testKeys() { 
            // 删除一个key
            jedis.del("name");
            // 删除多个key
            jedis.del("name", "age");
    
            // 设置一个key
            jedis.set("age", "hello");
    
            // 判断一个key是否存在
            Boolean name = jedis.exists("name");
            System.out.println(name);
    
            // 设置一个key超时时间
            Long age = jedis.expire("age", 100);
            System.out.println(age);
    
            // 获取一个key超时时间
            Long ttl = jedis.ttl("age");
            System.out.println(ttl);
    
            // 随机获取一个key
            String s = jedis.randomKey();
    
            // 修改key名称
            jedis.rename("age", "newage");
    
            // 查看对应值的类型
            String type1 = jedis.type("name");
            System.out.println(type1);
            String type2 = jedis.type("maps");
            System.out.println(type2);
        }
    }

# 操作 String 相关 API #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>set</td> 
   <td>设置一个key/value</td> 
  </tr> 
  <tr> 
   <td>get</td> 
   <td>根据key获得对应的value</td> 
  </tr> 
  <tr> 
   <td>mset</td> 
   <td>一次设置多个key value</td> 
  </tr> 
  <tr> 
   <td>mget</td> 
   <td>一次获得多个key的value</td> 
  </tr> 
  <tr> 
   <td>getset</td> 
   <td>获得原始key的值，同时设置新值</td> 
  </tr> 
  <tr> 
   <td>strlen</td> 
   <td>获得对应key存储value的长度</td> 
  </tr> 
  <tr> 
   <td>append</td> 
   <td>为对应key的value追加内容</td> 
  </tr> 
  <tr> 
   <td>getrange 索引0开始</td> 
   <td>截取value的内容</td> 
  </tr> 
  <tr> 
   <td>setex</td> 
   <td>设置一个key存活的有效期（秒）</td> 
  </tr> 
  <tr> 
   <td>psetex</td> 
   <td>设置一个key存活的有效期（毫秒）</td> 
  </tr> 
  <tr> 
   <td>setnx</td> 
   <td>存在不做任何操作,不存在添加</td> 
  </tr> 
  <tr> 
   <td>msetnx原子操作(只要有一个存在不做任何操作)</td> 
   <td>可以同时设置多个key,只要有一个存在都不保存</td> 
  </tr> 
  <tr> 
   <td>decr</td> 
   <td>进行数值类型的-1操作</td> 
  </tr> 
  <tr> 
   <td>decrby</td> 
   <td>根据提供的数据进行减法操作</td> 
  </tr> 
  <tr> 
   <td>incr</td> 
   <td>进行数值类型的+1操作</td> 
  </tr> 
  <tr> 
   <td>incrby</td> 
   <td>根据提供的数据进行加法操作</td> 
  </tr> 
  <tr> 
   <td>incrbyfloat</td> 
   <td>根据提供的数据加入浮点数</td> 
  </tr> 
 </tbody> 
</table>

public class TestString { 
        private Jedis jedis;
        @Before
        public void before() { 
            jedis = new Jedis("192.168.3.65", 6379);
        }
        @After
        public void after() { 
            jedis.close();
        }
        @Test
        public void testString() { 
            jedis.set("name", "zhenyu"); // set
    
            String name = jedis.get("name"); // get
            System.out.println(name);
    
            jedis.mset("content", "好人", "address", "苏州市"); // mset
    
            List<String> mget = jedis.mget("name", "content", "address"); // mget
            mget.forEach(v -> System.out.println("v = " + v));
    
            String set = jedis.getSet("name", "yusael");
            System.out.println(set);
    
            // ...
        }
    }

# 操作 List 相关 API #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>lpush</td> 
   <td>将某个值加入到一个key列表头部</td> 
  </tr> 
  <tr> 
   <td>lpushx</td> 
   <td>同lpush,但是必须要保证这个key存在</td> 
  </tr> 
  <tr> 
   <td>rpush</td> 
   <td>将某个值加入到一个key列表末尾</td> 
  </tr> 
  <tr> 
   <td>rpushx</td> 
   <td>同rpush,但是必须要保证这个key存在</td> 
  </tr> 
  <tr> 
   <td>lpop</td> 
   <td>返回和移除列表左边的第一个元素</td> 
  </tr> 
  <tr> 
   <td>rpop</td> 
   <td>返回和移除列表右边的第一个元素</td> 
  </tr> 
  <tr> 
   <td>lrange</td> 
   <td>获取某一个下标区间内的元素</td> 
  </tr> 
  <tr> 
   <td>llen</td> 
   <td>获取列表元素个数</td> 
  </tr> 
  <tr> 
   <td>lset</td> 
   <td>设置某一个指定索引的值(索引必须存在)</td> 
  </tr> 
  <tr> 
   <td>lindex</td> 
   <td>获取某一个指定索引位置的元素</td> 
  </tr> 
  <tr> 
   <td>lrem</td> 
   <td>删除重复元素</td> 
  </tr> 
  <tr> 
   <td>ltrim</td> 
   <td>保留列表中特定区间内的元素</td> 
  </tr> 
  <tr> 
   <td>linsert</td> 
   <td>在某一个元素之前，之后插入新元素</td> 
  </tr> 
 </tbody> 
</table>

public class TestList { 
        private Jedis jedis;
        @Before
        public void before() { 
            jedis = new Jedis("192.168.3.65", 6379);
        }
        @After
        public void after() { 
            jedis.close();
        }
        @Test
        public void testList() { 
    
            jedis.flushDB(); // 清除当前数据库
    
            jedis.lpush("names1", "1", "2", "3", "4", "5"); // lpush
            jedis.rpush("names1", "a", "b", "c", "d", "e"); // rpush
    
            List<String> names1 = jedis.lrange("names1", 0, -1);
            names1.forEach(v -> System.out.println("name = " + v));
    
            String name = jedis.lpop("names1"); // lpop rpop
            System.out.println(name); // 5
    
            System.out.println(jedis.llen("names1")); // llen
    
            // names1 中 2 左边插入一个 world
            Long linsert = jedis.linsert("names1", BinaryClient.LIST_POSITION.BEFORE, "2", "world");// linsert
            System.out.println("linsert: " + linsert);
            names1 = jedis.lrange("names1", 0, -1);
            names1.forEach(v -> System.out.println("name = " + v));
    
            // ...
        }
    }

# 操作 Set 的相关 API #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>sadd</td> 
   <td>为集合添加元素</td> 
  </tr> 
  <tr> 
   <td>smembers</td> 
   <td>显示集合中所有元素 无序</td> 
  </tr> 
  <tr> 
   <td>scard</td> 
   <td>返回集合中元素的个数</td> 
  </tr> 
  <tr> 
   <td>spop</td> 
   <td>随机返回一个元素 并将元素在集合中删除</td> 
  </tr> 
  <tr> 
   <td>smove</td> 
   <td>从一个集合中向另一个集合移动元素 必须是同一种类型</td> 
  </tr> 
  <tr> 
   <td>srem</td> 
   <td>从集合中删除一个元素</td> 
  </tr> 
  <tr> 
   <td>sismember</td> 
   <td>判断一个集合中是否含有这个元素</td> 
  </tr> 
  <tr> 
   <td>srandmember</td> 
   <td>随机返回元素</td> 
  </tr> 
  <tr> 
   <td>sdiff</td> 
   <td>去掉第一个集合中其它集合含有的相同元素</td> 
  </tr> 
  <tr> 
   <td>sinter</td> 
   <td>求交集</td> 
  </tr> 
  <tr> 
   <td>sunion</td> 
   <td>求和集</td> 
  </tr> 
 </tbody> 
</table>

public class TestSet { 
        private Jedis jedis;
        @Before
        public void before() { 
            jedis = new Jedis("192.168.3.65", 6379);
        }
        @After
        public void after() { 
            jedis.close();
        }
        @Test
        public void testSet() { 
            jedis.sadd("names","zhangsan", "lisi");
    
            Set<String> names = jedis.smembers("names");
            names.forEach(v -> System.out.println("v = " + v));
    
            Boolean sismember = jedis.sismember("names", "zhenyu");
            System.out.println(sismember);
        }
    }

# 操作 ZSet 相关 API #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>zadd</td> 
   <td>添加一个有序集合元素</td> 
  </tr> 
  <tr> 
   <td>zcard</td> 
   <td>返回集合的元素个数</td> 
  </tr> 
  <tr> 
   <td>zrange 升序 zrevrange 降序</td> 
   <td>返回一个范围内的元素</td> 
  </tr> 
  <tr> 
   <td>zrangebyscore</td> 
   <td>按照分数查找一个范围内的元素</td> 
  </tr> 
  <tr> 
   <td>zrank</td> 
   <td>返回排名</td> 
  </tr> 
  <tr> 
   <td>zrevrank</td> 
   <td>倒序排名</td> 
  </tr> 
  <tr> 
   <td>zscore</td> 
   <td>显示某一个元素的分数</td> 
  </tr> 
  <tr> 
   <td>zrem</td> 
   <td>移除某一个元素</td> 
  </tr> 
  <tr> 
   <td>zincrby</td> 
   <td>给某个特定元素加分</td> 
  </tr> 
 </tbody> 
</table>

public class TestZSet { 
        private Jedis jedis;
        @Before
        public void before() { 
            jedis = new Jedis("192.168.3.65", 6379);
        }
        @After
        public void after() { 
            jedis.close();
        }
        @Test
        public void testZSet() { 
            jedis.zadd("zset", 8, "张三");
            jedis.zadd("zset", 5, "李四");
            jedis.zadd("zset", 7, "王五");
            jedis.zadd("zset", 2, "赵六");
            jedis.zadd("zset", 33, "Win7");
            jedis.zadd("zset", 6, "Win8");
            jedis.zadd("zset",  77, "Win9");
    
            Set<String> names = jedis.zrange("zset", 0, -1);
            names.forEach(v -> System.out.println("v = " + v +", zscore = " + jedis.zscore("zset", v)));
    
            Long zcard = jedis.zcard("zset");
            System.out.println(zcard);
    
            names = jedis.zrangeByScore("zset", "0", "100", 0, 5);
            names.forEach(v -> System.out.println("v = " + v +", zscore = " + jedis.zscore("zset", v)));
        }
    }

# 操作 Hash 相关 API #

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>hset</td> 
   <td>设置一个key/value对</td> 
  </tr> 
  <tr> 
   <td>hget</td> 
   <td>获得一个key对应的value</td> 
  </tr> 
  <tr> 
   <td>hgetall</td> 
   <td>获得所有的key/value对</td> 
  </tr> 
  <tr> 
   <td>hdel</td> 
   <td>删除某一个key/value对</td> 
  </tr> 
  <tr> 
   <td>hexists</td> 
   <td>判断一个key是否存在</td> 
  </tr> 
  <tr> 
   <td>hkeys</td> 
   <td>获得所有的key</td> 
  </tr> 
  <tr> 
   <td>hvals</td> 
   <td>获得所有的value</td> 
  </tr> 
  <tr> 
   <td>hmset</td> 
   <td>设置多个key/value</td> 
  </tr> 
  <tr> 
   <td>hmget</td> 
   <td>获得多个key的value</td> 
  </tr> 
  <tr> 
   <td>hsetnx</td> 
   <td>设置一个不存在的key的值</td> 
  </tr> 
  <tr> 
   <td>hincrby</td> 
   <td>为value进行加法运算</td> 
  </tr> 
  <tr> 
   <td>hincrbyfloat</td> 
   <td>为value加入浮点值</td> 
  </tr> 
 </tbody> 
</table>

public class TestHash { 
        private Jedis jedis;
        @Before
        public void before() { 
            jedis = new Jedis("192.168.3.65", 6379);
        }
        @After
        public void after() { 
            jedis.close();
        }
        @Test
        public void testHash() { 
            jedis.hset("maps","name","zhangsan");
    
            Map<String, String> map = new HashMap<>();
            map.put("age", "12");
            map.put("content", "好人");
            jedis.hmset("maps", map);
    
            String maps = jedis.hget("maps", "name");
            System.out.println(maps);
            Map<String, String> all = jedis.hgetAll("maps");
            all.forEach((k, v) -> System.out.println("k = " + k + ", v = " + v));
        }
    }

[Redis_Redis]: https://blog.csdn.net/weixin_43734095/article/details/107093787