创建连接

public static Jedis jedis = null;

static {
    // 地址 和 端口
    jedis = new Jedis("127.0.0.1", 6379);
    // jedis.auth("helloworld"); // 若你的redis设置了密码，则可以执行该方法，开启密码验证
}

操作key

/**
 * 操作key
 */
@Test
void keyTest() {

    System.out.println(jedis.flushDB());// 清空数据
    System.out.println(jedis.echo("hello"));

    // 判断key否存在
    System.out.println(jedis.exists("foo"));

    jedis.set("key", "values");
    jedis.set("key2", "values");
    System.out.println(jedis.exists("key"));// 判断是否存在

    // 如果数据库没有任何key，返回nil，否则返回数据库中一个随机的key。
    String randomKey = jedis.randomKey();
    System.out.println("randomKey: " + randomKey);

    // 设置60秒后该key过期
    jedis.expire("key", 60);

    // key有效毫秒数
    System.out.println(jedis.pttl("key"));

    // 移除key的过期时间
    jedis.persist("key");

    // 获取key的类型, "string", "list", "set". "none" none表示key不存在
    System.out.println("type: " + jedis.type("key"));

    // 导出key的值
    byte[] bytes = jedis.dump("key");
    System.out.println(new String(bytes));

    // 将key重命名
    jedis.renamenx("key", "keytest");
    System.out.println("key是否存在: " + jedis.exists("key"));// 判断是否存在
    System.out.println("keytest是否存在: " + jedis.exists("keytest"));// 判断是否存在

    // 查询匹配的key
    // KEYS       * 匹配数据库中所有 key 。
    // KEYS       h?llo 匹配 hello ， hallo 和 hxllo 等。
    // KEYS       h*llo 匹配 hllo 和 heeeeello 等。
    // KEYS       h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
    // 特殊符号用 \ 隔开。
    Set<String> set = jedis.keys("k*");
    System.out.println(set);

    // 删除key
    jedis.del("key");
    System.out.println(jedis.exists("key"));
}

输出结果：

操作string

/**
 * 操作String字符串
 */
@Test
void stringTest() {
    // 清空库
    jedis.flushDB();

    // 设置 字符串
    jedis.set("hello", "hello");
    System.out.println(jedis.get("hello"));

    // 为某个value拼接字符串
    jedis.append("hello", " world");

    // 新增覆盖旧值
    jedis.set("hello","redis, hello world!");
    System.out.println(jedis.get("hello"));

    // 设置过期时间 | expire:失效
    // arg1：key  arg2：过期时间  arg3：对应value值
    jedis.setex("expireKey", 10, "一会儿就失效了");

    // multiple： 多次的
    // 多次设置
    jedis.mset("mkey1","hhh", "mkey2","hahaha");
    System.out.println(jedis.get("mkey1") + " " + jedis.get("mkey2"));
    // 多次获取
    List<String> mget = jedis.mget("mkey1", "mkey2");
    System.out.println(mget);

    // 批量删除
    jedis.del("mkey1", "mkey2");
    System.out.println(jedis.exists("mkey1"));
    System.out.println(jedis.exists("mkey2"));
}

输出结果：

操作list

/**
 * 对列表类型List的操作
 */
@Test
void listTest() {
    // 清空库
    jedis.flushDB();

    // 设置链表list
    String key = "myList";
    // rpush: 从添加元素到列表 右侧  (r 表示 right)
    jedis.rpush(key, "1");
    jedis.rpush(key, "2");
    // lpush: 从添加元素到列表 左侧  (l 表示 left)
    jedis.lpush(key, "0");
    jedis.lpush(key, "-8");
    // 同时 rpush 和 lpush 都可以插入多个元素
    jedis.rpush(key, "3","4","5");
    jedis.lpush(key,"a","b","c");
    
    // 获取链表的长度
    Long length = jedis.llen(key);
    System.out.println("列表的长度为："+length);
    
    // 打印队列，从索引0开始，到倒数第1个（全部元素）
    List<String> list = jedis.lrange(key, 0, -1);
    System.out.println(list);
    
    // 获取索引为index的元素
    String index_1_value = jedis.lindex(key, 1);
    System.out.println(index_1_value);
    // 设置索引index位置的元素, 新值覆盖旧值
    jedis.lset(key, 1, "999");
    System.out.println(jedis.lrange(key, 0, -1));

    // 从左边弹出一个元素
    String lpop = jedis.lpop(key);
    System.out.println(lpop);
    System.out.println(jedis.lrange(key, 0, -1));
    // 从右边弹出一个元素
    String rpop = jedis.rpop(key);
    System.out.println(rpop);
    System.out.println(jedis.lrange(key, 0, -1));
    
    // 删除值为xxx的元素
    // count > 0: 从头往尾移除值为 value 的元素，count为移除的个数。
    // count < 0: 从尾往头移除值为 value 的元素，count为移除的个数。
    // count = 0: 移除所有值为 value 的元素。
    jedis.lrem(key, 1, "a");

    // 即最右边的那个元素也会被包含在内。 如果start比list的尾部下标大的时候，会返回一个空列表。
    // 如果stop比list的实际尾部大的时候，Redis会当它是最后一个元素的下标。
    System.out.println(jedis.lrange(key, 0, 2));
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    // 删除区间以外的元素
    System.out.println(jedis.ltrim(key, 0, 2));
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));
}

输出结果：

操作set

@Test
void setTest() {
    // 清空库
    jedis.flushDB();
    String key1 = "set1";
    String key2 = "set2";

    // 集合添加元素
    jedis.sadd(key1, "aaa", "bbb", "ccc");
    jedis.sadd(key2, "bbb", "ccc", "ddd");

    // smembers方法: 返回set集合的成员属性，返回类型为 Set<String>。   s表示set，members 表示成员复数
    Set<String> smembers1 = jedis.smembers(key1);
    Set<String> smembers2 = jedis.smembers(key2);
    System.out.println(smembers1);
    System.out.println(smembers2);

    // 获取set集合的元素个数
    Long scard = jedis.scard(key1);
    System.out.println("key1集合的元素个数为："+scard);

    // 获得两个集合的交集，并存储在一个关键的结果集
    jedis.sinterstore("destination", key1, key2);
    System.out.println(jedis.smembers("destination"));

    // 获得两个集合的并集，并存储在一个关键的结果集
    jedis.sunionstore("destination", key1, key2);
    System.out.println(jedis.smembers("destination"));

    // 在key1集合中，key2集合没有的元素，并存储在一个关键的结果集
    jedis.sdiffstore("destination", key1, key2);
    System.out.println(jedis.smembers("destination"));

    // 判断某个元素是否是一个集合的成员
    System.out.println(jedis.sismember(key1, "aaa"));

    // 删除并获取一个集合里面的元素
    System.out.println(jedis.spop(key1));

    // 从集合里删除一个或多个元素
    jedis.srem(key2, "ccc", "ddd");
    System.out.println(jedis.smembers(key2));
}

输出结果：

操作zset

/**
 * 对sorted set的操作（有序的集合）
 */
@Test
void zsetTest() {
    // 清空库
    jedis.flushDB();
    String key = "sortedSet";

    // 添加元素，方式1：
    // arg1：key    arg2：分数（越小越靠前）    arg3：value
    jedis.zadd(key,6.0, "aaaa");

    // 添加元素，方式2：添加一个map集合
    // 2.1 首先创建一个map集合， key为zset中的值， value为对应的分数
    HashMap<String, Double> zsetMap = new HashMap<>();
    zsetMap.put("bbbb", 8.0);
    zsetMap.put("cccc", -1.0);
    zsetMap.put("dddd", 1.0);
    jedis.zadd(key, zsetMap);

    // 获取一个排序的集合中的成员数量
    System.out.println(jedis.zcard(key));

    // 返回的成员在指定范围内的有序集合，以0表示有序集第一个成员，以1表示有序集第二个成员，以此类推。
    // 负数下标，以-1表示最后一个成员，-2表示倒数第二个成员
    Set<String> zset = jedis.zrange(key, 0, -1);
    System.out.println(zset);

    // 返回的成员在指定范围内的逆序集合
    zset = jedis.zrevrange(key, 0, -1);
    System.out.println(zset);

    // 返回zset集合的Tuple元素， 该对象包含 分数和对应的值
    Set<Tuple> tuples = jedis.zrangeWithScores(key, 0, -1);
    for (Tuple item: tuples) {
        System.out.println(item.getScore()+" : "+ item.getElement());
    }

    // 获取某个元素的分数
    Double aaaaScore = jedis.zscore(key, "aaaa");
    System.out.println(aaaaScore);

    // 给定分数值范围内的成员数
    System.out.println(jedis.zcount(key, 0, 7));

}

输出结果：

操作hash

/**
 * 对hash的操作
 */
@Test
void hashTest() {
    // 清空库
    jedis.flushDB();

    String key = "myhash";

    // 添加元素，方式1：
    jedis.hset(key, "aa", "11");
    // 添加元素，方式2：添加一个map集合
    HashMap<String, String> hashMap = new HashMap<>();
    hashMap.put("bbb","22");
    hashMap.put("cc","33");
    jedis.hmset(key, hashMap);

    // 获取hash的所有元素(key值)
    System.out.println(jedis.hkeys(key));

    // 获取hash中所有的key对应的value值
    System.out.println(jedis.hvals(key));

    // 获取hash里所有元素的数量
    System.out.println(jedis.hlen(key));

    // 获取hash中全部的域和值,以Map<String, String> 的形式返回
    Map<String, String> map = jedis.hgetAll(key);
    System.out.println(map);

    // 判断给定key值是否存在于哈希集中
    System.out.println(jedis.hexists(key, "bbb"));

    // 获取指定的值
    System.out.println(jedis.hget(key, "aaa"));

    // 删除指定的值
    System.out.println(jedis.hdel(key, "aaa"));

    // 为key中的域 field 的值加上增量 increment
    System.out.println(jedis.hincrBy(key, "bbb", 100));
    System.out.println(jedis.hgetAll(key));
}

输出结果：

Jedis连接池工具类

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * todo jedis-pool 连接池
 *
 * @author coderzpw.zhang
 * @version 1.0
 * @date 2022/7/16 18:19
 */
public class JedisPoolUtils {

    public static final JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 资源池中的最大连接数
        jedisPoolConfig.setMaxTotal(8);
        // 资源池允许的最大空闲连接数
        jedisPoolConfig.setMaxIdle(8);
        // 资源池确保的最少空闲连接数
        jedisPoolConfig.setMinIdle(0);
        jedisPoolConfig.setMaxWaitMillis(1000); // 最多等待1000ms
        // 创建连接池对象
        jedisPool = new JedisPool(jedisPoolConfig, "127.0.0.1", 6379);
    }

    /**
     * 获取一个redis连接对象
     * @return
     */
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }

}