Java如何使用redis：Jedis和RedisTemplate

一、確認redis服務開啓

首先要確認redis正常開啓，命令行輸入
redis-server.exe

一定要確認redis服務啓動，如未啓動，程序肯定會報錯。

二、Jedis的配置及使用

1、添加依賴

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

2、連接Redis

import redis.clients.jedis.Jedis;

public class RedisUtil {
    private static Jedis jedis;
    public static Jedis connectRedis(String host) {
        jedis = new Jedis(host);
        return jedis;
    }

    public static void main(String[] args) {
        Jedis jedis = RedisUtil.connectRedis("localhost");
        System.out.println(jedis.ping());  // 輸出：PONG
    }
}

3、key的相關操作

方法名	功能
flushDB()	清除數據庫所有數據
exists(String key)	判斷鍵key是否存在
expire(String key, int second)	設置鍵key的過期時間
ttl(String key)	key的剩餘生存時間，不存在或永久都返回-1
type(String key)	key所儲存值的類型

4、string(字符串)類型：增刪改查

import redis.clients.jedis.Jedis;

public class RedisStringTest {
    public static void main(String[] args) {
        Jedis jedis = RedisUtil.connectRedis("localhost");
        // 增加String
        jedis.set("one", "1");
        jedis.set("two", "2");
        // 查詢鍵所對應的值
        System.out.println("鍵爲“two”的值：" + jedis.get("two"));
        // 原來基礎上修改
        jedis.append("two", "-修改");
        System.out.println("修改後，鍵爲“two”的值：" + jedis.get("two"));
        // 覆蓋修改
        jedis.set("two", "2-覆蓋修改");
        System.out.println("覆蓋修改後，鍵爲“two”的值：" + jedis.get("two"));
        // 刪除String
        jedis.del("two");
        System.out.println("刪除後，鍵爲“two”的值：" + jedis.get("two"));
    }
}

運行結果：

5、hash（哈希）類型：增刪改查

import redis.clients.jedis.Jedis;

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

public class RedisHashTest {
    public static void main(String[] args) {
        Jedis jedis = RedisUtil.connectRedis("localhost");
        Map<String, String> map = new HashMap<String, String>();
        map.put("AAA", "1");
        map.put("BBB", "2");
        map.put("CCC", "3");
        // 增加
        jedis.hmset("map", map);
        // 查詢，注意返回值是List型，第二個參數可以跟多個map的key。
        List<String> mapAAA = jedis.hmget("map", "AAA");
        System.out.println("查詢map鍵爲“AAA”的值：" + mapAAA);
        // 刪除
        jedis.hdel("map", "AAA");
        System.out.println("刪除後，查詢map鍵爲“AAA”的值：" + jedis.hmget("map", "AAA"));

        // 其他查詢
        System.out.println("map中鍵值對的個數：" + jedis.hlen("map"));
        System.out.println("map中所有的鍵：" + jedis.hkeys("map"));
        System.out.println("map中所有的值：" + jedis.hvals("map"));
    }
}

運行結果：

6、list（列表）類型：增刪改查、排序

import redis.clients.jedis.Jedis;
import redis.clients.jedis.SortingParams;

public class RedisListTest {
    public static void main(String[] args) {
        Jedis jedis = RedisUtil.connectRedis("localhost");
        // 清楚列表中所有數據
        jedis.del("listTest");
        // 增加
        jedis.lpush("listTest", "1");
        jedis.lpush("listTest", "java");
        jedis.lpush("listTest", "2");
        jedis.lpush("listTest", "java");
        jedis.lpush("listTest", "3");
        jedis.lpush("listTest", "4");
        jedis.lpush("listTest", "java");
        jedis.lpush("listTest", "redis");
        // 查詢,-1表示所有，注意查詢出來的元素和插入順序是相反的
        System.out.println("查詢所有元素：" + jedis.lrange("listTest", 0, -1));
        // 獲取指定座標的值
        System.out.println("獲取指定座標的值：" + jedis.lindex("listTest", 2));
        // 出棧
        jedis.lpop("listTest");
        System.out.println("出棧後，查詢所有元素：" + jedis.lrange("listTest", 0, -1));
        // 刪除
        // 刪除指定元素，第二個參數爲刪除個數（有重複元素），後添加的元素先被刪除
        jedis.lrem("listTest", 2, "java");
        System.out.println("刪除指定元素後，查詢所有元素：" + jedis.lrange("listTest", 0, -1));
        // 刪除某一範圍以外的數據
        jedis.ltrim("listTest", 0, 3);
        System.out.println("刪除某一範圍以外元素後，查詢所有元素：" + jedis.lrange("listTest", 0, -1));
        // 修改指定座標數據
        jedis.lset("listTest", 1, "jedis");
        System.out.println("修改後，查詢所有元素：" + jedis.lrange("listTest", 0, -1));
        // 排序，存在字母必須使用SortingParams，若爲純數字可直接使用sort
        SortingParams sortingParameters = new SortingParams();
        // 按字母排序
        sortingParameters.alpha();
        // 對某一範圍排序
        sortingParameters.limit(0, 4);
        System.out.println("排序後，查詢所有元素："+ jedis.sort("listTest",sortingParameters));
        // 其他查詢
        System.out.println("指定list的長度：" + jedis.llen("listTest"));
    }
}

運行結果：

7、set（集合）類型：增刪改查

import redis.clients.jedis.Jedis;

public class RedisSetTest {
    public static void main(String[] args) {
        Jedis jedis = RedisUtil.connectRedis("localhost");
        // 增加
        jedis.sadd("setTest", "1");
        jedis.sadd("setTest", "java");
        jedis.sadd("setTest", "2");
        // 重複元素不會出現兩次
        jedis.sadd("setTest", "java");
        // 查詢
        System.out.println("查詢所有元素：" + jedis.smembers("setTest"));
        // 刪除
        jedis.srem("setTest", "1");
        System.out.println("刪除後，查詢所有元素：" + jedis.smembers("setTest"));

        // 交併差
        jedis.sadd("setTest2", "2", "3");
        System.out.println("查詢第二個集合所有元素：" + jedis.smembers("setTest2"));
        System.out.println("兩集合的交集" + jedis.sinter("setTest", "setTest2"));
        System.out.println("兩集合的並集" + jedis.sunion("setTest", "setTest2"));
        // setTest中有，setTest2中沒有的元素
        System.out.println("兩集合的差集" + jedis.sdiff("setTest", "setTest2"));
    }
}

運行結果：

8、sorted set(有序集合)：增刪改查

public class RedisSortedSetTest {
    public static void main(String[] args) {
        Jedis jedis = RedisUtil.connectRedis("localhost");
        // 增加
        jedis.zadd("sortedSetTest", 3.1, "key1");
        jedis.zadd("sortedSetTest", 7.0, "key2");
        jedis.zadd("sortedSetTest", 5.5, "key3");
        jedis.zadd("sortedSetTest", 1.0, "key4");
        // 按權重值進行排序
        System.out.println("查詢所有元素：" + jedis.zrange("sortedSetTest", 0, -1));
        // 刪除
        jedis.zrem("sortedSetTest", "key1");
        System.out.println("刪除後，查詢所有元素：" + jedis.zrange("sortedSetTest", 0, -1));
        // 其他查詢
        System.out.println("查詢集合中的元素中個數：" + jedis.zcard("sortedSetTest"));
        System.out.println("查詢集合中權重某個範圍內（1.0——5.0），元素的個數：" + jedis.zcount("sortedSetTest", 1.0, 5.0));
        System.out.println("查看集合中指定元素的權重：" + jedis.zscore("sortedSetTest", "key4"));
    }
}

運行結果：

三、RedisTemplate的配置及使用

1、RedisTemplate和Jedis優缺點比較

Jedis的不足：
（1）connection管理缺乏自動化；
（2）數據操作需要關注“序列化”/“反序列化”，因爲jedis只接收String和byte數據類型，對於json、xml、pojo等結構化數據類型需要額外的支持；
（3）事務操作純粹硬編碼；
（4）對於pub/sub功能，缺乏必要的設計模式支持。對於開發者而言，需要關注的太多。
RedisTemplate的優點：
（1）RedisTemplate高度封裝，連接池自動管理；
（2）對jedis客戶端中大量api進行了封裝，將同一類型操作封裝爲operation接口（ValueOperations-簡單K-V操作、HashOperations、ListOperations、SetOperations、ZSetOperations）；
（3）提供了對key的bound便捷化操作API；
（4）將事務操作封裝，由容器控制；
（5）針對數據的“序列化和反序列化”提供了多種可選擇測量（JdkSerializationRedisSerializer、StringRedisSerializer、JacksonJsonRedisSerializer、OxmSerializer）。也可自定義類進行序列化和反序列化。
（6）基於設計模式和JMS開發思路，將pub/sub的API設計進行了封裝，使開發更加便捷。

2、添加依賴

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.8.10.RELEASE</version>
</dependency>

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>compile</scope>
</dependency>

3、redis屬性配置

resources目錄下創建redis.properties

#ip地址
redis.hostName=127.0.0.1
#端口號
redis.port=6379
#如果有密碼
redis.password=
#客戶端超時時間單位是毫秒 默認是2000
redis.timeout=2000

#最大空閒數
redis.maxIdle=10
#連接池的最大數據庫連接數。設爲0表示無限制,如果是jedis 2.4以後用redis.maxTotal
redis.maxActive=10
#控制一個pool可分配多少個jedis實例,用來替換上面的redis.maxActive,如果是jedis 2.4以後用該屬性
redis.maxTotal=10
#最大建立連接等待時間。如果超過此時間將接到異常。設爲-1表示無限制。
redis.maxWaitMillis=1000
#連接的最小空閒時間 默認1800000毫秒(30分鐘)
redis.minEvictableIdleTimeMillis=300000
#每次釋放連接的最大數目,默認3
redis.numTestsPerEvictionRun=1024
#逐出掃描的時間間隔(毫秒) 如果爲負數,則不運行逐出線程, 默認-1
redis.timeBetweenEvictionRunsMillis=30000
#是否在從池中取出連接前進行檢驗,如果檢驗失敗,則從池中去除連接並嘗試取出另一個
redis.testOnBorrow=false
#在空閒時檢查有效性, 默認false
redis.testWhileIdle=false

4、工具類

封裝RedisTemplate，便於更方便使用。
本部分過長，爲便於閱讀，放於文末附錄。

5、配置類

使用JavaConfig的方式來配置，主要是三個Bean，讀取配置文件設置各種參數的RedisConnectionFactory以及預期的RedisTemplate和RedisUtil。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.jcache.config.JCacheConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@PropertySource("classpath:redis.properties")
public class RedisConfig extends JCacheConfigurerSupport {
    @Autowired
    private Environment environment;

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        JedisConnectionFactory fac = new JedisConnectionFactory();
        fac.setHostName(environment.getProperty("redis.hostName"));
        fac.setPort(Integer.parseInt(environment.getProperty("redis.port")));
        fac.setPassword(environment.getProperty("redis.password"));
        fac.setTimeout(Integer.parseInt(environment.getProperty("redis.timeout")));
        fac.getPoolConfig().setMaxIdle(Integer.parseInt(environment.getProperty("redis.maxIdle")));
        fac.getPoolConfig().setMaxTotal(Integer.parseInt(environment.getProperty("redis.maxTotal")));
        fac.getPoolConfig().setMaxWaitMillis(Integer.parseInt(environment.getProperty("redis.maxWaitMillis")));
        fac.getPoolConfig().setMinEvictableIdleTimeMillis(
                Integer.parseInt(environment.getProperty("redis.minEvictableIdleTimeMillis")));
        fac.getPoolConfig()
                .setNumTestsPerEvictionRun(Integer.parseInt(environment.getProperty("redis.numTestsPerEvictionRun")));
        fac.getPoolConfig().setTimeBetweenEvictionRunsMillis(
                Integer.parseInt(environment.getProperty("redis.timeBetweenEvictionRunsMillis")));
        fac.getPoolConfig().setTestOnBorrow(Boolean.parseBoolean(environment.getProperty("redis.testOnBorrow")));
        fac.getPoolConfig().setTestWhileIdle(Boolean.parseBoolean(environment.getProperty("redis.testWhileIdle")));
        return fac;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();
        redis.setConnectionFactory(redisConnectionFactory);
        redis.afterPropertiesSet();
        return redis;
    }

    @Bean
    public RedisUtil redisUtil() {
        return new RedisUtil();
    }
}

6、測試類

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.HashMap;
import java.util.Map;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisConfig.class})
public class RedisTest {
    @Autowired
    private RedisUtil redisUtil;

    @Test
    public void test() {
        Map<String, Object> hashMap = new HashMap<String, Object>();
        hashMap.put("123", "hello");
        hashMap.put("abc", "456");

        redisUtil.hmset("hashTT", hashMap);
        System.out.println(redisUtil.hmget("hashTT"));

        redisUtil.set("a","123");
        System.out.println(redisUtil.get("a"));
    }
}

運行結果：

redis數據庫中顯示：


可以看到是有前綴的，這就意味着使用redis命令：get hashTT是獲取不到內容的，如圖

爲解決存在前綴的問題，就要解決序列化問題。

7、序列化問題

追溯源碼，hash在存入redis時使用putAll()方法，而putAll調用了rawKey()方法。

觀察rawKey()方法的源碼，可以看到並不是直接返回想要的key.getBytes()，而是調用了this.keySerializer().serialize(key)，

而在RedisTemplate的afterPropertiesSet()源碼中默認的序列化方式（defaultSerializer）是JdkSerializationRedisSerializer。

因此需要在配置類中進行設置，可以使用StringRedisSerializer類，但是該類的序列化方法只接收String類型，如果hashTT中存入了Integer的值（hashMap.put(“Integer”, 555);），會報錯。


因此可以仿照StringRedisSerializer重寫一個序列化類，

import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException; 
import org.springframework.util.Assert;

import java.nio.charset.Charset;

public class RedisSerializerUtil implements RedisSerializer<Object> {
    private final Charset charset;

    public RedisSerializerUtil() {
        this(Charset.forName("UTF8"));
    }

    public RedisSerializerUtil(Charset charset) {
        Assert.notNull(charset, "Charset must not be null!");
        this.charset = charset;
    }

    @Override
    public byte[] serialize(Object object) throws SerializationException {
        return object == null ? null : String.valueOf(object).getBytes(charset);
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        return bytes == null ? null : new String(bytes, this.charset);
    }
}

然後設置序列化方式，

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();
    redis.setConnectionFactory(redisConnectionFactory);
    redis.afterPropertiesSet();

    // 設置redis的String/Value的默認序列化方式
    RedisSerializerUtil redisSerializerUtil = new RedisSerializerUtil();
    redis.setKeySerializer(redisSerializerUtil);
    redis.setHashKeySerializer(redisSerializerUtil);
    redis.setValueSerializer(redisSerializerUtil);
    redis.setHashValueSerializer(redisSerializerUtil);
    return redis;
}

在測試類中加入

hashMap.put("Integer", 555);

運行結果：

命令行查詢：

附錄：RedisTemplate的工具類RedisUtil

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * 基於spring和redis的redisTemplate工具類
 * 針對所有的hash 都是以h開頭的方法
 * 針對所有的Set 都是以s開頭的方法                    不含通用方法
 * 針對所有的List 都是以l開頭的方法
 * 引用自how2java網站
 */
@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    //=============================common============================
    /**
     * 指定緩存失效時間
     * @param key 鍵
     * @param time 時間(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根據key 獲取過期時間
     * @param key 鍵 不能爲null
     * @return 時間(秒) 返回0代表爲永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判斷key是否存在
     * @param key 鍵
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 刪除緩存
     * @param key 可以傳一個值 或多個
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================
    /**
     * 普通緩存獲取
     * @param key 鍵
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通緩存放入
     * @param key 鍵
     * @param value 值
     * @return true成功 false失敗
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通緩存放入並設置時間
     * @param key 鍵
     * @param value 值
     * @param time 時間(秒) time要大於0 如果time小於等於0 將設置無限期
     * @return true成功 false 失敗
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 遞增
     * @param key 鍵
     * @param delta 要增加幾(大於0)
     * @return
     */
    public long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("遞增因子必須大於0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 遞減
     * @param key 鍵
     * @param delta 要減少幾(小於0)
     * @return
     */
    public long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("遞減因子必須大於0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================
    /**
     * HashGet
     * @param key 鍵 不能爲null
     * @param item 項 不能爲null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 獲取hashKey對應的所有鍵值
     * @param key 鍵
     * @return 對應的多個鍵值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 鍵
     * @param map 對應多個鍵值
     * @return true 成功 false 失敗
     */
    public boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 並設置時間
     * @param key 鍵
     * @param map 對應多個鍵值
     * @param time 時間(秒)
     * @return true成功 false失敗
     */
    public boolean hmset(String key, Map<String,Object> map, long time){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一張hash表中放入數據,如果不存在將創建
     * @param key 鍵
     * @param item 項
     * @param value 值
     * @return true 成功 false失敗
     */
    public boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一張hash表中放入數據,如果不存在將創建
     * @param key 鍵
     * @param item 項
     * @param value 值
     * @param time 時間(秒)  注意:如果已存在的hash表有時間,這裏將會替換原有的時間
     * @return true 成功 false失敗
     */
    public boolean hset(String key,String item,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 刪除hash表中的值
     * @param key 鍵 不能爲null
     * @param item 項 可以使多個 不能爲null
     */
    public void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判斷hash表中是否有該項的值
     * @param key 鍵 不能爲null
     * @param item 項 不能爲null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash遞增 如果不存在,就會創建一個 並把新增後的值返回
     * @param key 鍵
     * @param item 項
     * @param by 要增加幾(大於0)
     * @return
     */
    public double hincr(String key, String item, double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash遞減
     * @param key 鍵
     * @param item 項
     * @param by 要減少記(小於0)
     * @return
     */
    public double hdecr(String key, String item, double by){
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

    //============================set=============================
    /**
     * 根據key獲取Set中的所有值
     * @param key 鍵
     * @return
     */
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根據value從一個set中查詢,是否存在
     * @param key 鍵
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將數據放入set緩存
     * @param key 鍵
     * @param values 值 可以是多個
     * @return 成功個數
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 將set數據放入緩存
     * @param key 鍵
     * @param time 時間(秒)
     * @param values 值 可以是多個
     * @return 成功個數
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 獲取set緩存的長度
     * @param key 鍵
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值爲value的
     * @param key 鍵
     * @param values 值 可以是多個
     * @return 移除的個數
     */
    public long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================

    /**
     * 獲取list緩存的內容
     * @param key 鍵
     * @param start 開始
     * @param end 結束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key,long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 獲取list緩存的長度
     * @param key 鍵
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通過索引 獲取list中的值
     * @param key 鍵
     * @param index 索引  index>=0時， 0 表頭，1 第二個元素，依次類推；index<0時，-1，表尾，-2倒數第二個元素，依次類推
     * @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 將list放入緩存
     * @param key 鍵
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將list放入緩存
     * @param key 鍵
     * @param value 值
     * @param time 時間(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將list放入緩存
     * @param key 鍵
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 將list放入緩存
     * @param key 鍵
     * @param value 值
     * @param time 時間(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根據索引修改list中的某條數據
     * @param key 鍵
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N個值爲value
     * @param key 鍵
     * @param count 移除多少個
     * @param value 值
     * @return 移除的個數
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
}