Redis系列八 使用Jedis

使用Jedis jar操作Redis

1、配置redis.conf文件，修改

　　

2、建java工程，加入 jedis jar包

　　

3、代码示例：

package com.ntjr.redis;

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

import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.Jedis;

public class TestApi {
    private Jedis jedis;

    /**
     * 连接192.168.15.128:6379 Redis
     */
    @Before
    public void before() {
        jedis = new Jedis("192.168.15.128", 6379);
    }

    
    /**
     * 测试set get  及 过期时间，返回-1代表永不过期
     */
    @Test
    public void testSetKey() {
        jedis.set("k1", "v1");
        jedis.set("k2", "v2");
        jedis.set("k3", "v3");
        System.out.println(jedis.get("k3"));
        System.out.println(jedis.ttl("k1"));
    }

    
    /**
     * 获取所有的key
     */
    @Test
    public void testGet() {
        Set<String> keys = jedis.keys("*");
        for (Iterator<String> iterator = keys.iterator(); iterator.hasNext();) {
            String key = (String) iterator.next();
            System.out.println(key);
        }
    }

    /**
     * 是否存在k2
     */
    @Test
    public void testExists() {
        System.out.println(jedis.exists("k2"));
    }

    /**
     * string 追加
     */
    @Test
    public void testAppend() {
        jedis.append("k1", "myredis");
        System.out.println(jedis.get("k1"));
    }

    /**
     * 设置多个键值对
     */
    @Test
    public void testMSET() {
        jedis.mset("str1", "v1", "str2", "v2", "str3", "v3");
        System.out.println(jedis.mget("str1", "str2", "str3"));
    }

    /**
     * 测试为list设置值，获取list集合
     */
    @Test
    public void testLPUSH() {
        jedis.lpush("mylist", "v1", "v2", "v3", "v4", "v5");
        List<String> myList = jedis.lrange("mylist", 0, -1);
        for (String element : myList) {
            System.out.println(element);
        }
    }

    /**
     * Set集合的添加、遍历、删除
     */
    @Test
    public void testSet() {
        jedis.sadd("orders", "jd001");
        jedis.sadd("orders", "jd002");
        jedis.sadd("orders", "jd003");
        Set<String> orders = jedis.smembers("orders");
        for (Iterator<String> iterator = orders.iterator(); iterator.hasNext();) {
            System.out.println(iterator.next());
        }
        jedis.srem("orders", "jd002");
        System.out.println(jedis.smembers("orders").size());
    }

    /**
     * Map集合操作，获取多个值
     */
    @Test
    public void testHash() {
        jedis.hset("hash1", "uername", "lisi");
        System.out.println(jedis.hget("hash1", "uername"));
        Map<String, String> map = new HashMap<>();
        map.put("telphone", "13811814763");
        map.put("address", "atguigu");
        map.put("email", "abc@163.com");
        jedis.hmset("hash1", map);
        List<String> result = jedis.hmget("hash1", "telphone", "email");
        for (String element : result) {
            System.out.println(element);
        }
    }

    /**
     * Zset设置，为每个数据设置 score
     */
    @Test
    public void testZSET() {
        jedis.zadd("zset01", 60d, "v1");
        jedis.zadd("zset01", 70d, "v2");
        jedis.zadd("zset01", 80d, "v3");
        jedis.zadd("zset01", 90d, "v4");
        Set<String> zset = jedis.zrange("zset01", 0, -1);
        for(Iterator<String> iterator = zset.iterator();iterator.hasNext(); ){
            System.out.println(iterator.next());
        }
    }

}

4、使用JedisPool连接池

package com.ntjr.redis;

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

public class JedisPoolUtils {

    private static volatile JedisPool jedisPool = null;

    private JedisPoolUtils() {
    }

    public static JedisPool getJedisPoolInstance() {
        synchronized (JedisPoolUtils.class) {
            if (jedisPool == null) {
                synchronized (JedisPoolUtils.class) {
                    if (jedisPool == null) {
                        JedisPoolConfig poolConfig = new JedisPoolConfig();
                        poolConfig.setMaxActive(1000);
                        poolConfig.setMaxIdle(30);
                        poolConfig.setMaxWait(100*1000);
                        poolConfig.setTestOnBorrow(true);
                        jedisPool = new JedisPool(poolConfig, "192.168.15.128", 6379);
                    }
                }
            }
        }
        return jedisPool;
    }
    
    
    
    public static void release(JedisPool jedisPool,Jedis jedis){
        if(jedis!=null){
            jedisPool.returnResourceObject(jedis);
        }
    }

}

5、JedisPool配置参数

　　JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。
　　maxActive：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。
　　maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；
　　whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。
　　 WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException；
 　　WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException；
 　　WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用；
　　maxWait：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛JedisConnectionException；
　　testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的

　　testOnReturn：return 一个jedis实例给pool时，是否检查连接可用性（ping()）；　　

　　testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；　　

　　timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数；

　　numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；

　　minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；

　　softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义；

　　lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；

==================================================================================================================
　　其中JedisPoolConfig对一些参数的默认设置如下：
　　testWhileIdle=true
　　minEvictableIdleTimeMills=60000
　　timeBetweenEvictionRunsMillis=30000
numTestsPerEvictionRun=-1

6、链接集群

　　第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。

　　第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。

　　第三步：打印结果

　　第四步：系统关闭前，关闭JedisCluster对象。

public void testJedisCluster() throws Exception {
        // 第一步：使用JedisCluster对象。需要一个Set<HostAndPort>参数。Redis节点的列表。
        Set<HostAndPort> nodes = new HashSet<>();
        nodes.add(new HostAndPort("192.168.25.153", 7001));
        nodes.add(new HostAndPort("192.168.25.153", 7002));
        nodes.add(new HostAndPort("192.168.25.153", 7003));
        nodes.add(new HostAndPort("192.168.25.153", 7004));
        nodes.add(new HostAndPort("192.168.25.153", 7005));
        nodes.add(new HostAndPort("192.168.25.153", 7006));
        JedisCluster jedisCluster = new JedisCluster(nodes);
        // 第二步：直接使用JedisCluster对象操作redis。在系统中单例存在。
        jedisCluster.set("hello", "100");
        String result = jedisCluster.get("hello");
        // 第三步：打印结果
        System.out.println(result);
        // 第四步：系统关闭前，关闭JedisCluster对象。
        jedisCluster.close();
    }

 7、使用Redis向业务逻辑中添加缓存

　　1、接口封装：常用的操作redis的方法提取出一个接口，分别对应单机版和集群版创建两个实现类。

　　2、接口定义

public interface JedisClient {

    String set(String key, String value);
    String get(String key);
    Boolean exists(String key);
    Long expire(String key, int seconds);
    Long ttl(String key);
    Long incr(String key);
    Long hset(String key, String field, String value);
    String hget(String key, String field);
    Long hdel(String key, String... field);
}

　3、单机版实现

public class JedisClientPool implements JedisClient {
    
    @Autowired
    private JedisPool jedisPool;

    @Override
    public String set(String key, String value) {
        Jedis jedis = jedisPool.getResource();
        String result = jedis.set(key, value);
        jedis.close();
        return result;
    }

    @Override
    public String get(String key) {
        Jedis jedis = jedisPool.getResource();
        String result = jedis.get(key);
        jedis.close();
        return result;
    }

    @Override
    public Boolean exists(String key) {
        Jedis jedis = jedisPool.getResource();
        Boolean result = jedis.exists(key);
        jedis.close();
        return result;
    }

    @Override
    public Long expire(String key, int seconds) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.expire(key, seconds);
        jedis.close();
        return result;
    }

    @Override
    public Long ttl(String key) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.ttl(key);
        jedis.close();
        return result;
    }

    @Override
    public Long incr(String key) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.incr(key);
        jedis.close();
        return result;
    }

    @Override
    public Long hset(String key, String field, String value) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.hset(key, field, value);
        jedis.close();
        return result;
    }

    @Override
    public String hget(String key, String field) {
        Jedis jedis = jedisPool.getResource();
        String result = jedis.hget(key, field);
        jedis.close();
        return result;
    }

    @Override
    public Long hdel(String key, String... field) {
        Jedis jedis = jedisPool.getResource();
        Long result = jedis.hdel(key, field);
        jedis.close();
        return result;
    }

}

　　4、集群版实现

package cn.e3mall.jedis;

import org.springframework.beans.factory.annotation.Autowired;

import redis.clients.jedis.JedisCluster;

public class JedisClientCluster implements JedisClient {
    
    @Autowired
    private JedisCluster jedisCluster;

    @Override
    public String set(String key, String value) {
        return jedisCluster.set(key, value);
    }

    @Override
    public String get(String key) {
        return jedisCluster.get(key);
    }

    @Override
    public Boolean exists(String key) {
        return jedisCluster.exists(key);
    }

    @Override
    public Long expire(String key, int seconds) {
        return jedisCluster.expire(key, seconds);
    }

    @Override
    public Long ttl(String key) {
        return jedisCluster.ttl(key);
    }

    @Override
    public Long incr(String key) {
        return jedisCluster.incr(key);
    }

    @Override
    public Long hset(String key, String field, String value) {
        return jedisCluster.hset(key, field, value);
    }

    @Override
    public String hget(String key, String field) {
        return jedisCluster.hget(key, field);
    }

    @Override
    public Long hdel(String key, String... field) {
        return jedisCluster.hdel(key, field);
    }

}

　5、spring配置单机版　

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans4.2.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context4.2.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop4.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx4.2.xsd
    http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util4.2.xsd">

    <!-- 配置单机版的连接 -->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool">
        <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
        <constructor-arg name="port" value="6379"></constructor-arg>
    </bean>
    <bean id="jedisClientPool" class="cn.e3mall.jedis.JedisClientPool"/>
    
</beans>

　　6、spring集群版配置

<!-- 集群版的配置 -->
    <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">
        <constructor-arg>
            <set>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
                    <constructor-arg name="port" value="7001"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
                    <constructor-arg name="port" value="7002"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
                    <constructor-arg name="port" value="7003"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
                    <constructor-arg name="port" value="7004"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
                    <constructor-arg name="port" value="7005"></constructor-arg>
                </bean>
                <bean class="redis.clients.jedis.HostAndPort">
                    <constructor-arg name="host" value="192.168.25.153"></constructor-arg>
                    <constructor-arg name="port" value="7006"></constructor-arg>
                </bean>
            </set>
        </constructor-arg>
    </bean>
    <bean id="jedisClientCluster" class="cn.e3mall.jedis.JedisClientCluster"/>

注意：单机版和集群版不能共存，使用单机版时注释集群版的配置。使用集群版，把单机版注释。