Jedis

本文涉及的产品
云数据库 Tair(兼容Redis),内存型 2GB
Redis 开源版,标准版 2GB
推荐场景:
搭建游戏排行榜
简介: Jedis


依赖下载

       前往maven仓库搜索jedis:

选择4版本:

然后引入或者下载依赖即可。

这里直接提供了maven的一个jedis地址:

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.4.3</version>
</dependency>

在pom.xml中引入依赖:

配置SSH转发

       以xshell为例子:

       右键你所选择的会话。选择属性:

       然后添加:

然后点击连接。

       查看是否生效:

       使用netstat命令来访问 8888端口:

  • win + r 输入cmd打开命令行。
  • 输入: netstat -ano |findstr 8888

        说明转发成功。

       如果什么都不显示,则表示配置失败。

       此时此刻,在后续的本地windows编程中,咱们的java代码就可以通过127.0.0.1:8888来访问我们的redis服务器了。同时外面的客户端是无法直接访问redis的6379端口了。

       接下来可以正式编辑代码了。

连接到redis服务器

       在java目录中创建一个案例,如下:

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
 
public class RedisDemo {
    public static void main(String[] args) {
        // 连接到redis 服务器.
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
 
        // 从redis池中取出一个连接来
        try (Jedis  jedis = jedisPool.getResource()) {
            // Redis各种命令就对应到Jedis对象的各种方法,调用方法,就相当于执行命令.
            String pong = jedis.ping();
            System.out.println(pong);
        }
    }
}
  • 首先需要创建一个jedis池,也就是JedisPool类,然后在这个pool中取出连接,来进行执行命令。
  • 使用jedisPool中的getResource方法来获取一个jedis连接,返回值为Jedis类型数据,这个Jedis类型的数据就是建立好的一个链接
  • 通过这个Jedis连接来进行编写代码,最简单的一个代码用来验证是否连接上了,如上:jedis.ping(),如果返回值为pong,那么说明连接成功,如代码:
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
PONG
 
Process finished with exit code 0

        最开始安装Redis的时候,要配置绑定的ip,以及关闭保护模式。下面来看看如何操作:

  • 找到Redis的配置文件:redis.conf,然后打开
  • 找到bind选项:

    这里默认绑定的是127.0.0.1,此时只能本机和本机访问,不能跨主机访问。应该将其改为图所示的0.0.0.0
  • 关闭保护模式,首先找到redis.conf配置文件中的protected-mode

    这里默认是yes,如果是yes的话就是开启保护模式,跨主机也是不能访问的。将其设置为no。

警告:当前的使用java代码和ssh转发进行的redis服务器访问操作仅限于开发阶段,实际情况就需要根据实际情况来修改ip。


客户端的使用

        下面就将介绍jedis中的通用命令:

  • get/set
  • exists
  • del
  • keys
  • expire /ttl
  • type
  • ......

       接下来的介绍不会覆盖到所有的命令,这里只是介绍到比较重要的、具有代表性的命令进行演示。

get / set

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
 
import javax.swing.*;
 
public class RedisDemo {
    public static void test1(Jedis jedis) {
        System.out.println("jedis的get和set的使用");
        // 先清空数据库(避免上一组数据对本次测试的影响)
        jedis.flushAll(); // 此命令就相当于Redis中的flushall
 
        // 使用set
        jedis.set("key","111");
        jedis.set("key2","222");
 
        // 进行get
        System.out.println("key: " + jedis.get("key"));
        System.out.println("key2: "+jedis.get("key2"));
 
 
    }
    public static void main(String[] args) {
        // 连接到redis 服务器.
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
 
        // 从redis池中取出一个连接来
        try (Jedis  jedis = jedisPool.getResource()) {
            // Redis各种命令就对应到Jedis对象的各种方法,调用方法,就相当于执行命令.
            test1(jedis);
        }
    }
}

        注意看,在编写set的时候,你会发现,这里的set有很多重载的方法,例如:

       除了指定keyvalue 的方法,还可以设置一个参数,这个参数的类型是SetParams。

       首先我们先new一个SetParams,并创建其对象。

       可以看见里面提供了很多方法:

  • 其中有一个ex的方法可以用于设置超时时间,单位是秒,这里不做过多讲解。
  • nx():用于对不存在的数据进行操作,只会添加数据,不会更新数据
  • xx():用于已经存在的数据,才能够进行修改。
    public static void test2(Jedis jedis) {
        System.out.println("exists 和 del的使用");
        jedis.flushAll(); // 此命令就相当于Redis中的flushall
 
        // 首先set两个key
        jedis.set("key1","111");
        jedis.set("key2","222");
 
        System.out.println(jedis.exists("key1")); // 已经设置,打印true
        System.out.println(jedis.exists("key2")); // 已经设置,打印true
        System.out.println(jedis.exists("key3")); // 没有设置,打印false
 
        long ret = jedis.del("key1"); // 成功删除key1这一个健,返回1
        // del 返回long类型表示成功返回多少个元素.
        System.out.println(ret);
 
        // 判定这个被删除的key1是否存在
        boolean retEx = jedis.exists("key1"); // 已经被删除,返回false.
        System.out.println(retEx);
 
        // 如果要删除多个key: jedis.del("key1","key2","key3", ... )
    }

       执行test1方法,就会出现:

       因为设置了xx参数,代表只会对已经存在的数据进行修改,但是此时的set操作当前的key是不存在的,所以get返回一个空。

exists / del

       实例:

    public static void test3(Jedis jedis) {
        System.out.println("keys* 的使用");
        jedis.flushAll(); // 此命令就相当于Redis中的flushall
 
        // 设置四个key
        jedis.set("key1","1");
        jedis.set("key2","2");
        jedis.set("key3","3");
        jedis.set("key4","4");
 
        // 使用keysm,参数为pattern,通过特定格式的字符串来匹配符合要求的key,其中最简单的就是*,表示匹配任意结果
        Set<String> set = jedis.keys("*");
 
        // 这里使用set表示,是因为set里面的key是不能重复的
        System.out.println(set);
    }

        Jedis的方法exists,如果key已经存在,那么返回值为boolean类型的true,如果不存在则返回false。del则是删除已经存在的key,返回值为long类型,表示删除key的个数。

       当然del还支持多个key同时删除:

jedis.del("key1","key2","key3", ... )

keys

    public static void test4(Jedis jedis) {
        System.out.println("expire / ttl* 的使用");
        jedis.flushAll(); // 此命令就相当于Redis中的flushall
 
        jedis.set("key","111");
        jedis.expire("key",10);  // expire的第一个参数是key,第二个参数是long类型.表示秒
 
        // ttl 判断一个key还有多少过期时间,返回类型为long
        long time = jedis.ttl("key");
        System.out.println(time);
 
        // 休眠三秒
        try {
            Thread.sleep(Long.parseLong("3000"));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
 
        // 再次ttl查看多少秒
        System.out.println(jedis.ttl("key"));
    }

        调用test3(),输出:

expire /ttl

    public static void test4(Jedis jedis) {
        System.out.println("expire / ttl* 的使用");
        jedis.flushAll(); // 此命令就相当于Redis中的flushall
 
        jedis.set("key","111");
        jedis.expire("key",10);  // expire的第一个参数是key,第二个参数是long类型.表示秒
 
        // ttl 判断一个key还有多少过期时间,返回类型为long
        long time = jedis.ttl("key");
        System.out.println(time);
 
        // 休眠三秒
        try {
            Thread.sleep(Long.parseLong("3000"));
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
 
        // 再次ttl查看多少秒
        System.out.println(jedis.ttl("key"));
    }

输出:

       这里有延迟,说明服务器有延迟。

  • expire:给存活的key设置一个过期时间,有两个参数,第一个参数是key对象,第二个 参数是long类型的数字,表示存活多少秒
  • ttl:查看一个key的存活时间,返回类型为long类型,表示还剩多少秒。

type

    public static void test5(Jedis jedis) {
        System.out.println("type 的使用");
        jedis.flushAll(); // 此命令就相当于Redis中的flushall
 
        // type: 查看一个key的value是什么类型
        jedis.set("key","111");
        String type = jedis.type("key");
        System.out.println(type);
 
        jedis.lpush("list","111","222","333");
        System.out.println(jedis.type("list"));
    }

字符串命令

  • get/set
  • mget /mset
  • getrange和setrange
  • append
  • incr 、decr

mget / mset

    public static void test1(Jedis jedis) {
        System.out.println("mget,mset");
        jedis.flushAll();
 
        jedis.mset("key1","111","key2","222","key3","333");
 
        // 返回值为 List<String>
        List<String> list = jedis.mget("key1","key2","key3","key100");
        System.out.println("values:" + list);
    }

输出:

       如果没有找到,那么使用null来表示。

getrange /setrange

    public static void test2(Jedis jedis) {
        System.out.println("mget,mset");
        jedis.flushAll();
 
        jedis.set("key","0123456789");
        // 有三个参数,第一个参数用来指定key,第二个和第三个参数用来指定范围,类型都是long,这里的下标可以理解为字符串的charAt()
        System.out.println(jedis.getrange("key", 0, 4));
        System.out.println(jedis.getrange("key",1,8));
 
        jedis.setrange("key",9,"xxx");
        System.out.println(jedis.get("key"));
    }

append

    public static void test3(Jedis jedis) {
        System.out.println("append");
        jedis.flushAll();
 
        jedis.set("key","abcdef");
        jedis.append("key","ghijk");
 
        String val = jedis.get("key");
        System.out.println(val);
    }

输出:

incr / decr

    public static void test4(Jedis jedis) {
        System.out.println("incr / decr");
        jedis.flushAll();
 
        jedis.set("key","100");
        long ret = jedis.incr("key");
        System.out.println(ret);
 
        ret = jedis.decr("key");
        System.out.println(ret);
    }

输出:

  • 他们两个的返回值都是执行命令之后的结果。
  • 除了incr和decr之外,还有很多,例如:

    这些就不做过多的讲解,可以自己参考上面的例子进行演示。

列表list

  • lpush / lpop / lrange
  • rpush / rpop
  • blpop / brpop
  • llen

push / pop / lrange

    public static void test1(Jedis jedis) {
        System.out.println("lpush 和 lrange");
        jedis.flushAll();
 
        // 头插
        jedis.lpush("key","111","222","333","444");
 
        // 尾插
        jedis.rpush("key","000");
        List<String> list = jedis.lrange("key",0,-1);
        System.out.println(list);
 
        // 弹出444和000
        jedis.lpop("key");
        jedis.rpop("key");
 
        list  = jedis.lrange("key",0,-1);
        System.out.println(list);
    }

输出:

blpop/brpop

       首先创建一个延迟100秒的brpop并执行:

    public static void test2(Jedis jedis) {
        System.out.println("brpop");
        jedis.flushAll();
 
        // 返回结果是一个二元组,一个是从哪个key对应的list中删除,另外一个是删除的是什么
        List<String> list = jedis.brpop(100,"key");
        System.out.println(list);
    }

       首先输出:

       然后在设置的100s内,打开redis客户端,set一个key:

       此时idea控制台输出:

["key","111"]

       blpop同理。

llen

       求列表的长度:

    public static void test3(Jedis jedis) {
        System.out.println("llen");
        jedis.flushAll();
 
        jedis.lpush("key","111","222","333");
        long len = jedis.llen("key");
        System.out.println(len);
    }

输出:

  • llen返回值为long类型。
  • 返回值表示列表中元素的个数。

集合set

  • sadd, smembers
  • sismember
  • scard
  • spop
  • sinter, sinterstore

sadd

public class JedisSet {
    public static void test1(Jedis jedis) {
        System.out.println("sadd");
        jedis.flushAll();
 
        jedis.sadd("key","1","2","3","4");
        Set<String> set  = jedis.smembers("key");
        System.out.println(set);
    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try(Jedis jedis = jedisPool.getResource()) {
            test1(jedis);
        }
    }
}

输出:

sismember

    public static void test2(Jedis jedis) {
        System.out.println("sadd");
        jedis.flushAll();
        long ret = jedis.sadd("key","1","2","3","4");
 
        System.out.println(jedis.sismember("key", "1"));
        System.out.println(jedis.sismember("key", "10"));
    }

scard

    public static void test3(Jedis jedis ){
        System.out.println("scard");
        jedis.flushAll();
 
        long ret = jedis.sadd("key","1","2","3","4");
        long nums = jedis.scard("key");
        System.out.println(nums);
    }

spop

    public static void test4(Jedis jedis) {
        System.out.println("spop");
        jedis.flushAll();
 
        long ret = jedis.sadd("key","1","2","3","4");
        String res = jedis.spop("key");
        System.out.println(res);
 
    }

输出:

sinter

    public static void test5(Jedis jedis) {
        System.out.println("sinter");
        jedis.flushAll();
 
        jedis.sadd("key1","1","2","3");
        jedis.sadd("key2","2","3","4");
 
        Set<String> set = jedis.sinter("key1","key2");
 
        System.out.println(set);
    }

sinterstore

    public static void test6(Jedis jedis) {
        System.out.println("sinterstore");
        jedis.flushAll();
        jedis.sadd("key1","1","2","3");
        jedis.sadd("key2","2","3","4");
 
        long nums = jedis.sinterstore("key3","key1","key2");
        System.out.println(nums);
        System.out.println(jedis.smembers("key3"));
 
    }

hash

  • hset / hget
  • hexists
  • hdel
  • hkeys
  • hvals
  • hmget / hmset

hset / hget

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
 
import java.util.HashMap;
import java.util.Map;
 
public class JedisHash {
    public static void testHgetAndHset(Jedis jedis) {
        System.out.println("hset和hget");
        jedis.flushAll();
 
        // 每次都只设置一次 key的filed和value
        jedis.hset("key","f1","v1");
        jedis.hset("key","f2","v2");
        jedis.hset("key","f3","v3");
        jedis.hset("key","f4","v4");
 
        // 一次性设置多个key的field
        Map<String, String> map = new HashMap<>();
        map.put("f5","v5");
        map.put("f6","v6");
        jedis.hset("key",map);
 
        // 获取
        String res = jedis.hget("key","f1");
        System.out.println(res);
 
        // 尝试获取不存在的
        res = jedis.hget("key","f100");
        System.out.println(res);
    }
    public static void main(String[] args) {
        JedisPool jedisPool = new JedisPool("tcp://127.0.0.1:8888");
        try(Jedis jedis = jedisPool.getResource()) {
            testHgetAndHset(jedis);
        }
 
    }
}

输出:

hexists

    public static void testHexists(Jedis jedis) {
        System.out.println("hexists");
        jedis.flushAll();
 
        jedis.hset("key","f1","v1");
        jedis.hset("key","f2","v2");
        jedis.hset("key","f3","v3");
 
        System.out.println(jedis.hexists("key","f1"));
        System.out.println(jedis.hexists("key","f2"));
        System.out.println(jedis.hexists("key","f100"));
    }

hdel

 public static void testHdel(Jedis jedis) {
        System.out.println("hdel");
        jedis.flushAll();
        jedis.hset("key","f1","v1");
        jedis.hset("key","f2","v2");
        jedis.hset("key","f3","v3");
 
        // 删除key中的f3
        jedis.hdel("key","f3");
        // 使用hexists查看是否存在
        System.out.println(jedis.hexists("key", "f3"));
 
        // 同时hdel可以同时删除多个
        long ret = jedis.hdel("key","f1","f2");
 
        System.out.println(jedis.hexists("key", "f1"));
        System.out.println(jedis.hexists("key", "f2"));
        System.out.println("一共被删除" + ret + "个field");
    }

hkeys / hvals

    public static void testHkeysAndHvals(Jedis jedis) {
        System.out.println("hkeys and hvals");
        jedis.flushAll();
 
        jedis.hset("key","f1","v1");
        jedis.hset("key","f2","v2");
        jedis.hset("key","f3","v3");
 
        // 使用hkeys获取所有的key
        System.out.println("获取所有的key");
        Set<String> set = jedis.hkeys("key");
        System.out.println(set);
 
        // 使用hvals获取所有的val
        System.out.println("获取所有的val");
        List<String> list = jedis.hvals("key");
        System.out.println(list);
    }

有序集合zset

  • zadd
  • zrange
  • zcard
  • zrem
  • zscore
  • zrank

zadd

    public static void testZaddAndZrange(Jedis jedis) {
        System.out.println("zadd / zrange");
        jedis.flushAll();
 
        // 一次性添加一个元素
        jedis.zadd("key", 10.0,"zhangsan");
 
        // 一次性添加多个元素
        Map<String,Double> map = new HashMap<>();
        map.put("lisi",11.3);
        map.put("wangwu",13.5);
        jedis.zadd("key",map);
 
        // 使用zrange查看
        List<String> list = jedis.zrange("key",0, -1);
        System.out.println(list);
 
        // 携带分数score:zrangeWithScores
        List<Tuple> listWithScores = jedis.zrangeWithScores("key", 0, -1);
        System.out.println(listWithScores);
 
        // 获取listWithScores中的元素
        String member = listWithScores.get(0).getElement();
        double score = listWithScores.get(0).getScore();
        System.out.println("member:" + member + ",score:" + score);
    }

  • Tuple是Jedis或者说是Redis依赖中所携带的类,不是java本身自带的库.

       Jedis中的Tuple类是一个用于存储键值对的简单数据结构。它包含两个泛型字段:key和value。key字段用于存储键,而value字段用于存储与键关联的值。Tuple类主要用于在Redis中存储和操作键值对数据。

以下是一个简单的示例:

import redis.clients.jedis.Tuple;
 
public class JedisTupleExample {
    public static void main(String[] args) {
        // 创建一个Tuple对象
        Tuple<String, String> tuple = new Tuple<>("name", "张三");
 
        // 获取键和值
        String key = tuple.getKey();
        String value = tuple.getValue();
 
        System.out.println("Key: " + key);
        System.out.println("Value: " + value);
    }
}

       在这个示例中,我们创建了一个包含键"name"和值"张三"的Tuple对象。然后,我们使用getKey()和getValue()方法分别获取键和值,并将它们打印到控制台。

       下面是Tuple的原码:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
 
package redis.clients.jedis.resps;
 
import java.util.Arrays;
import java.util.Objects;
import redis.clients.jedis.util.ByteArrayComparator;
import redis.clients.jedis.util.SafeEncoder;
 
public class Tuple implements Comparable<Tuple> {
    private byte[] element;
    private Double score;
 
    public Tuple(String element, Double score) {
        this(SafeEncoder.encode(element), score);
    }
 
    public Tuple(byte[] element, Double score) {
        this.element = element;
        this.score = score;
    }
 
    public int hashCode() {
        int prime = true;
        int result = 1;
        result = 31 * result;
        if (null != this.element) {
            byte[] var3 = this.element;
            int var4 = var3.length;
 
            for(int var5 = 0; var5 < var4; ++var5) {
                byte b = var3[var5];
                result = 31 * result + b;
            }
        }
 
        long temp = Double.doubleToLongBits(this.score);
        result = 31 * result + (int)(temp ^ temp >>> 32);
        return result;
    }
 
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        } else if (obj == this) {
            return true;
        } else if (!(obj instanceof Tuple)) {
            return false;
        } else {
            Tuple other = (Tuple)obj;
            return !Arrays.equals(this.element, other.element) ? false : Objects.equals(this.score, other.score);
        }
    }
 
    public int compareTo(Tuple other) {
        return compare(this, other);
    }
 
    public static int compare(Tuple t1, Tuple t2) {
        int compScore = Double.compare(t1.score, t2.score);
        return compScore != 0 ? compScore : ByteArrayComparator.compare(t1.element, t2.element);
    }
 
    public String getElement() {
        return null != this.element ? SafeEncoder.encode(this.element) : null;
    }
 
    public byte[] getBinaryElement() {
        return this.element;
    }
 
    public double getScore() {
        return this.score;
    }
 
    public String toString() {
        return '[' + SafeEncoder.encode(this.element) + ',' + this.score + ']';
    }
}

       里面提供了两个比较关键的数据一个是element,也就是member,另外一个就是score,也就是分数.

zcard

    public static void testZcard(Jedis jedis) {
        System.out.println("zcard");
        jedis.flushAll();
 
        Map<String,Double> map = new HashMap<>();
        map.put("lisi",11.3);
        map.put("wangwu",13.5);
        map.put("zhangsan", 10.5);
        jedis.zadd("key",map);
        long ret = jedis.zcard("key");
        System.out.println(ret);
    }

zrem

    public static void testZrem(Jedis jedis) {
        System.out.println("zrem");
        jedis.flushAll();
 
        Map<String,Double> map = new HashMap<>();
        map.put("lisi",11.3);
        map.put("wangwu",13.5);
        map.put("zhangsan", 10.5);
        jedis.zadd("key",map);
 
        long  n = jedis.zrem("key","zhangsan");
        System.out.println("删除的个数:" + n);
 
        System.out.println(jedis.zrangeWithScores("key", 0, -1));
    }

zscore

    public static void testZscore(Jedis jedis) {
        System.out.println("zscore");
        jedis.flushAll();
 
        Map<String,Double> map = new HashMap<>();
        map.put("lisi",11.3);
        map.put("wangwu",13.5);
        map.put("zhangsan", 10.5);
        jedis.zadd("key",map);
 
        double ret = jedis.zscore("key","lisi");
        System.out.println(ret);
         ret = jedis.zscore("key","wangwu");
        System.out.println(ret);
         ret = jedis.zscore("key","zhangsan");
        System.out.println(ret);
    }

zrank

   public static void testZrank(Jedis jedis) {
        System.out.println("zrank");
        jedis.flushAll();
 
        Map<String,Double> map = new HashMap<>();
        map.put("lisi",11.3);
        map.put("wangwu",13.5);
        map.put("zhangsan", 10.5);
        jedis.zadd("key",map);
 
        long rankLisi = jedis.zrank("key","lisi");
        
        long rankwangwu = jedis.zrank("key","wangwu");
        long rankzhangsan = jedis.zrank("key","zhangsan");
        System.out.println("lisi分数:" + jedis.zscore("key","lisi") + ", 排名:" +rankLisi);
        System.out.println("wangwu分数:" + jedis.zscore("key","wangwu") + ", 排名:" +rankwangwu);
        System.out.println("zhangsan分数:" + jedis.zscore("key","zhangsan") + ", 排名:" +rankzhangsan);
    }

如果指定一个不存在的member,会出现异常:

Exception in thread "main" java.lang.NullPointerException
  at JedisZset.testZrank(JedisZset.java:96)
  at JedisZset.main(JedisZset.java:110)


相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务,基于高可靠双机热备架构及可无缝扩展的集群架构,满足高读写性能场景及容量需弹性变配的业务需求。 产品详情:https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
目录
相关文章
|
7月前
|
缓存 负载均衡 监控
请列出与jedis相关的10种技术
列出与jedis相关的10种技术
177 0
|
2月前
|
存储 NoSQL Java
Jedis客户端介绍
【10月更文挑战第12天】
|
5月前
|
NoSQL Java Redis
|
缓存 Dart NoSQL
Jedis和RedisTemplate 1
Jedis和RedisTemplate
123 0
|
7月前
|
NoSQL Java Redis
|
NoSQL Java Redis
jedis分布式锁实现
jedis分布式锁实现
149 0
|
缓存 Dart Java
Jedis和RedisTemplate 2
Jedis和RedisTemplate
63 0
|
NoSQL Java Redis
|
NoSQL Java Redis
分享一个基于 Jedis 的 Redis 工具类
分享一个基于 Jedis 的 Redis 工具类
106 0
|
NoSQL Java 中间件
Jedis基础详解
Jedis基础详解
113 0