使用Jedis客户端快速操作redis

1、加入相关maven依赖

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

<!-- 下面仅为了为了测试加入的依赖 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.68</version>
</dependency>

2、Jedis操作

package org.example;

import com.alibaba.fastjson.JSONArray;
import org.junit.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Unit test for simple App.
 */
@RunWith(JUnit4.class)
public class AppTest {
    private static Jedis jedis;

    @BeforeClass
    public static void beforeClass() {
        // 如果没有密码，可以直接用new Jedis("192.168.154.5",6379),因为设置了密码，所以用jedisShardInfo
        JedisShardInfo info = new JedisShardInfo("192.168.154.5", 6379);
        info.setPassword("123456");
        jedis = new Jedis(info);
        Assert.assertEquals("PONG", jedis.ping());
    }

    @AfterClass
    public static void afterClass() {
        jedis.close();
    }

    @Before
    public void before() {
        // 异常：JedisDataException: WRONGTYPE Operation against a key holding the wrong kind of value 错误类型操作
        // 避免某处用language 作为hset  然后又lpush操作出现类型操作错误
        jedis.del("name");
        jedis.del("name1");
        jedis.del("name2");
        jedis.del("user");
        jedis.del("user2");
        jedis.del("language");
        jedis.del("positions");
        jedis.del("hll");
        jedis.del("languageSet");
    }

    /**
     * 字符串，支持int,string,float
     */
    @Test
    public void string() throws InterruptedException {
        jedis.set("name", "wanger");

        Assert.assertEquals("wanger", jedis.get("name"));


        jedis.mset("name1", "wanger1", "name2", "wanger2");

        Assert.assertEquals("wanger1", jedis.get("name1"));
        Assert.assertEquals("wanger2", jedis.get("name2"));


        /*
                加锁演示，失败
         */
        jedis.del("lock");
        // 加锁成功
        Assert.assertEquals(1L, jedis.setnx("lock", "2").longValue());
        // 再加锁，失败，
        Assert.assertEquals(0L, jedis.setnx("lock", "2").longValue());

        /*
                加锁演示，并且设置超时时间，超时后获取锁成功！（名字不一定是lock，只是刚好用这个）
         */
        // 过期自动释放锁（删除key）
        jedis.del("lock");
        // 加锁setnx，（或直接用jedis.setex("lock",2,"2");  指定过期时间）
        Assert.assertEquals(1L, jedis.setnx("lock", "2").longValue());
        // 设置锁过期时间
        jedis.expire("lock", 2);
        // 测试获取锁失败
        Assert.assertEquals(0L, jedis.setnx("lock", "2").longValue());
        // 等待2秒，锁会删除
        Thread.sleep(2001L);
        // 再次获取锁成功
        Assert.assertEquals(1L, jedis.setnx("lock", "2").longValue());
    }

    /**
     * 哈希
     */
    @Test
    public void hash() throws InterruptedException {
        // hset 支持构建map插入，也支持不构建map（仅一个字段）
        jedis.hset("user", "foo", "bar");

        Assert.assertEquals("bar", jedis.hget("user", "foo"));

        // hmset 仅支持map插入
        Map<String, String> temp = new HashMap<>();
        temp.put("foo", "bar");
        temp.put("foo2", "bar2");
        jedis.hmset("user2", temp);

        Assert.assertEquals("{foo2=bar2, foo=bar}", jedis.hgetAll("user2").toString());
        Assert.assertEquals("bar", jedis.hget("user2", "foo"));
        Assert.assertEquals("bar2", jedis.hget("user2", "foo2"));

    }

    /**
     * 集合
     */
    @Test
    public void set() {
        jedis.sadd("languageSet", "java");
        jedis.sadd("languageSet", "python");
        jedis.sadd("languageSet", "python");// 无效插入
        jedis.sadd("languageSet", "python");// 无效插入
        jedis.sadd("languageSet", "c++");
        jedis.sadd("languageSet", "vb");
        Set<String> sList = jedis.smembers("languageSet");
        System.out.println(sList);
        Assert.assertEquals(4, sList.size());
    }

    /**
     * 列表，底层是双向链表结构
     */
    @Test
    public void list() {

        jedis.lpush("language", "java");
        jedis.lpush("language", "python");
        jedis.lpush("language", "python");//重复插入，无效才啊哦做
        jedis.lpush("language", "c++");
        jedis.lpush("language", "vb");

        List<String> lList = jedis.lrange("language", 0, 100);
        String result = JSONArray.toJSONString(lList);

        Assert.assertEquals("[\"vb\",\"c++\",\"python\",\"python\",\"java\"]", result);
    }

    /**
     * 有序集合
     */
    @Test
    public void sortSet() {
        jedis.zadd("language", 0, "java");
        jedis.zadd("language", 1, "python");
        jedis.zadd("language", 1, "python");// 无效插入
        jedis.zadd("language", 10, "python");// 无效插入
        jedis.zadd("language", 1, "c++");
        jedis.zadd("language", 4, "vb");
        Set<String> sList = jedis.zrangeByScore("language", 0, 10);

        Assert.assertEquals("[\"java\",\"c++\",\"vb\",\"python\"]", JSONArray.toJSONString(sList));
    }

    /**
     * 基数，可以使用非常小的内存统计非常大的数据，存在小量误差，用于统计流量 阅读不错
     */
    @Test
    public void hyperLogLog() {
        float size = 100000;
        for (int i = 0; i < size; i++) {
            jedis.pfadd("hll", "hll-" + i);
        }
        long total = jedis.pfcount("hll");

        // 统计个数：99577
        System.out.println(total);
        // 正确率：0.99577
        System.out.println(total / size);
        // 误差率：0.0042300224
        System.out.println(1 - (total / size));
    }

    /**
     * 地理位置，存储的是位置信息，可以进行操作
     */
    @Test
    public void geo() {
        Map<String, GeoCoordinate> geoMap = new HashMap<>();
        GeoCoordinate localCoordinate = new GeoCoordinate(112.881953, 28.238426);
        GeoCoordinate CompanyCoordinate = new GeoCoordinate(78.45681, 64.15516);
        geoMap.put("local", localCoordinate);
        geoMap.put("company", CompanyCoordinate);
        jedis.geoadd("positions", geoMap);
        Assert.assertEquals("[(112.88195461034775,28.238424808101946)]", jedis.geopos("positions", "local").toString());
        Assert.assertEquals("[(78.45681041479111,64.15516002493432)]", jedis.geopos("positions", "company").toString());
    }
}