7.Jedis

1、什么是Jedis ？

​ 它是 Redis 官方推荐的 java连接开发工具， 使用Java 操作Redis 中间件。如果你要使用Java操作Redis，那么一定要对Jedis 十分的熟悉。

2、使用Jedis

2.1 、Maven导入对应的依赖

<dependencies>
  	<!-- 导入jedis的包 -->
    <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.3.0</version>
    </dependency>
		
    
    <!-- json选择1：导入fastjson的包 -->
    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>

    
  	<!-- json选择2：导入jackson的包 -->
    <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.11.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.11.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.11.0</version>
    </dependency>
    
    <!-- json选择3：导入gson包 -->
    <!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>2.8.5</version>
    </dependency>
</dependencies>

2.2 、编码测试

连接数据库

操作命令

断开连接

import redis.clients.jedis.Jedis;

public class testPing {
  	//开启本地redis服务器，测试是否ping通
    public static void main(String[] args) {
        // 1、new Jedis 对象
        Jedis jedis = new Jedis("127.0.0.1", 6379);
      	// 2、测试ping方法，若输出pong，代表成功
        System.out.println(jedis.ping());  
    }
}

/*
 *	此处若不是连接本地redis，而是连接服务器则可直接输入服务器IP(公有)地址。 
 *  Jedis jedis = new Jedis("服务器IP(公有)", 6379);
 *  
 *  若阿里云连接不上，则需要：
 *  第一步：先去阿里云服务器添加安全组规则放行Jedis对应的端口
    firewall-cmd --permanent --zone=public --add-port=6379/tcp
    firewall-cmd --reload
	firewall-cmd --zone=public --query-port=6379/tcp

 *  第二步：通过vim redis.conf命令进入，将# bind 127.0.0.1注释掉，protected-mode no关闭保护模式
 *  第三步：redis重启
 */

2.3、常用的API

import redis.clients.jedis.Jedis;

import java.util.Set;

public class TestKey {

    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);

        System.out.println("清空数据："+jedis.flushDB());
        System.out.println("判断某个键是否存在："+jedis.exists("username"));

        System.out.println("新增键值对："+jedis.set("username", "zhangsan"));
        System.out.println("新增键值对："+jedis.set("password", "123"));

        System.out.println("系统中所有键如下：");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);

        System.out.println("删除键password:"+jedis.del("password"));
        System.out.println("判断password键是否存在："+jedis.exists("password"));
        System.out.println("查看键username所存储的值的类型："+jedis.type("username"));

        System.out.println("随机返回键空间的一个："+jedis.randomKey());
        System.out.println("重命名key："+jedis.rename("username", "name"));
        System.out.println("取出改名后的name键的值："+jedis.get("name"));

        // 切换数据库
        System.out.println("按索引切换数据库："+jedis.select(0));
        System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());

        System.out.println("返回当前数据库中的key的数目："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key："+jedis.flushAll());

    }

}

// 输出结果
清空数据：OK
判断某个键是否存在：false
新增键值对：OK
新增键值对：OK
系统中所有键如下：
[password, username]
删除键password:1
判断password键是否存在：false
查看键username所存储的值的类型：string
随机返回键空间的一个：username
重命名key：OK
取出改名后的name键的值：zhangsan
按索引切换数据库：OK
删除当前选择数据库中的所有key：OK
返回当前数据库中的key的数目：0
删除所有数据库中的所有key：OK

String

import redis.clients.jedis.Jedis;

/**
 * 测试字符串命令操作
 */
public class TestString {

    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("========增加数据=========");
        System.out.println(jedis.set("k1", "v1"));
        System.out.println(jedis.set("k2", "v2"));
        System.out.println(jedis.set("k3", "v3"));

        System.out.println("删除键k2："+jedis.del("k2"));
        System.out.println("获取键k2："+jedis.get("k2"));

        System.out.println("修改k1："+jedis.set("k1", "v111"));
        System.out.println("获取k1的值："+jedis.get("k1"));

        System.out.println("在k3的value值后追加："+jedis.append("k3", "end"));
        System.out.println("获取k3的值："+jedis.get("k3"));

        System.out.println("========增加多个键值对========");
        System.out.println(jedis.mset("key1", "aaa", "key2", "bbb", "key3", "ccc"));
        System.out.println(jedis.mget("key1", "key2", "key3"));
        System.out.println(jedis.mget("key1", "key2", "key3", "key4"));
        System.out.println(jedis.del("key1", "key2"));
        System.out.println(jedis.mget("key1", "key2", "key3"));

        jedis.flushDB();
        System.out.println("========新增键值对，不存在再插入，存在则插入不成功=========");
        System.out.println(jedis.setnx("k1", "v1"));
        System.out.println(jedis.setnx("k2", "v2"));
        System.out.println(jedis.setnx("k2", "v2-new"));
        System.out.println(jedis.get("k1"));
        System.out.println(jedis.get("k2"));

        System.out.println("=========新增键值对并设置有效时间==========");
        System.out.println(jedis.setex("k3", 2, "v3"));
        System.out.println(jedis.get("k3"));
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(jedis.get("k3"));

        System.out.println("==========获取原值，并更新为新值==========");
        System.out.println(jedis.getSet("k2", "v2getSet"));
        System.out.println(jedis.get("k2"));

        System.out.println("获得k2的值的字符串："+jedis.getrange("k2", 2, 4));
    }

}

// 输出结果
========增加数据=========
OK
OK
OK
删除键k2：1
获取键k2：null
修改k1：OK
获取k1的值：v111
在k3后面加入值：5
获取k3的值：v3end
========增加多个键值对========
OK
[aaa, bbb, ccc]
[aaa, bbb, ccc, null]
2
[null, null, ccc]
========新增键值对，防止覆盖原先值==========
1
1
0
v1
v2
=========新增键值对并设置有效时间==========
OK
v3
null
==========获取原值，更新为新值==========
v2
v2getSet
获得k2的值的字符串：get

List

/**
 * 测试List命令操作
 */
public class TestList {

    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("=========增加一个list=========");
        jedis.lpush("collections", "ArrayList","LinkedList","Vector","HashMap","HashSet");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        jedis.lpush("collections", "HashMap");

        //第一个参数：集合名  第二个参数：起始位置下标  第二个参数：终止位置下标，-1代表截取到最后
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));
        System.out.println("collections的0-3区间的元素："+jedis.lrange("collections", 0, 3));

        System.out.println("=========lrem 删除指定元素并指定个数==========");
        //第一个参数：删除指定列表 第二个参数：删除的个数（有重复时），后添加进去的值先被删，类似于出栈
        System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, "HashMap"));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("=========ltrim 截取指定区间的元素==========");
        System.out.println("截取下标0-3区间之间的元素："+jedis.ltrim("collections", 0, 3));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("=========lpop 出栈（左端）==========");
        System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("=========rpush 添加（右端）==========");
        System.out.println("collections列表添加元素（右端）："+jedis.rpush("collections","xxx"));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("=========rpop 出栈（右端）==========");
        System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("=========lpush 添加（左端）==========");
        System.out.println("collections列表添加元素（左端）："+jedis.lpush("collections","xxx"));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("=========lset 修改指定下标的元素=========");
        System.out.println("collections修改指定下标的元素："+jedis.lset("collections", 1, "AAA"));
        System.out.println("collections的所有元素："+jedis.lrange("collections", 0, -1));

        System.out.println("========================");
        System.out.println("collections的长度："+jedis.llen("collections"));
        System.out.println("collections获取指定下标的元素："+jedis.lindex("collections", 2));

        System.out.println("========================");
        jedis.flushDB();

        jedis.rpush("sortList","3","6","4","8","7");
        System.out.println("sortList排序前："+jedis.lrange("sortList", 0, -1));
        System.out.println(jedis.sort("sortList"));
        System.out.println("sortList排序后："+jedis.lrange("sortList", 0, -1));
    }

}

// 输出结果
=========增加一个list=========
collections的所有元素：[HashMap, TreeMap, TreeSet, HashSet, HashMap, Vector, LinkedList, ArrayList]
collections的0-3区间的元素：[HashMap, TreeMap, TreeSet, HashSet]
=========lrem 删除指定元素并指定个数==========
删除指定元素个数：2
collections的所有元素：[TreeMap, TreeSet, HashSet, Vector, LinkedList, ArrayList]
=========ltrim 截取指定区间的元素==========
截取下标0-3区间之间的元素：OK
collections的所有元素：[TreeMap, TreeSet, HashSet, Vector]
=========lpop 出栈（左端）==========
collections列表出栈（左端）：TreeMap
collections的所有元素：[TreeSet, HashSet, Vector]
=========rpush 添加（右端）==========
collections列表添加元素（右端）：4
collections的所有元素：[TreeSet, HashSet, Vector, xxx]
=========rpop 出栈（右端）==========
collections列表出栈（右端）：xxx
collections的所有元素：[TreeSet, HashSet, Vector]
=========lpush 添加（左端）==========
collections列表添加元素（左端）：4
collections的所有元素：[xxx, TreeSet, HashSet, Vector]
=========lset 修改指定下标的元素=========
collections修改指定下标的元素：OK
collections的所有元素：[xxx, AAA, HashSet, Vector]
========================
collections的长度：4
collections获取指定下标的元素：HashSet
========================
sortList排序前：[3, 6, 4, 8, 7]
[3, 4, 6, 7, 8]
sortList排序后：[3, 6, 4, 8, 7]

Set

import redis.clients.jedis.Jedis;

/**
 * 测试Set命令操作
 */
public class TestSet {

    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();

        System.out.println("=========向集合中添加元素（不重复）=========");
        System.out.println(jedis.sadd("myset", "s1","s2","s5","s0","s8","s3","s4"));
        System.out.println(jedis.sadd("myset", "s6"));
        System.out.println(jedis.sadd("myset", "s6"));
        System.out.println("查看set集合中所有元素："+jedis.smembers("myset"));

        System.out.println("===========删除元素============");
        System.out.println("删除一个元素："+jedis.srem("myset", "s0"));
        System.out.println("查看set集合中所有元素："+jedis.smembers("myset"));

        System.out.println("删除两个元素："+jedis.srem("myset", "s3","s5"));
        System.out.println("查看set集合中所有元素："+jedis.smembers("myset"));

        System.out.println("随机移除元素："+jedis.spop("myset"));
        System.out.println("查看set集合中所有元素："+jedis.smembers("myset"));

        System.out.println("=====================");
        System.out.println("集合set中元素的个数："+jedis.scard("myset"));
        System.out.println("查看指定元素是否在myset中："+jedis.sismember("myset", "s8"));
        System.out.println("查看指定元素是否在myset中："+jedis.sismember("myset", "s5"));

        System.out.println("=====================");
        System.out.println(jedis.sadd("myset1", "a","b","d","e","c","f"));
        System.out.println(jedis.sadd("myset2", "c","f","h","d","k"));
        System.out.println("将myset1集合中指定元素移入myset3："+jedis.smove("myset1", "myset3", "a"));
        System.out.println("将myset2集合中指定元素移入myset3："+jedis.smove("myset2", "myset3", "f"));

        System.out.println("查看myset1集合中所有元素："+jedis.smembers("myset1"));
        System.out.println("查看myset2集合中所有元素："+jedis.smembers("myset2"));
        System.out.println("查看myset3集合中所有元素："+jedis.smembers("myset3"));

        System.out.println("==========集合运算===========");
        System.out.println("myset1和myset2的交集："+jedis.sinter("myset1","myset2"));
        System.out.println("myset1和myset2的并集："+jedis.sunion("myset1","myset2"));
        System.out.println("myset1和myset2的差集："+jedis.sdiff("myset1","myset2"));

        System.out.println("===========将并集保存到新集合中============");
        jedis.sinterstore("newSet", "myset1","myset2");
        System.out.println("查看newSet集合中所有元素："+jedis.smembers("newSet"));
    }

}

// 输出结果
=========向集合中添加元素（不重复）=========
7
1
0
查看set集合中所有元素：[s5, s3, s4, s8, s2, s6, s1, s0]
===========删除元素============
删除一个元素：1
查看set集合中所有元素：[s4, s8, s2, s6, s1, s5, s3]
删除两个元素：2
查看set集合中所有元素：[s6, s1, s2, s8, s4]
随机移除元素：s2
查看set集合中所有元素：[s1, s6, s8, s4]
=====================
集合set中元素的个数：4
查看指定元素是否在myset中：true
查看指定元素是否在myset中：false
=====================
6
5
将myset1集合中指定元素移入myset3：1
将myset2集合中指定元素移入myset3：1
查看myset1集合中所有元素：[b, c, e, f, d]
查看myset2集合中所有元素：[d, h, c, k]
查看myset3集合中所有元素：[f, a]
==========集合运算===========
myset1和myset2的交集：[d, c]
myset1和myset2的并集：[c, e, b, h, f, d, k]
myset1和myset2的差集：[e, f, b]
===========将并集保存到新集合中============
查看newSet集合中所有元素：[c, d]

Hash

import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.Map;

/**
 * 测试Hash命令操作
 */
public class TestHash {

    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.flushDB();

        Map<String,String> map = new HashMap<String,String>();
        map.put("k1", "v1");
        map.put("k2", "v2");
        map.put("k3", "v3");
        map.put("k4", "v4");

        //添加名称为hash的键，将map集合作为值添加
        jedis.hmset("hash", map);
        //添加元素
        jedis.hset("hash", "k5","v5");

        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));
        System.out.println("散列hash的所有值为："+jedis.hvals("hash"));

        System.out.println("将k6保存的值加上一个整数，如果k6不存在则添加k6："
                +jedis.hincrBy("hash", "k6", 100));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("将k6保存的值加上一个整数，如果k6不存在则添加k6："
                +jedis.hincrBy("hash", "k6", 300));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));

        System.out.println("删除一个或多个键值对："+jedis.hdel("hash", "k2"));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));

        System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));

        System.out.println("判断是否存在指定的键："+jedis.hexists("hash", "k2"));
        System.out.println("判断是否存在指定的键："+jedis.hexists("hash", "k3"));

        System.out.println("获取hash中的值："+jedis.hmget("hash", "k3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash", "k3","k4"));
    }

}

// 输出结果
散列hash的所有键值对为：{k3=v3, k4=v4, k5=v5, k1=v1, k2=v2}
散列hash的所有键为：[k3, k4, k5, k1, k2]
散列hash的所有值为：[v1, v3, v2, v4, v5]
将k6保存的值加上一个整数，如果k6不存在则添加k6：100
散列hash的所有键值对为：{k3=v3, k4=v4, k5=v5, k6=100, k1=v1, k2=v2}
将k6保存的值加上一个整数，如果k6不存在则添加k6：400
散列hash的所有键值对为：{k3=v3, k4=v4, k5=v5, k6=400, k1=v1, k2=v2}
删除一个或多个键值对：1
散列hash的所有键值对为：{k3=v3, k4=v4, k5=v5, k6=400, k1=v1}
散列hash中键值对的个数：5
判断是否存在指定的键：false
判断是否存在指定的键：true
获取hash中的值：[v3]
获取hash中的值：[v3, v4]

Zset

import redis.clients.jedis.Jedis;

/**
 * 测试Zset命令操作
 */
public class TestZset {

    public static void main(String[] args) {

        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        jedis.zadd("myzset", 1, "one");
        jedis.zadd("myzset", 2, "two");
        jedis.zadd("myzset", 3, "three");
        System.out.println(jedis.zrange("myzset", 0, -1));
        System.out.println(jedis.zrangeWithScores("myzset", 0, -1));


        jedis.flushDB();
        jedis.zadd("salary", 2000, "lisi");
        jedis.zadd("salary", 3000, "zs");
        jedis.zadd("salary", 1500, "wanger");
        System.out.println("按照score字段值排序："+jedis.zrangeByScore("salary", 1000, 3500));
        System.out.println("按照score字段值逆序："+jedis.zrevrangeByScore("salary", 3500, 1000));

        System.out.println("有序集合中元素的个数："+jedis.zcard("salary"));
        System.out.println("移除："+jedis.zrem("salary", "lisi"));
        System.out.println("有序集合中元素的个数："+jedis.zcard("salary"));
        System.out.println("集合中的所有元素："+jedis.zrange("salary", 0, -1));
        System.out.println("获取集合中指定区间的元素个数："+jedis.zcount("salary", 1500, 2500));

    }

}

// 输出结果
[one, two, three]
[[one,1.0], [two,2.0], [three,3.0]]
按照score字段值排序：[wanger, lisi, zs]
按照score字段值逆序：[zs, lisi, wanger]
有序集合中元素的个数：3
移除：1
有序集合中元素的个数：2
集合中的所有元素：[wanger, zs]
获取集合中指定区间的元素个数：1

2.4、事务

正常执行

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * 测试Jedis进行事务管理
 */
public class TestTrans {

    public static void main(String[] args) {

        //创建Jedis对象
        Jedis jedis = new Jedis("106.14.159.179", 6379);
        //测试连接
        System.out.println(jedis.ping());

        //创建json对象
        JSONObject obj = new JSONObject();
        //给json对象存储值
        obj.put("hello", "world");
        obj.put("name", "zhangsan");
        obj.put("age", "10");
        String str = obj.toJSONString();

        //开启事务
        Transaction multi = jedis.multi();
        try {
            //命令入队
            multi.set("user1", str);
            multi.set("user2", str);

            //执行事务
            multi.exec();
        } catch (Exception e) {
            //放弃事务
            multi.discard();
            e.printStackTrace();
        } finally {
            //输出信息
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            //关闭连接
            jedis.close();
        }
    }

}

// 运行结果
PONG
{"name":"zhangsan","hello":"world","age":"10"}
{"name":"zhangsan","hello":"world","age":"10"}

出现异常

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

/**
 * 测试Jedis进行事务管理
 */
public class TestTrans {

    public static void main(String[] args) {

        //创建Jedis对象
        Jedis jedis = new Jedis("106.14.159.179", 6379);
        //测试连接
        System.out.println(jedis.ping());

        jedis.flushDB();

        //创建json对象
        JSONObject obj = new JSONObject();
        //给json对象存储值
        obj.put("hello", "world");
        obj.put("name", "zhangsan");
        obj.put("age", "10");
        String str = obj.toJSONString();

        //开启事务
        Transaction multi = jedis.multi();
        try {
            //命令入队
            multi.set("user1", str);
            multi.set("user2", str);

            //异常代码块，抛出异常，事务执行失败
            int i = 10/0;

            //执行事务
            multi.exec();
        } catch (Exception e) {
            //放弃事务
            multi.discard();
            e.printStackTrace();
        } finally {
            //输出信息
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            //关闭连接
            jedis.close();
        }
    }

}

// 运行结果
PONG
java.lang.ArithmeticException: / by zero
	at com.igeek.test.TestTrans.main(TestTrans.java:37)
null
null