redis使用总结(二)(jedis使用)

Jedis使用(Jedis中的API和redis的指令基本相同)

1.创建maven工程,在pom文件中导入jedis的坐标
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
2. 获取使用jedis获取redis的连接(注意：操作完成后将jedis的连接关闭)

    private Jedis jedis;

    @Before
    public void before() {
        jedis = new Jedis("localhost",6379);
    }

    @After
    public void after() {
        jedis.close();
    }

3. jedis操作String类型

    @Test
    public void testStringDel() {
        jedis.del("jedisStr");
        String str =  jedis.get("jedisStr");
        System.out.println(str);
    }

    输出为 ：myJedis

    @Test
    public void testStringSet() {
        jedis.set("jedisStr","myJedis");
        String str = jedis.get("jedisStr");
        System.out.println(str);
    }

    输出为 ：null

4. jedis操作hash类型

    @Test
    public void testHashSet() {
        String[] strings = {"王重阳","洪七公","欧阳锋","黄药师","段智兴"};

        //查看hset方法的源码,hset方法的三个参数都为String类型,所以将数组转换为json
        String JSONStr = JSONObject.toJSONString(strings);
        jedis.hset("jedisHash", "strings", JSONStr);
        jedis.hset("jedisHash", "string", "JSONStr");

        String hashStr = jedis.hget("jedisHash", "string");
        String hashJSONStr = jedis.hget("jedisHash", "strings");
        JSONArray hashJSONStrs = JSONObject.parseArray(hashJSONStr);

        System.out.println(hashStr);
        System.out.println(hashJSONStrs);
    }

    输出为 ：JSONStr
            ["王重阳","洪七公","欧阳锋","黄药师","段智兴"]

    @Test
    public void testHashDel() {

        jedis.hdel("jedisHash", "string");
        String hashStr = jedis.hget("jedisHash", "string");
        HashMap<String,String> map =  (HashMap<String, String>) jedis.hgetAll("jedisHash");
        System.out.println(hashStr);
        System.out.println(map);
    }

    输出为 ：null
            {strings=["王重阳","洪七公","欧阳锋","黄药师","段智兴"]}

    hset方法的源码：
    public Long hset(final String key, final String field, final String value) {
        checkIsInMultiOrPipeline();
        client.hset(key, field, value);
        return client.getIntegerReply();
    }

    hget方法的源码：
    public String hget(final String key, final String field) {
        checkIsInMultiOrPipeline();
        client.hget(key, field);
        return client.getBulkReply();
    }

5. jedis操作list类型

    @Test
    public void testListPush() {
        //lpush和rpush中value的参数是可变参数序列
        jedis.lpush("jedisList", "one","two","three");
        jedis.rpush("jedisList", "1","2","3");
        List<String> list = jedis.lrange("jedisList", 0, -1);
        System.out.println(list);
    }

    输出为 ：[three, two, one, 1, 2, 3]

    @Test
    public void testListPop() {

        String listStr1 = jedis.lpop("jedisList");
        String listStr2 = jedis.rpop("jedisList");
        List<String> list = jedis.lrange("jedisList", 0, -1);

        System.out.println(listStr1);
        System.out.println(listStr2);
        System.out.println(list);
    }

    输出为 ：three
            3
            [two, one, 1, 2]

6. jedis操作set类型

    @Test
    public void testSetAdd() {

        jedis.sadd("jedisSet", "南帝","北丐","中神通");
        Set<String> set = jedis.smembers("jedisSet");
        System.out.println(set);
    }

    输出为 : [南帝, 中神通, 北丐]

    @Test
    public void testSetRem() {
        jedis.srem("jedisSet", "中神通");
        Set<String> set = jedis.smembers("jedisSet");
        System.out.println(set);
    }

    输出为 ：[南帝, 北丐]

    7. jedis操作Sorted Set类型(ZSet)

    @Test
    public void testSortedSetAdd() {

        Map<String, Double> map =  new HashMap<String, Double>();
        map.put("华佗", 36D);
        map.put("张仲景", 66.6);

        jedis.zadd("jedisZSet", 6, "扁鹊");
        jedis.zadd("jedisZSet", map);

        Set<String> set =  jedis.zrange("jedisZSet", 0, -1);
        Set<Tuple> zSet =  jedis.zrangeWithScores("jedisZSet", 0, -1);

        System.out.println(set);

        for(Tuple tuple : zSet) {
            System.out.print(tuple.getElement() + "  ");
            System.out.print(tuple.getScore()+ " ");
        }
    }

    输出为 ： [扁鹊, 华佗, 张仲景]
             扁鹊  6.0 华佗  36.0 张仲景  66.6 

    @Test
    public void testSortedSetRem() {
        jedis.zrem("jedisZSet", "扁鹊");

        Set<String> set =  jedis.zrange("jedisZSet", 0, -1);
        System.out.println(set);
    }

    输出为 ： [华佗, 张仲景]

8. 其他redis的常用指令使用jedis操作

    1) redis指令： dbsize ：返回当前数据库的 key 的数量。
       jedis操作：

    @Test
    public void testDbsize() {
        Long size =  jedis.dbSize();
        System.out.println(size);
    }

    输出为 ： 9

    2) redis指令 Keys pattern：查找所有符合给定模式 pattern 的 key 。
       jedis操作：

    @Test
    public void testKeys() {
        Set<String> keys = jedis.keys("jedis*");
        System.out.println(keys);
    }

    输出为 ： [jedisList, jedisZSet, jedisSet, jedisStr, jedisHash]

    3) redis指令 del key [key …] ：删除给定的一个或多个key，以及对应的value，不存在的 key 会被忽略，该指令可以将任意数据类型删除
       jedis操作:

    @Test
    public void testDel() {
        jedis.del("jedisStr");
        Set<String> keys = jedis.keys("jedis*");
        System.out.println(keys);
    }

    输出为 ： [jedisList, jedisZSet, jedisSet, jedisHash]

    4) redis指令 type key ：返回 key 所储存的值的类型。
       jedis操作:

    @Test
    public void testType() {
        String type =  jedis.type("jedisHash");
        System.out.println(type);
    }

    输出为 ：hash

    5）redis指令 exists key ：检查指定key是否存在
       jedis操作:

    @Test
    public void testExists() {
        Boolean hashExists = jedis.exists("jedisHash");
        Boolean strExists = jedis.exists("jedisStr");

        System.out.println(hashExists);
        System.out.println(strExists);
    }

    输出为 ： true
             false

    6）redis指令 expire key seconds：为给定 key 设置生存时间，当 key 过期时(生存时间为 0 )，它会被自动删除。seconds的单位为秒。
    7）redis指令 ttl key  以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
                当 key 不存在时，返回 -2 。
                当 key 存在但没有设置剩余生存时间时，返回 -1 。
                否则，以秒为单位，返回 key 的剩余生存时间。
       jedis操作：

    @Test
    public void testExpireAndTtl() throws InterruptedException {
        jedis.expire("jedisHash", 20);

        Thread.sleep(2000L);

        Long jedisHashExistsTime = jedis.ttl("jedisHash");
        Long jedisStrExistsTime = jedis.ttl("jedisStr");
        Long jedisZSetExistsTime = jedis.ttl("jedisZSet");

        System.out.println(" jedisHash 存活时间 ： " + jedisHashExistsTime);
        System.out.println(" jedisStr  存活时间 ： " + jedisStrExistsTime);
        System.out.println(" jedisZSet 存活时间 ： " + jedisZSetExistsTime);
    }

    输出为 ：
            jedisHash 存活时间 ： 18
            jedisStr  存活时间 ： -2
            jedisZSet 存活时间 ： -1

    7) redis指令 flushall：清空整个 Redis 服务器的数据(删除所有数据库的所有 key )，此命令从不失败。
       flushdb ：清空当前数据库中的所有 key，此命令从不失败。

    jedis操作：("禁止在公司的正式项目中使用该命令")

    @Test
    public void testFlushdb() {
        String str = jedis.flushDB();
        Set<String> set = jedis.keys("*");

        System.out.println(str);
        System.out.println(set.isEmpty());
    }

    输出 ：
        OK
        true

    这时redis中数据被清空，在公司的正式项目中禁止使用该指令，需要删除数据尽量使用del指令或方法

    127.0.0.1:6379> keys *
    (empty list or set)

jedis连接池使用

jedis连接资源的创建与销毁是很消耗程序性能，所以jedis为我们提供了jedis的池化技术，

jedisPool在创建时初始化一些连接资源存储到连接池中，使用jedis连接资源时不需要创建，

而是从连接池中获取一个资源进行redis的操作，使用完毕后，不需要销毁该jedis连接资源，

而是将该资源归还给连接池，供其他请求使用。

jedis连接池使用

@Test
public void testJedisPool(){
    //1 获得连接池配置对象，设置配置项
    JedisPoolConfig config = new JedisPoolConfig();
    // 1.1 最大连接数
    config.setMaxTotal(20);

    //1.2 最大空闲连接数
    config.setMaxIdle(10);

    //获得连接池
    JedisPool jedisPool = new JedisPool(config,"localhost",6379);

    Jedis jedis=null;
    try {
        //3.获得核心对象
         jedis = jedisPool.getResource();
        //4.设置数据
        jedis.set("name","laocao");
        //5.获得数据
        String name = jedis.get("name");
        System.out.println(name);
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if(jedis!=null){
            //6.归还jedis连接到连接池中
            jedis.close();
        }
    }

    //虚拟机关闭时，释放pool资源
    if(jedisPool!=null){
        jedisPool.close();
    }
}

我们在使用jedis连接池时不能每次都创建jedisPool，所以我们创建一个jedisPool的工具类

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

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

public class JedisPoolUtil {

    //jedis的url
    private static String url;
    //jedis的端口
    private static int port;
    //jedis的最大连接数
    private static int maxtotal;
    //jedis的最大空闲连接数
    private static int maxwaitmillis;
    //jedis连接池
    private static JedisPool jedisPool;

    //静态代码块保证jedisPool只初始化一次
    static {
        //读取配置文件 读取properties比较常用的是 Properties和ResourceBundle 这里使用的是Properties
        InputStream inputStream = JedisPoolUtil.class.getClassLoader().getResourceAsStream("jedis.properties");
        //创建Properties对象
        Properties pro = new Properties();
        //关联文件
        try {
            pro.load(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //为属性赋值
        url = pro.getProperty("jedis.url");
        port = Integer.parseInt(pro.getProperty("jedis.port"));
        maxtotal = Integer.parseInt(pro.getProperty("jedis.maxtotal"));
        maxwaitmillis = Integer.parseInt(pro.getProperty("jedis.maxwaitmillis"));

        //获取数据，设置到JedisPoolConfig中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(maxtotal);
        config.setMaxIdle(maxwaitmillis);
        //初始化JedisPool
        jedisPool = new JedisPool(config,url,port);
    }

    //获取jedis
    public static Jedis getJedisResource() {
        return jedisPool.getResource();
    }
}

配置文件 ：

jedis.url=127.0.0.1
jedis.port=6379
jedis.maxtotal=20
jedis.maxwaitmillis=10

文章部分借鉴了 @Roy-Xin 老兄jedis连接池的部分内容,在此表示感谢