java通過redis+lua腳本執行完成原子操作的業務

最近開發新代碼的時候發現有好多同學，開始考慮redis的原子操作執行了，實際的業務場景：比如指定發放優惠劵；redis的秒殺活動等。

今天我根據實際的開發業務，咱們寫一個指定發送優惠劵的邏輯。並發其實支持 jmeter測試並不好、

 

1.先來一個生產key的代碼

package com.hbg.common.constants;

/**
 * 緩存key管理類
 *
 * @author huojg
 */
public class RedisKeyConstant {

    public static final String ROOT = "hbg:";

    public static final String ROOT_VALUE = "hbg";

    public static final String SPRING_CACHE_ROOT = "hbg::";

    /**
     * 通用 獲取Key
     *
     * @param key
     * @param args
     * @return
     */
    public static String getKey(String key, Object... args) {
        if (args != null && args.length > 0) {
            return ROOT + String.format(key, args);
        }
        return ROOT + key;
    }

    public static String getSpringCachedKey(String key, Object... args) {
        if (args != null && args.length > 0) {
            return SPRING_CACHE_ROOT + String.format(key, args);
        }
        return SPRING_CACHE_ROOT + key;
    }

    public static String annoCachedKey(String key, Object... args) {
        if (args != null && args.length > 0) {
            return String.format(key, args);
        }
        return key;
    }

    /**
     * 系統配置緩存key,展位填充，%s = 組名
     */
    public static final String SYSTEM_CONFIG = "system.config:%s";

    /**
     * 頭部Banner配置緩存key ：banner位置
     */
    public static final String BANNER = "banner";

    /**
     * 售后前置標記key
     */
    public static final String AFTER_SALE = "after:sale:";

    /**
     * 優惠券
     */
    public static final String CARD = "cardVoucher:id:%s";

    public static final String COUPON_GET_TYPE = "cardVoucher:getType:id:%s";

    public static final String USER_GET_NUM = "coupon:userId:%s:couponId:%s";
    /**
     * 購買，按規格粒度 加鎖; %s = skuId
     * 適用於非活動購買
     */
    public static final String SKU_STOCK_LOCK = "stock:lock:skuId:%s";

    /**
     * 直播廣告
     */
    public static final String LIVE = "live.id:%s";

    /**
     * 購物車 鎖標識 用戶Id + skuId
     */
    public static final String SHOPPING_CART_LOCK = "shoppingCart:userId:%s:skuId:%s";

    /**
     * 商品庫存
     */
    public static final String SKU_STOCK = "stock:skuId:%s";

    /**
     * 商品統計鎖
     */
    public static final String GOODS_STATISTIC_STOCK_LOCK = "goods.statistic.goodsId:%s";

    /**
     * 訂單發貨消息
     */
    public static final String ORDER_DELIVER_MESSAGE = "order:deliver:message:%s";

    /**
     * 商品詳情緩存
     */
    public static final String GOODS_DETAIL = "goods:detail:Id:%s";

    /**
     * 商品詳情緩存
     */
    public static final String GOODS_PROFIT_CONFIG = "goods:profit:config:Id:%s";

    /**
     * 商品詳情緩存
     */
    public static final String ACT_GOODS_DETAIL = "act:goods:detail:Id:%s";
}

2.再來lua腳本

couponRedis.lua

--庫存
local stock=KEYS[1]
local stockValue=redis.call('GET',stock)
--限領次數
local num=KEYS[2]
local numValue=redis.call('GET',num)
--領取次數
local getNum=KEYS[3]
local getNumValue=redis.call('GET',getNum)


if stockValue then
--庫存是否小於0
    if tonumber(stockValue)<=0 then
    return 0
    end
    --是否限領
    if numValue then
     --redis.log(redis.LOG_DEBUG,'2222')
     --是否領取過
      if getNumValue then
      --是否超出限領
        if tonumber(getNumValue) >= tonumber(numValue) then
        --redis.log(redis.LOG_DEBUG,'33333')
        return 0
        end
      --redis.log(redis.LOG_DEBUG,'666666')
      redis.call('set',getNum,tonumber(getNumValue)+1)
      redis.call('SET',stock,tonumber(stockValue)-1)
      return 1
      end
      --redis.log(redis.LOG_DEBUG,'44444')
      redis.call('set',getNum,1)
      redis.call('SET',stock,tonumber(stockValue)-1)
     return 1
     end
   --redis.log(redis.LOG_DEBUG,'11111')
   redis.call('SET',stock,tonumber(stockValue)-1)
  return 1
end

3.執行java代碼調用：

 public boolean getCardVoucher(UserGetCouponsRequest baseRequest, Long userId) {

        // 執行 lua 腳本
        DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>();
        // 指定返回類型
        redisScript.setResultType(Boolean.class);
        // 指定 lua 腳本
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("couponRedis.lua")));


        List<String> list=new ArrayList<>();
        list.add(RedisKeyConstant.getKey(RedisKeyConstant.CARD, baseRequest.getCardId()));
        list.add(RedisKeyConstant.getKey(RedisKeyConstant.COUPON_GET_TYPE, baseRequest.getCardId()));
        list.add(RedisKeyConstant.getKey(RedisKeyConstant.USER_GET_NUM, baseRequest.getUserId(),baseRequest.getCardId()) );

        // 參數一：redisScript，參數二：key列表，參數三：arg（可多個）
        Boolean result = redisTemplate.execute(redisScript, list);
        log.info("結果："+result);
        if(result){
            getCoupon(baseRequest,userId);
        }
        else {
            throw BusinessExceptionFactory.create(BusinessErrorEnum.SERVER_IS_BUSY);
        }

4.在給你們加上依賴包

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

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.11.0</version>
</dependency>

<!-- 使用spring cache -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- redis -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

RedisTemplate<String, String> redisTemplate;

 

總結： 上面就是基本的通過lua腳本執行redis命令，來完成java業務代碼，java通過script加載引擎的模式引用lua文件。保證執行的redis命令都在一個lua腳本中，保證中執行的一個原子性。

 

注意：好多同學看不懂lua腳本的語法，解釋如下

local 標識 當前變量全局

KEYS[?] 這是我們redis要設置的key，默認是從1開始

redis.call('GET',getNum) 通過語法函數。命令

'GET' 獲取當前key的值。跟redis直接獲取key 一樣一樣的。

重點：
if條件
lua腳本的語法： if ...  then ... end

簡單理解就是，如果 if 后面的語句是true 就執行 then后面的語句。end就是結束符
我的理解 把 then ...end   理解成java的 if（）形式就ok


關於lua語法結構和使用，包括。變量定於，if條件。for條件，結束語
跟學習java的語法結構相差不多，同學們自行找資源學習。


最后給同學們一點好東西

package com.hbg.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.Codec;
import org.redisson.client.codec.JsonJacksonMapCodec;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@Slf4j
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Value("${database:0}")
    private Integer database;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.block-when-exhausted}")
    private boolean  blockWhenExhausted;

    @Bean
    public JedisPool redisPoolFactory() {
        log.info("JedisPool注入成功！！");
        log.info("redis地址：" + host + ":" + port);
        log.info("timeout:"+timeout);
        log.info("maxIdle:"+maxIdle);
        log.info("maxWaitMillis:"+maxWaitMillis);
        log.info("blockWhenExhausted:"+blockWhenExhausted);
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        // 連接耗盡時是否阻塞, false報異常,ture阻塞直到超時, 默認true
        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);
        // 是否啟用pool的jmx管理功能, 默認true
        jedisPoolConfig.setJmxEnabled(true);
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
        log.info("jedisPool:"+jedisPool);
        return jedisPool;
    }

    @Bean
    public RedissonClient redissonClient() {

        ObjectMapper mapper = Jackson2ObjectMapperBuilder.json()
                .featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
                .modules(new JavaTimeModule())
                .build();
        Codec codec = new JsonJacksonCodec(mapper);
        Config config = new Config();
        config.setCodec(codec);
        config.useSingleServer()
                .setAddress("redis://" + host + ":" + port)
                .setPassword(password)
                .setDatabase(database == null ? 0 : database)
                .setTimeout(5000)
                .setSubscriptionConnectionMinimumIdleSize(1)
                .setSubscriptionConnectionPoolSize(256)
                .setConnectTimeout(30000)
                .setConnectionPoolSize(256)
                .setConnectionMinimumIdleSize(1)
                .setRetryAttempts(3)
                .setRetryInterval(3000)
                .setIdleConnectionTimeout(30000)
                .setClientName("com.nuonuo.accounting.redisclient");

        return Redisson.create(config);
    }


    /**
     * 引入RedisTemplate
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);

        //json轉對象類，不設置默認的會將json轉成hashmap
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        om.registerModule(new JavaTimeModule());
        om.configure(MapperFeature.USE_ANNOTATIONS, false);
        om.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        om.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        // 此項必須配置，否則會報java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to XXX
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        //使用Jackson 2，將對象序列化為JSON
        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(om);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

        // 設置key,value的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

}

注入redis 和redisson 的工具conf類

RedissonUtil

package com.hbg.common.cache;

import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.redisson.RedissonMultiLock;
import org.redisson.api.*;
import org.redisson.client.codec.Codec;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class RedissonUtil {

    /**
     * 默認緩存時間
     */
    private static final Long DEFAULT_EXPIRED = 5 * 60L;
    /**
     * redisson client對象
     */
    private final RedissonClient redisson;

    public RedissonUtil(RedissonClient redisson) {
        this.redisson = redisson;
    }

    /**
     * 讀取緩存
     *
     * @param key 緩存key
     * @param <V>
     * @return 緩存返回值
     */
    public <V> V get(String key) {
        try {
            RBucket<V> bucket = redisson.getBucket(key);
            return bucket.get();
        } catch (Exception e) {
            this.remove(key);
        }
        return null;
    }


    /**
     * 讀取緩存
     *
     * @param key 緩存key
     * @param <V>
     * @param codec value編碼解碼方式
     * @return 緩存返回值
     * @like https://yq.aliyun.com/articles/551642/
     */
    public <V> V get(String key, Codec codec) {
        RBucket<V> bucket = redisson.getBucket(key, codec);
        return bucket.get();
    }


    /**
     * rmap中獲取
     */
    public <K, V>V get(String key, String hashKey, Codec codec) {
        RMap<K, V> map = redisson.getMap(key, codec);
        return map.get(hashKey);
    }


    /**
     * rmap中獲取
     */
    public <K, V>V get(String key, String hashKey) {
        RMap<K, V> map = redisson.getMap(key);
        return map.get(hashKey);
    }


    /**
     * rmap中設置值
     */
    public <K, V>V put(String key, K hashKey, V v) {
        RMap<K, V> map = redisson.getMap(key);
        return map.put(hashKey,v);
    }

    /**
     * rmap中設置值
     */
    public <K, V>V put(String key, K hashKey, V v, Codec codec) {
        RMap<K, V> map = redisson.getMap(key, codec);
        return map.put(hashKey,v);
    }

    /**
     * 設置緩存
     *
     * @param key   緩存key
     * @param value 緩存值
     * @param <V>
     */
    public <V> void set(String key, V value) {
        RBucket<V> bucket = redisson.getBucket(key);
        bucket.set(value, DEFAULT_EXPIRED, TimeUnit.SECONDS);
    }

    /**
     * 獲取set格式的緩存
     *
     * @param key 緩存key
     * @return
     */
    public <V> RSet<V> getRSet(String key) {
        return redisson.getSet(key);
    }

    /**
     * 獲取set格式的緩存
     *
     * @param key   緩存key
     * @return
     */
    public <V> Set<V> getSets(String key) {
        return getRSet(key);
    }

    /**
     * 設置緩存,不設置過期時間
     *
     * @param key   緩存key
     * @param value 緩存值
     * @param <V>
     */
    public <V> void getAndSet(String key, V value) {
        RBucket<V> bucket = redisson.getBucket(key);
        bucket.set(value);
    }

    /**
     * 設置緩存
     *
     * @param key     緩存key
     * @param value   緩存值
     * @param expired 緩存過期時間
     * @param <V>     類型
     */
    public <V> void set(String key, V value, long expired) {
        RBucket<V> bucket = redisson.getBucket(key);
        bucket.set(value, expired <= 0 ? DEFAULT_EXPIRED : expired, TimeUnit.SECONDS);
    }

    /**
     * 移除緩存
     *
     * @param key
     */
    public void remove(String key) {
        redisson.getBucket(key).delete();
    }


    /**
     * 移除緩存,map
     *
     * @param key
     */
    public void remove(String key, String hashKey) {
        redisson.getMap(key).remove(hashKey);
    }



    /**
     * 設置過期時間
     *
     * @param key
     */
    public void expire(String key) {
        redisson.getBucket(key).expire(10, TimeUnit.SECONDS);
    }
    
   /**
    * 自定義設置設置過期時間
    * @param key
    * @param time
    * @param timeType
    */
    public void expire(String key,long time,TimeUnit timeType) {
        redisson.getBucket(key).expire(time, timeType);
    }

    /**
     * 判斷緩存是否存在
     *
     * @param key
     * @return
     */
    public boolean exists(String key) {
        return redisson.getBucket(key).isExists();
    }

    /**
     * 判斷緩存是否存在 針對hash數據結構
     *
     * @param key
     * @return
     */
    public boolean exists(String key, String hashKey) {
        return redisson.getMap(key).containsKey(hashKey);
    }

    /**
     * 暴露redisson的RList對象
     *
     * @param key
     * @param <T>
     * @return
     */
    public <T> RList<T> getRList(String key) {
        return redisson.getList(key);
    }

    /**
     * 暴露redisson的List結果
     *
     * @param key
     * @param <T>
     * @return
     */
    public <T> List<T> getLists(String key) {
        return getRList(key);
    }


    /**
     * 暴露redisson的RMap對象
     *
     * @param key
     * @param <K, V>
     * @return
     */
    public <K, V> RMap<K, V> getRMap(String key) {
        return redisson.getMap(key);
    }

    /**
     * 暴露redisson的Lock對象
     *
     * @param key
     * @return
     */
    public RLock getRedisLock(String key) {
        return redisson.getLock(key);
    }

    /**
     * 暴露redisson的連鎖 RedissonMultiLock對象
     *
     * @param locks
     * @return
     */
    public RedissonMultiLock getMultiLock(RLock... locks) {
        return new RedissonMultiLock(locks);
    }


    /**
     *  原子的獲取某個key遞增后的值
     * @param key key
     * @return 更新后的值
     */
    public long incrementAndGet(String key){
        RAtomicLong rAtomicLong = redisson.getAtomicLong(key);
        return rAtomicLong.incrementAndGet();
    }

    /**
     *  原子的獲取某個key遞增后的值
     * @param key key
     * @return 更新后的值
     */
    public long addAndGet(String key, long value){
        RAtomicLong rAtomicLong = redisson.getAtomicLong(key);
        return rAtomicLong.addAndGet(value);
    }

    public void setRAtomicLong(String key, long value) {
        RAtomicLong rAtomicLong = redisson.getAtomicLong(key);
        rAtomicLong.set(value);
    }

    public RAtomicLong getRAtomicLong(String key) {
        RAtomicLong atomicLong = redisson.getAtomicLong(key);
        return atomicLong;
    }

    /**
     * 初始化原子long 0
     * @param key
     */
    public void atomicSetZero(String key) {
        RAtomicLong rAtomicLong = redisson.getAtomicLong(key);
        rAtomicLong.set(0);
        rAtomicLong.expire(DEFAULT_EXPIRED, TimeUnit.SECONDS);
    }


    @PreDestroy
    public void close() {
        try {
            if (redisson != null) {
                redisson.shutdown();
            }
        } catch (Exception ex) {
            log.error(StrUtil.EMPTY, "RedissonUtil.close", ex);
        }
    }


}

RedisCache：

package com.hbg.common.cache;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.ListPosition;
import redis.clients.jedis.SortingParams;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.List;
import java.util.Map;
import java.util.Set;


/**
 * redis 緩存
 *
 * @author cyx
 */

@Component
@Slf4j
public class RedisCache {
    @Autowired
    private JedisPool jedisPool;

    //選擇redis庫 0-15   默認是0
    private int indexdb = 0;

    public int getIndexdb() {
        return indexdb;
    }

    public void setIndexdb(int indexdb) {
        this.indexdb = indexdb;
    }

    /**
     * <p>
     * 通過key獲取儲存在redis中的value
     * </p>
     * <p>
     * 並釋放連接
     * </p>
     *
     * @param key
     * @return 成功返回value 失敗返回null
     */
    public String getStringValue(String key) {
        Jedis jedis = null;
        String value = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            value = jedis.get(key);
            log.info(value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return value;
    }

    /**
     * <p>
     * 通過key獲取儲存在redis中的value
     * </p>
     * <p>
     * 並釋放連接
     * </p>
     *
     * @param key
     * @return 成功返回value 失敗返回null
     */
    public Object getObjectValue(String key) {
        Jedis jedis = null;
        Object obj = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            byte[] bytes = jedis.get(key.getBytes());
            if (bytes != null && bytes.length > 0) {
                obj = unserialize(bytes);
            }
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return obj;
    }

    public <T> T getObject(String key) {
        Jedis jedis = null;
        Object obj = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            byte[] bytes = jedis.get(key.getBytes());
            if (bytes != null && bytes.length > 0) {
                obj = unserialize(bytes);
            }
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return (T) obj;
    }

    /**
     * <p>
     * 通過key獲取儲存在redis中的value
     * </p>
     * <p>
     * 並釋放連接
     * </p>
     *
     * @param key
     * @return 成功返回value 失敗返回null
     */
    public byte[] get(byte[] key) {
        Jedis jedis = null;
        byte[] value = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            value = jedis.get(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return value;
    }

    /**
     * <p>
     * 向redis存入key和value,並釋放連接資源
     * </p>
     * <p>
     * 如果key已經存在 則覆蓋
     * </p>
     *
     * @param key
     * @param value
     * @param seconds 存活時間  秒
     * @return 成功 返回OK 失敗返回 0
     */
    public String setStringValue(String key, String value, int seconds) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            return jedis.setex(key, seconds, value);
        } catch (Exception e) {

            log.error(e.getMessage());
            return "0";
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 向redis存入key和value,並釋放連接資源
     * </p>
     * <p>
     * 如果key已經存在 則覆蓋
     * </p>
     *
     * @param key
     * @param value
     * @param seconds 存活時間  秒
     * @return 成功 返回OK 失敗返回 0
     */
    public String setObjectValue(String key, Object value, int seconds) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            return jedis.setex(key.getBytes(), seconds, ObjTOSerialize(value));
        } catch (Exception e) {

            log.error(e.getMessage());
            return "0";
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 向redis存入key和value,並釋放連接資源
     * </p>
     * <p>
     * 如果key已經存在 則覆蓋
     * </p>
     *
     * @param key
     * @param value
     * @return 成功 返回OK 失敗返回 0
     */
    public String set(byte[] key, byte[] value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            return jedis.set(key, value);
        } catch (Exception e) {
            log.error(e.getMessage());
            return "0";
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 刪除指定的key,也可以傳入一個包含key的數組
     * </p>
     *
     * @param keys 一個key 也可以使 string 數組
     * @return 返回刪除成功的個數
     */
    public Long del(String... keys) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.del(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 刪除指定的key,也可以傳入一個包含key的數組
     * </p>
     *
     * @param keys 一個key 也可以使 string 數組
     * @return 返回刪除成功的個數
     */
    public Long delete(String... keys) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            return jedis.del(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 刪除指定的key,也可以傳入一個包含key的數組
     * </p>
     *
     * @param keys 一個key 也可以使 string 數組
     * @return 返回刪除成功的個數
     */
    public Long delete(byte[]... keys) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            return jedis.del(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 通過key向指定的value值追加值
     * </p>
     *
     * @param key
     * @param str
     * @return 成功返回 添加后value的長度 失敗 返回 添加的 value 的長度 異常返回0L
     */
    public Long append(String key, String str) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.append(key, str);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 判斷key是否存在
     * </p>
     *
     * @param key
     * @return true OR false
     */
    public Boolean exists(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.exists(key);
        } catch (Exception e) {

            log.error(e.getMessage());
            return false;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 清空當前數據庫中的所有 key,此命令從不失敗。
     * </p>
     *
     * @return 總是返回 OK
     */
    public String flushDB() {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.flushDB();
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 為給定 key 設置生存時間，當 key 過期時(生存時間為 0 )，它會被自動刪除。
     * </p>
     *
     * @param key
     * @param value 過期時間，單位：秒
     * @return 成功返回1 如果存在 和 發生異常 返回 0
     */
    public Long expire(String key, int value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            return jedis.expire(key, value);
        } catch (Exception e) {
            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 以秒為單位，返回給定 key 的剩余生存時間
     * </p>
     *
     * @param key
     * @return 當 key 不存在時，返回 -2 。當 key 存在但沒有設置剩余生存時間時，返回 -1 。否則，以秒為單位，返回 key
     * 的剩余生存時間。 發生異常 返回 0
     */
    public Long ttl(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            Long ttl = jedis.ttl(key);
            if (ttl < 0L) {
                ttl = 0L;
            }
            return ttl;
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 移除給定 key 的生存時間，將這個 key 從『易失的』(帶生存時間 key )轉換成『持久的』(一個不帶生存時間、永不過期的 key )
     * </p>
     *
     * @param key
     * @return 當生存時間移除成功時，返回 1 .如果 key 不存在或 key 沒有設置生存時間，返回 0 ， 發生異常 返回 -1
     */
    public Long persist(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.persist(key);
        } catch (Exception e) {

            log.error(e.getMessage());
            return -1L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 新增key,並將 key 的生存時間 (以秒為單位)
     * </p>
     *
     * @param key
     * @param seconds 生存時間 單位：秒
     * @param value
     * @return 設置成功時返回 OK 。當 seconds 參數不合法時，返回一個錯誤。
     */
    public String setex(String key, int seconds, String value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.setex(key, seconds, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 設置key value,如果key已經存在則返回0,nx==> not exist
     * </p>
     *
     * @param key
     * @param value
     * @return 成功返回1 如果存在 和 發生異常 返回 0
     */
    public Long setnx(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.setnx(key, value);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 將給定 key 的值設為 value ，並返回 key 的舊值(old value)。
     * </p>
     * <p>
     * 當 key 存在但不是字符串類型時，返回一個錯誤。
     * </p>
     *
     * @param key
     * @param value
     * @return 返回給定 key 的舊值。當 key 沒有舊值時，也即是， key 不存在時，返回 nil
     */
    public String getSet(String key, String value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.getSet(key, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 設置key value並制定這個鍵值的有效期
     * </p>
     *
     * @param key
     * @param value
     * @param seconds 單位:秒
     * @return 成功返回OK 失敗和異常返回null
     */
    public String setex(String key, String value, int seconds) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.setex(key, seconds, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key 和offset 從指定的位置開始將原先value替換
     * </p>
     * <p>
     * 下標從0開始,offset表示從offset下標開始替換
     * </p>
     * <p>
     * 如果替換的字符串長度過小則會這樣
     * </p>
     * <p>
     * example:
     * </p>
     * <p>
     * value : [e-mail]
     * </p>
     * <p>
     * str : abc
     * </p>
     * <P>
     * 從下標7開始替換 則結果為
     * </p>
     * <p>
     * RES : bigsea.abc.cn
     * </p>
     *
     * @param key
     * @param str
     * @param offset 下標位置
     * @return 返回替換后 value 的長度
     */
    public Long setrange(String key, String str, int offset) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.setrange(key, offset, str);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }
    }

    /**
     * <p>
     * 通過批量的key獲取批量的value
     * </p>
     *
     * @param keys string數組 也可以是一個key
     * @return 成功返回value的集合, 失敗返回null的集合 ,異常返回空
     */
    public List<String> mget(String... keys) {
        Jedis jedis = null;
        List<String> values = null;
        try {
            jedis = jedisPool.getResource();
            values = jedis.mget(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return values;
    }

    /**
     * <p>
     * 批量的設置key:value,可以一個
     * </p>
     * <p>
     * example:
     * </p>
     * <p>
     * obj.mset(new String[]{"key2","value1","key2","value2"})
     * </p>
     *
     * @param keysvalues
     * @return 成功返回OK 失敗 異常 返回 null
     */
    public String mset(String... keysvalues) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.mset(keysvalues);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 批量的設置key:value,可以一個,如果key已經存在則會失敗,操作會回滾
     * </p>
     * <p>
     * example:
     * </p>
     * <p>
     * obj.msetnx(new String[]{"key2","value1","key2","value2"})
     * </p>
     *
     * @param keysvalues
     * @return 成功返回1 失敗返回0
     */
    public Long msetnx(String... keysvalues) {
        Jedis jedis = null;
        Long res = 0L;
        try {
            jedis = jedisPool.getResource();
            res = jedis.msetnx(keysvalues);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 設置key的值,並返回一個舊值
     * </p>
     *
     * @param key
     * @param value
     * @return 舊值 如果key不存在 則返回null
     */
    public String getset(String key, String value) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.getSet(key, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過下標 和key 獲取指定下標位置的 value
     * </p>
     *
     * @param key
     * @param startOffset 開始位置 從0 開始 負數表示從右邊開始截取
     * @param endOffset
     * @return 如果沒有返回null
     */
    public String getrange(String key, int startOffset, int endOffset) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.getrange(key, startOffset, endOffset);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key 對value進行加值+1操作,當value不是int類型時會返回錯誤,當key不存在是則value為1
     * </p>
     *
     * @param key
     * @return 加值后的結果
     */
    public Long incr(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.incr(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key給指定的value加值,如果key不存在,則這是value為該值
     * </p>
     *
     * @param key
     * @param integer
     * @return
     */
    public Long incrBy(String key, Long integer) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.incrBy(key, integer);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 對key的值做減減操作,如果key不存在,則設置key為-1
     * </p>
     *
     * @param key
     * @return
     */
    public Long decr(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.decr(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 減去指定的值
     * </p>
     *
     * @param key
     * @param integer
     * @return
     */
    public Long decrBy(String key, Long integer) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.decrBy(key, integer);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取value值的長度
     * </p>
     *
     * @param key
     * @return 失敗返回null
     */
    public Long serlen(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.strlen(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key給field設置指定的值,如果key不存在,則先創建
     * </p>
     *
     * @param key
     * @param field 字段
     * @param value
     * @return 如果存在返回0 異常返回null
     */
    public Long hset(String key, String field, String value) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hset(key, field, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key給field設置指定的值,如果key不存在則先創建,如果field已經存在,返回0
     * </p>
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hsetnx(String key, String field, String value) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hsetnx(key, field, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key同時設置 hash的多個field
     * </p>
     *
     * @param key
     * @param hash
     * @return 返回OK 異常返回null
     */
    public String hmset(String key, Map<String, String> hash) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.hmset(key, hash);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key 和 field 獲取指定的 value
     * </p>
     *
     * @param key
     * @param field
     * @return 沒有返回null
     */
    public String hget(String key, String field) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hget(key, field);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key 和 fields 獲取指定的value 如果沒有對應的value則返回null
     * </p>
     *
     * @param key
     * @param fields 可以使 一個String 也可以是 String數組
     * @return
     */
    public List<String> hmget(String key, String... fields) {
        Jedis jedis = null;
        List<String> res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.hmget(key, fields);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key給指定的field的value加上給定的值
     * </p>
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public Long hincrby(String key, String field, Long value) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hincrBy(key, field, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key和field判斷是否有指定的value存在
     * </p>
     *
     * @param key
     * @param field
     * @return
     */
    public Boolean hexists(String key, String field) {
        Jedis jedis = null;
        Boolean res = false;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hexists(key, field);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回field的數量
     * </p>
     *
     * @param key
     * @return
     */
    public Long hlen(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hlen(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;

    }

    /**
     * <p>
     * 通過key 刪除指定的 field
     * </p>
     *
     * @param key
     * @param fields 可以是 一個 field 也可以是 一個數組
     * @return
     */
    public Long hdel(String key, String... fields) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hdel(key, fields);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回所有的field
     * </p>
     *
     * @param key
     * @return
     */
    public Set<String> hkeys(String key) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hkeys(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回所有和key有關的value
     * </p>
     *
     * @param key
     * @return
     */
    public List<String> hvals(String key) {
        Jedis jedis = null;
        List<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.hvals(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取所有的field和value
     * </p>
     *
     * @param key
     * @return
     */
    public Map<String, String> hgetall(String key) {
        Jedis jedis = null;
        Map<String, String> res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.hgetAll(key);
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key向list頭部添加字符串
     * </p>
     *
     * @param key
     * @param strs 可以使一個string 也可以使string數組
     * @return 返回list的value個數
     */
    public Long lpush(String key, String... strs) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.lpush(key, strs);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key向list尾部添加字符串
     * </p>
     *
     * @param key
     * @param strs 可以使一個string 也可以使string數組
     * @return 返回list的value個數
     */
    public Long rpush(String key, String... strs) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.rpush(key, strs);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key在list指定的位置之前或者之后 添加字符串元素
     * </p>
     *
     * @param key
     * @param where LIST_POSITION枚舉類型
     * @param pivot list里面的value
     * @param value 添加的value
     * @return
     */
    public Long linsert(String key, ListPosition where, String pivot,
                        String value) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.linsert(key, where, pivot, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key設置list指定下標位置的value
     * </p>
     * <p>
     * 如果下標超過list里面value的個數則報錯
     * </p>
     *
     * @param key
     * @param index 從0開始
     * @param value
     * @return 成功返回OK
     */
    public String lset(String key, Long index, String value) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.lset(key, index, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key從對應的list中刪除指定的count個 和 value相同的元素
     * </p>
     *
     * @param key
     * @param count 當count為0時刪除全部
     * @param value
     * @return 返回被刪除的個數
     */
    public Long lrem(String key, long count, String value) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.lrem(key, count, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key保留list中從strat下標開始到end下標結束的value值
     * </p>
     *
     * @param key
     * @param start
     * @param end
     * @return 成功返回OK
     */
    public String ltrim(String key, long start, long end) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.ltrim(key, start, end);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key從list的頭部刪除一個value,並返回該value
     * </p>
     *
     * @param key
     * @return
     */
    synchronized public String lpop(String key) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.lpop(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key從list尾部刪除一個value,並返回該元素
     * </p>
     *
     * @param key
     * @return
     */
    synchronized public String rpop(String key) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.rpop(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key從一個list的尾部刪除一個value並添加到另一個list的頭部,並返回該value
     * </p>
     * <p>
     * 如果第一個list為空或者不存在則返回null
     * </p>
     *
     * @param srckey
     * @param dstkey
     * @return
     */
    public String rpoplpush(String srckey, String dstkey) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.rpoplpush(srckey, dstkey);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取list中指定下標位置的value
     * </p>
     *
     * @param key
     * @param index
     * @return 如果沒有返回null
     */
    public String lindex(String key, long index) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.lindex(key, index);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回list的長度
     * </p>
     *
     * @param key
     * @return
     */
    public Long llen(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.llen(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取list指定下標位置的value
     * </p>
     * <p>
     * 如果start 為 0 end 為 -1 則返回全部的list中的value
     * </p>
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<String> lrange(String key, long start, long end) {
        Jedis jedis = null;
        List<String> res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(indexdb);
            res = jedis.lrange(key, start, end);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 將列表 key 下標為 index 的元素的值設置為 value
     * </p>
     *
     * @param key
     * @param index
     * @param value
     * @return 操作成功返回 ok ，否則返回錯誤信息
     */
    public String lset(String key, long index, String value) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.lset(key, index, value);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 返回給定排序后的結果
     * </p>
     *
     * @param key
     * @param sortingParameters
     * @return 返回列表形式的排序結果
     */
    public List<String> sort(String key, SortingParams sortingParameters) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.sort(key, sortingParameters);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 返回排序后的結果，排序默認以數字作為對象，值被解釋為雙精度浮點數，然后進行比較。
     * </p>
     *
     * @param key
     * @return 返回列表形式的排序結果
     */
    public List<String> sort(String key) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.sort(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 通過key向指定的set中添加value
     * </p>
     *
     * @param key
     * @param members 可以是一個String 也可以是一個String數組
     * @return 添加成功的個數
     */
    public Long sadd(String key, String... members) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sadd(key, members);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key刪除set中對應的value值
     * </p>
     *
     * @param key
     * @param members 可以是一個String 也可以是一個String數組
     * @return 刪除的個數
     */
    public Long srem(String key, String... members) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.srem(key, members);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key隨機刪除一個set中的value並返回該值
     * </p>
     *
     * @param key
     * @return
     */
    public String spop(String key) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.spop(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取set中的差集
     * </p>
     * <p>
     * 以第一個set為標准
     * </p>
     *
     * @param keys 可以使一個string 則返回set中所有的value 也可以是string數組
     * @return
     */
    public Set<String> sdiff(String... keys) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sdiff(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取set中的差集並存入到另一個key中
     * </p>
     * <p>
     * 以第一個set為標准
     * </p>
     *
     * @param dstkey 差集存入的key
     * @param keys   可以使一個string 則返回set中所有的value 也可以是string數組
     * @return
     */
    public Long sdiffstore(String dstkey, String... keys) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sdiffstore(dstkey, keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取指定set中的交集
     * </p>
     *
     * @param keys 可以使一個string 也可以是一個string數組
     * @return
     */
    public Set<String> sinter(String... keys) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sinter(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取指定set中的交集 並將結果存入新的set中
     * </p>
     *
     * @param dstkey
     * @param keys   可以使一個string 也可以是一個string數組
     * @return
     */
    public Long sinterstore(String dstkey, String... keys) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sinterstore(dstkey, keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回所有set的並集
     * </p>
     *
     * @param keys 可以使一個string 也可以是一個string數組
     * @return
     */
    public Set<String> sunion(String... keys) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sunion(keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回所有set的並集,並存入到新的set中
     * </p>
     *
     * @param dstkey
     * @param keys   可以使一個string 也可以是一個string數組
     * @return
     */
    public Long sunionstore(String dstkey, String... keys) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sunionstore(dstkey, keys);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key將set中的value移除並添加到第二個set中
     * </p>
     *
     * @param srckey 需要移除的
     * @param dstkey 添加的
     * @param member set中的value
     * @return
     */
    public Long smove(String srckey, String dstkey, String member) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.smove(srckey, dstkey, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取set中value的個數
     * </p>
     *
     * @param key
     * @return
     */
    public Long scard(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.scard(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key判斷value是否是set中的元素
     * </p>
     *
     * @param key
     * @param member
     * @return
     */
    public Boolean sismember(String key, String member) {
        Jedis jedis = null;
        Boolean res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.sismember(key, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取set中隨機的value,不刪除元素
     * </p>
     *
     * @param key
     * @return
     */
    public String srandmember(String key) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.srandmember(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取set中所有的value
     * </p>
     *
     * @param key
     * @return
     */
    public Set<String> smembers(String key) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.smembers(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key向zset中添加value,score,其中score就是用來排序的
     * </p>
     * <p>
     * 如果該value已經存在則根據score更新元素
     * </p>
     *
     * @param key
     * @param score
     * @param member
     * @return
     */
    public Long zadd(String key, double score, String member) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zadd(key, score, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 返回有序集 key 中，指定區間內的成員。min=0,max=-1代表所有元素
     * </p>
     *
     * @param key
     * @param min
     * @param max
     * @return 指定區間內的有序集成員的列表。
     */
    public Set<String> zrange(String key, long min, long max) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.zrange(key, min, max);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return null;
    }

    /**
     * <p>
     * 統計有序集 key 中,值在 min 和 max 之間的成員的數量
     * </p>
     *
     * @param key
     * @param min
     * @param max
     * @return 值在 min 和 max 之間的成員的數量。異常返回0
     */
    public Long zcount(String key, double min, double max) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.zcount(key, min, max);
        } catch (Exception e) {

            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }

    }

    /**
     * <p>
     * 為哈希表 key 中的域 field 的值加上增量 increment 。增量也可以為負數，相當於對給定域進行減法操作。 如果 key
     * 不存在，一個新的哈希表被創建並執行 HINCRBY 命令。如果域 field 不存在，那么在執行命令前，域的值被初始化為 0 。
     * 對一個儲存字符串值的域 field 執行 HINCRBY 命令將造成一個錯誤。本操作的值被限制在 64 位(bit)有符號數字表示之內。
     * </p>
     * <p>
     * 將名稱為key的hash中field的value增加integer
     * </p>
     *
     * @param key
     * @param value
     * @param increment
     * @return 執行 HINCRBY 命令之后，哈希表 key 中域 field的值。異常返回0
     */
    public Long hincrBy(String key, String value, long increment) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            return jedis.hincrBy(key, value, increment);
        } catch (Exception e) {
            log.error(e.getMessage());
            return 0L;
        } finally {
            returnResource(jedisPool, jedis);
        }

    }

    /**
     * <p>
     * 通過key刪除在zset中指定的value
     * </p>
     *
     * @param key
     * @param members 可以使一個string 也可以是一個string數組
     * @return
     */
    public Long zrem(String key, String... members) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zrem(key, members);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key增加該zset中value的score的值
     * </p>
     *
     * @param key
     * @param score
     * @param member
     * @return
     */
    public Double zincrby(String key, double score, String member) {
        Jedis jedis = null;
        Double res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zincrby(key, score, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回zset中value的排名
     * </p>
     * <p>
     * 下標從小到大排序
     * </p>
     *
     * @param key
     * @param member
     * @return
     */
    public Long zrank(String key, String member) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zrank(key, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回zset中value的排名
     * </p>
     * <p>
     * 下標從大到小排序
     * </p>
     *
     * @param key
     * @param member
     * @return
     */
    public Long zrevrank(String key, String member) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zrevrank(key, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key將獲取score從start到end中zset的value
     * </p>
     * <p>
     * socre從大到小排序
     * </p>
     * <p>
     * 當start為0 end為-1時返回全部
     * </p>
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<String> zrevrange(String key, long start, long end) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zrevrange(key, start, end);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回指定score內zset中的value
     * </p>
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    public Set<String> zrangebyscore(String key, String max, String min) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zrevrangeByScore(key, max, min);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回指定score內zset中的value
     * </p>
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    public Set<String> zrangeByScore(String key, double max, double min) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zrevrangeByScore(key, max, min);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 返回指定區間內zset中value的數量
     * </p>
     *
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Long zcount(String key, String min, String max) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zcount(key, min, max);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key返回zset中的value個數
     * </p>
     *
     * @param key
     * @return
     */
    public Long zcard(String key) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zcard(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key獲取zset中value的score值
     * </p>
     *
     * @param key
     * @param member
     * @return
     */
    public Double zscore(String key, String member) {
        Jedis jedis = null;
        Double res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zscore(key, member);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key刪除給定區間內的元素
     * </p>
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Long zremrangeByRank(String key, long start, long end) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zremrangeByRank(key, start, end);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 通過key刪除指定score內的元素
     * </p>
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Long zremrangeByScore(String key, double start, double end) {
        Jedis jedis = null;
        Long res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.zremrangeByScore(key, start, end);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * <p>
     * 返回滿足pattern表達式的所有key
     * </p>
     * <p>
     * keys(*)
     * </p>
     * <p>
     * 返回所有的key
     * </p>
     *
     * @param pattern
     * @return
     */
    public Set<String> keys(String pattern) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.keys(pattern);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    public Set<String> keysBySelect(String pattern, int database) {
        Jedis jedis = null;
        Set<String> res = null;
        try {
            jedis = jedisPool.getResource();
            jedis.select(database);
            res = jedis.keys(pattern);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }


    /**
     * <p>
     * 通過key判斷值得類型
     * </p>
     *
     * @param key
     * @return
     */
    public String type(String key) {
        Jedis jedis = null;
        String res = null;
        try {
            jedis = jedisPool.getResource();
            res = jedis.type(key);
        } catch (Exception e) {

            log.error(e.getMessage());
        } finally {
            returnResource(jedisPool, jedis);
        }
        return res;
    }

    /**
     * 序列化對象
     *
     * @param obj
     * @return 對象需實現Serializable接口
     */
    public static byte[] ObjTOSerialize(Object obj) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream byteOut = null;
        try {
            byteOut = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(byteOut);
            oos.writeObject(obj);
            byteOut.flush();
            oos.flush();
            byte[] bytes = byteOut.toByteArray();
            oos.close();
            byteOut.close();
            return bytes;
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 反序列化對象
     *
     * @param bytes
     * @return 對象需實現Serializable接口
     */
    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            //反序列化
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 返還到連接池
     *
     * @param jedisPool
     * @param jedis
     */
    public static void returnResource(JedisPool jedisPool, Jedis jedis) {
        if (jedis != null) {
            //jedisPool.returnResource(jedis);
            jedis.close();
        }
    }

    // public static RedisUtil getRu() {
    // return ru;
    // }
    //
    // public static void setRu(RedisUtil ru) {
    // RedisUtil.ru = ru;
    // }

}

 

SpringCacheConfig：

package com.hbg.common.cache;

import com.hbg.common.constants.RedisKeyConstant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * @author zxf
 * @date 2020/11/5 16:49
 */
@Configuration
@EnableCaching
public class SpringCacheConfig extends CachingConfigurerSupport {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private CacheManager goodsDetailCacheManager;

    @Autowired
    private CacheManager defaultCacheManager;

    @Bean(name = "goodsCacheResolver")
    public CacheResolver goodsCacheResolver() {
        return new SimpleCacheResolver(goodsDetailCacheManager);
    }

    @Override
    @Bean(name = "defaultCacheResolver")
    public CacheResolver cacheResolver() {
        return new SimpleCacheResolver(defaultCacheManager);
    }

    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        // 用於捕獲從Cache中進行CRUD時的異常的回調處理器。
        return new SimpleCacheErrorHandler();
    }

    /**
     * 自定義生成redis-key
     *
     * @return
     */
/*    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new SimpleKeyGenerator();
    }*/

    /**
     * 商品詳情用的緩存管理器
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager goodsDetailCacheManager(RedisConnectionFactory redisConnectionFactory) {
        return this.goodsDetailCacheManager(redisConnectionFactory, 30L);
    }


    @Bean
    public CacheManager defaultCacheManager(RedisConnectionFactory redisConnectionFactory) {
        return this.goodsDetailCacheManager(redisConnectionFactory, 24*60L);
    }

    /**
     * 配置緩存管理器
     * @param redisConnectionFactory
     * @param minutes
     * @return
     */
    private CacheManager goodsDetailCacheManager(RedisConnectionFactory redisConnectionFactory, long minutes) {
        //緩存配置對象
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

        //設置緩存的默認超時時間：30分鍾
        redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofMinutes(minutes))
                //如果是空值，不緩存
                .disableCachingNullValues()
                //設置key序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                //設置value序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }
}

 

 

 

 

 

 

 

 

package com.hbg.common.cache;

import com.hbg.common.constants.RedisKeyConstant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

/**
 * @author zxf
 * @date 2020/11/5 16:49
 */
@Configuration
@EnableCaching
public class SpringCacheConfig extends CachingConfigurerSupport {

    @Autowired
private RedisTemplate<String, Object> redisTemplate;

    @Autowired
private CacheManager goodsDetailCacheManager;

    @Autowired
private CacheManager defaultCacheManager;

    @Bean(name = "goodsCacheResolver")
    public CacheResolver goodsCacheResolver() {
        return new SimpleCacheResolver(goodsDetailCacheManager);
    }

    @Override
    @Bean(name = "defaultCacheResolver")
    public CacheResolver cacheResolver() {
        return new SimpleCacheResolver(defaultCacheManager);
    }

    @Bean
    @Override
public CacheErrorHandler errorHandler() {
        // 用於捕獲從Cache中進行CRUD時的異常的回調處理器。
return new SimpleCacheErrorHandler();
    }

    /**
     * 自定義生成redis-key
     *
     * @return
*/
/*    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new SimpleKeyGenerator();
    }*/

    /**
     * 商品詳情用的緩存管理器
     * @param redisConnectionFactory
* @return
*/
@Bean
public CacheManager goodsDetailCacheManager(RedisConnectionFactory redisConnectionFactory) {
        return this.goodsDetailCacheManager(redisConnectionFactory, 30L);
    }


    @Bean
public CacheManager defaultCacheManager(RedisConnectionFactory redisConnectionFactory) {
        return this.goodsDetailCacheManager(redisConnectionFactory, 24*60L);
    }

    /**
     * 配置緩存管理器
     * @param redisConnectionFactory
* @param minutes
* @return
*/
private CacheManager goodsDetailCacheManager(RedisConnectionFactory redisConnectionFactory, long minutes) {
        //緩存配置對象
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

        //設置緩存的默認超時時間：30分鍾
redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofMinutes(minutes))
                //如果是空值，不緩存
.disableCachingNullValues()
                //設置key序列化器
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                //設置value序列化器
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }
}




實在看不懂，可以聯系我購買源碼-保證實用- 一次服務10元。