使用jedis操作redis常用方法

最新推荐文章于 2024-03-22 09:25:27 发布
最新推荐文章于 2024-03-22 09:25:27 发布
阅读量706 收藏 1
点赞数
文章标签： jedis

，在redis入门及在商城案例中的使用中简单介绍了下使用jedis如何操作redis，但是其实方法是跟redis的操作大部分是相对应的。

1、String类型操作
public class StringTest {

    Jedis jedis;
    @Before//该注解下的方法在@Test执行之前执行
    public void before(){
        //创建连接
        jedis = new Jedis("192.168.25.128",6379);
    }
    @After//该注解下的方法在@Test执行之后执行
    public void after(){
        //关闭连接
        jedis.close();
    }
    /*
     * 存储，获取，设置过期时间,key命令
     */
    @Test
    public void test() throws InterruptedException{
        //1.存储值
        jedis.set("name", "张三");
        //2.取值
        String name = jedis.get("name");
        System.out.println(name);
        //3.key命令：查看有效期，-1表示持久化，-2表示不存在
        Long t = jedis.ttl("name");
        System.out.println(t);
        System.out.println("-------------------");
        //4.key命令,对已经存在的key设置过期时间
        jedis.expire("name", 5);
        while(true){
            String name2 = jedis.get("name");
            System.out.println(name2);
            System.out.println("有效期为:"+jedis.ttl("name")+"秒");
            Thread.sleep(2000);
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
输出结果:
张三
-1
-------------------
张三
有效期为:5秒
张三
有效期为:3秒
张三
有效期为:1秒
null
有效期为:-2秒
1
2
3
4
5
6
7
8
9
10
11
12
    /*
     * 测试自增自减:前提，value值能解析为数字类型
     * 删除
     */
    @Test
    public void test2(){
        jedis.set("age", "18");
        String age1 = jedis.get("age");
        System.out.println("当前年龄:"+age1);

        Long age2 = jedis.decr("age");
        System.out.println("一年前年龄为:"+age2);

        Long age3 = jedis.incr("age");
        System.out.println("现在年龄又变回为:"+age3);

        //如果key不存在则忽略此操作
        Long del = jedis.del("age1");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
输出结果:
当前年龄:18
一年前年龄为:17
现在年龄又变回为:18
1
2
3
4
    /*
     * 批量存储和获取
     */
    @Test
    public void test3(){
        jedis.mset("a1","mysql","a2","oracle","a3","sqlServer","a4",
                "redis","a5","mongodb","a6","hbase");
        List<String> list = jedis.mget("a1","a2","a3","a4","a5","a6");
        for (String s : list) {
            System.out.println(s);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
输出结果：
mysql
oracle
sqlServer
redis
mongodb
hbase
1
2
3
4
5
6
7
    /*
     * 存储值的同时设置过期时间,判断key是否存在
     */
    @Test
    public void test4() throws InterruptedException{
        //jedis.setex(key, 过期时间, value)
        jedis.setex("life", 5, "享受美好");
        while(jedis.exists("life")){
            System.out.println(jedis.get("life"));
            Thread.sleep(2000);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
输出结果:在输出三个“享受美好”之后便不再输出
享受美好
享受美好
享受美好
1
2
3
4
2、Hash类型操作
public class MapTest {

    Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.25.128",6379);
    }
    @After
    public void after(){
        jedis.close();
    }

    @Test
    public void test1(){
        //1.存储值
        jedis.hset("student", "name", "小李");
        jedis.hset("student", "class", "小学生");
        jedis.hset("student", "age", "10");
        jedis.hset("student", "skill", "keng");
        //2.获取指定值  获取名字
        String name = jedis.hget("student", "name");
        System.out.println(name);
        System.out.println("----------------------");
        //3.获取存储的map
        Map<String, String> all = jedis.hgetAll("student");
        Set<Entry<String,String>> set = all.entrySet();
        Iterator<Entry<String, String>> iterator = set.iterator();
        while (iterator.hasNext()) {
            Entry<String, String> entry = iterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+":"+value);
        }
        System.out.println("------------------------------");
        //4.获取map中全部key
        Set<String> keySet = jedis.hkeys("student");
        for (String key : keySet) {
            System.out.println(key);
        }
        System.out.println("-------------------------------");
        //5.获取map中全部values
        List<String> list = jedis.hvals("student");
        for (String value : list) {
            System.out.println(value);
        }
        System.out.println("------------------");
        //6.删除指定的值 删除map中class,name两对键值对
        Long long1 = jedis.hdel("student", "class","name");
        Set<String> set2 = jedis.hkeys("student");
        for (String key : set2) {
            System.out.println(key);
        }
        System.out.println("-------------------");
        //7.判断map是否存在
        Boolean e = jedis.hexists("student", "class");
        System.out.println("class是否存在:"+e);
        System.out.println("-----------------");
        //8.自增自减，可以指定增加减少的数值
        jedis.hincrBy("student", "age", 2);
        System.out.println(jedis.hget("student", "age"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
输出结果:
小李
----------------------
skill:keng
name:小李
class:小学生
age:10
------------------------------
name
class
age
skill
-------------------------------
10
keng
小李
小学生
------------------
age
skill
-------------------
class是否存在:false
-----------------
2年后年龄为:12
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
String跟Hash是最常见的类型，在实习这段时间也都只用到这两种，所以我觉得不管怎样这两种至少应该掌握。

3、List类型操作
public class ListTest {
    Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.25.128",6379);
    }
    @After
    public void after(){
        jedis.close();
    }

    @Test
    public void test(){
        //1.存储值(左边开始)。当成栈（子弹匣），先进先出，入栈
        jedis.lpush("scores", "100","90","80","70","60");
        //右边开始存
        jedis.rpush("scores", "50","40","30","20","10");
        //2.取值（左边开始），可以说是同时移除了该值，出栈
        String lv = jedis.lpop("scores");
        //右边开始取
        String rv= jedis.rpop("scores");
        System.out.println("左边取为:"+lv);
        System.out.println("右边取为:"+rv);
        System.out.println("--------------------");
        //3.取所有值(只有左边开始取)0 -1表示取所有位置,位置是[start,end]
        //redis命令行操作的时候已经演示过
        List<String> list = jedis.lrange("scores", 0, -1);
        for (String value : list) {
            System.out.println(value);
        }
        System.out.println("-----------");
        //4.插队,44插入到100后面,注:没有什么rinsert()方法
    jedis.linsert("scores",BinaryClient.LIST_POSITION    .AFTER, "100", "44");
        List<String> list2 = jedis.lrange("scores", 0, -1);
        for (String value : list2) {
            System.out.println(value);
        }
        List<String> list3 = jedis.lrange("scores", 0, 3);
        for (String value : list3) {
            System.out.println(value);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
输出结果:
左边取为:60
右边取为:10
--------------------
70
80
90
100
50
40
30
20
-----------
70
80
90
100
44
50
40
30
20
---------------
70
80
90
100
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
4、Set类型操作
public class JedisTest {
    Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.25.128",6379);
    }
    @After
    public void after(){
        jedis.close();
    }
    /*
     * 测试添加，取值，移除,判断
     */
    @Test
    public void test1(){
        //1.存储
        jedis.sadd("names", "Tom","Jack","Harry","Lucy","laowang");
        //2.获取set中全部记录,取出来的跟存储的顺序不一样
        Set<String> members = jedis.smembers("names");
        for (String member : members) {
            System.out.println(member);
        }
        //3.移除指定数据
        jedis.srem("names","Tome","Jack");
        //4.判断某值是否为set中成员
        Boolean tom = jedis.sismember("names", "Tome");
        System.out.println("Tom在名单里吗:"+tom);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
输出结果:
Jack
Harry
Lucy
Tom
laowang
Tom在名单里吗:false
1
2
3
4
5
6
7
/*
     * 差集，交集，并集
     */
    @Test
    public void test2(){
        jedis.sadd("set1", "a","b","c","d");
        jedis.sadd("set2", "b","c","d","e");
        //1.差集 set1中有set2中没有的
        Set<String> sdiff = jedis.sdiff("set1","set2");
        for (String d : sdiff) {
            System.out.println(d);
        }
        System.out.println("----------------");
        //2.交集
        Set<String> sinter = jedis.sinter("set1","set2");
        for (String in : sinter) {
            System.out.println(in);
        }
        System.out.println("----------------");
        //3.并集
        Set<String> sunion = jedis.sunion("set1","set2");
        for (String un : sunion) {
            System.out.println(un);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
输出结果:
a
----------------
d
c
b
----------------
d
e
a
c
b
1
2
3
4
5
6
7
8
9
10
11
12
5、Zset（有序Set）类型操作
public class SortedSetTest {
    Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.25.128",6379);
    }
    @After
    public void after(){
        jedis.close();
    }
    @Test
    public void test1(){
        //1.添加
        jedis.zadd("table", 1, "a");
        jedis.zadd("table", 3, "b");
        jedis.zadd("table", 2, "c");
        jedis.zadd("table", 5, "d");
        jedis.zadd("table", 4, "e");
        //2.取值 0 -1表示取所有，可以自己指定开始结束位置，跟list一样
        //默认根据分数由低到高排
        Set<String> table = jedis.zrange("table", 0, -1);
        for (String t : table) {
            System.out.println(t);
        }
        System.out.println("-----------------");
        //3.排序,由高到低排
        Set<String> table2 = jedis.zrevrange("table", 0, -1);
        for (String t : table2) {
            System.out.println(t);
        }
        System.out.println("-----------------");
        //4.修改某个值的分数
        jedis.zincrby("table", 7, "a");
        Set<String> table3 = jedis.zrevrange("table", 0, -1);
        for (String t : table3) {
            System.out.println(t);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
输出结果：
a
c
b
e
d
-----------------
d
e
b
c
a
-----------------
a
d
e
b
c
--------------------- 
作者：成都往右 
来源：CSDN 
原文：https://blog.csdn.net/qq_37334135/article/details/76593479 
版权声明：本文为博主原创文章，转载请附上博文链接！

写代码的东东
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jedis简单使用
nicedaych的博客
05-12 235
jedis简单使用导入相关jar包jedis的简单操作redis中文显示 导入相关jar包 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.2.0</version> </dependency> <dependency> <groupId
java jedis.incr()_Java Jedis.incr方法代碼示例
weixin_29305313的博客
02-25 1964
本文整理匯總了Java中redis.clients.jedis.Jedis.incr方法的典型用法代碼示例。如果您正苦於以下問題：Java Jedis.incr方法的具體用法？Java Jedis.incr怎麽用？Java Jedis.incr使用的例子？那麽恭喜您, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在類redis.clients.jedis.Jedis的用法...
Jedis LRANGE
小海的专栏
12-17 4085
LRANGE key start stop 返回列表 key 中指定区间内的元素，区间以偏移量 start 和 stop 指定。 下标(index)参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
Jedis、RedisTemplate、Redisson 详解和实例
最新发布
深圳市多克创新科技有限公司
03-22 5597
Jedis、RedisTemplate、Redisson 核心功能解析
redis java_Java中使用Jedis操作Redis
weixin_39524842的博客
02-12 160
1 packagecom.test;23 importjava.util.HashMap;4 importjava.util.Iterator;5 importjava.util.List;6 importjava.util.Map;78 importorg.junit.Before;9 importorg.junit.Test;1011 importredis.clients.jedis.Jed...
java redis hget_java中Redis5大基本类型的用法
weixin_31186111的博客
02-24 1243
存储格式基本用法通过Jedis(封装了redis的Java客户端)对redis进行操作。Jedis工具类public class JedisPoolUtil {private static JedisPool pool = null;static {//加载配置文件InputStream in = JedisPoolUtil.class.getClassLoader().getResourceAs...
redis常用方法封装
11-21
redis代码封装，保函jedis 操作list map set等，都带有详细注释
RedisUtil_RedisUtil_redis_jedis常用util_
10-03
redis常用的操作方法，里面有各种redis基本类型的操作方法和说明
redis使用基本方法
10-21
1. redis 1. 概念 2. 下载安装 3. 命令操作 1. 数据结构 4. 持久化操作 5. 使用Java客户端操作redis
java jedis redis 接口工具类
02-01
java框架中使用jedis操控redis 1、单机版 2、集群版 工具类 常用的操作redis的方法提取出一个接口，分别对应单机版和集群版创建两个实现类
redis常用操作
02-24
Jedis常用操作，测试连通性，五大数据类型，事务提交，主从复制，获取Jedis实例需要从JedisPool中获取
Redis学习lrange命令
爱喝水的qdy的博客
12-15 526
目录lrange命令语法返回值例子 lrange命令 Redis lrange，返回列表中指定区间内的元素，区间以偏移量 start 和 stop 指定。（可以使用负索引） 语法 lrange key start stop Redis lrange 返回列表中指定区间内的元素，区间以偏移量 start 和 stop 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。...
Jedis操作Redis的常用命令
L'Étranger的博客
08-27 493
class RedisTests { Jedis jedis = JedisUtils.getJedis(); @Test public void testKey(){ System.out.println("清空数据："+jedis.flushDB()); System.out.println("判断某个键是否存在："+jedis.exists("username")); System.out.println("新增<'username','zzh'>的键值对："+je.
Redis入门笔记（1）（lrange用法）
AAAhxz的博客
10-07 1751
今天参考了网上的Redis操作，心生疑惑，便有所思考 有这样一段代码： 所有元素-stringlists："+shardedJedis.lrange("stringlists", 0, -1) lrange这是啥？ 网上参考教程： Redis Lrange 返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此...
jedis常用操作命令
cjy8866的博客
12-31 1087
1.对value操作的命令      exists(key)：确认一个key是否存在      del(key)：删除一个key      type(key)：返回值的类型      keys(pattern)：返回满足给定patt...
redis的lrange_Redis LRANGE 命令-Redis LRANGE命令详解教程-Redis LRANGE使用案例-嗨客网
weixin_30129025的博客
01-30 5856
Redis LRANGE命令教程下标参数 start 和 stop 都以 0 为底，也就是说，以 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。Redis LRANGE命令详解语法192.168.98.70:6379> LRANGE key start stop参数参数描述K...
【干货】Redis在Java开发中的基本使用和巧妙用法
Dark_orange的博客
02-23 2438
本文介绍了Redis在Java中的巧妙用法，包括基本数据类型和Jedis API的基本用法，以及高级用法如连接池、事务和发布/订阅模式等。同时，还介绍了使用Spring Data Redis的方法，使得在Spring应用程序中使用Redis变得更加容易。这些方法可以帮助Java开发人员更好地使用Redis实现高效、可靠的缓存。参考资料Redis官网：https://redis.io/Jedis GitHub仓库：https://github.com/redis/jedis。
lrange是取出所有值并移除么_Go操作Redis实战
weixin_35385462的博客
02-01 630
目录安装Redis客户端连接redis基本指令Keys():根据正则获取keysType():获取key对应值得类型Del():删除缓存项Exists():检测缓存项是否存在Expire(),ExpireAt():设置有效期TTL(),PTTL():获取有效期DBSize():查看当前数据库key的数量FlushDB():清空当前数据FlushAll():清空所有数据库字符串(string)类型S...
Java的Redis客户端，Jedis和Redisson客户端的使用详细说明；Jedis的基本使用；Redisson作为消息中间件​、​布隆过滤器​、限流器、分布式锁、分布式集合、分布式远程服务；
一个学习Java开发的老头
11-23 2317
jedis 是直连 redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个jedis实例增加物理连接 ； Redisson 实现了分布式 和 可扩展的Java数据结构，和 Jedis 相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。Redisson 的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。
java中redis的常用方法
04-29
Java中常用的Redis方法如下： 1. 连接Redis ``` Jedis jedis = new Jedis("localhost", 6379); ``` 2. 存储数据 ``` jedis.set("key", "value"); ``` 3. 获取数据 ``` String value = jedis.get("key"); ``` 4. 删除数据 ``` jedis.del("key"); ``` 5. 判断key是否存在 ``` jedis.exists("key"); ``` 6. 设置key的过期时间 ``` jedis.expire("key", 60); //60秒后过期 ``` 7. 获取key的剩余过期时间 ``` jedis.ttl("key"); ``` 8. 自增操作 ``` jedis.incr("key"); //自增1 jedis.incrBy("key", 10); //自增10 ``` 9. 自减操作 ``` jedis.decr("key"); //自减1 jedis.decrBy("key", 10); //自减10 ``` 10. 列表操作 ``` jedis.lpush("listKey", "value1", "value2"); //从左边插入两个元素 jedis.rpush("listKey", "value3"); //从右边插入一个元素 List<String> list = jedis.lrange("listKey", 0, -1); //获取整个列表 ``` 11. 集合操作 ``` jedis.sadd("setKey", "value1", "value2"); //添加两个元素 jedis.sadd("setKey", "value3"); jedis.srem("setKey", "value3"); //删除一个元素 Set<String> set = jedis.smembers("setKey"); //获取整个集合 ``` 12. 哈希表操作 ``` jedis.hset("hashKey", "field1", "value1"); //添加一个键值对 jedis.hset("hashKey", "field2", "value2"); jedis.hdel("hashKey", "field2"); //删除一个键值对 Map<String, String> map = jedis.hgetAll("hashKey"); //获取整个哈希表 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值