使用redis缓存数据

该博客介绍了如何在项目中配置并使用Redis作为数据缓存。首先在配置文件中引入redisTemplate,并设置redis的相关属性。接着通过读取配置文件,定义接口和其实现类来操作Redis。在生成缓存Key时,采用了正则表达式进行动态替换,以实现个性化缓存键。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

首先在applicationContext.xml中引入redisTemplate

<bean id="propertyConfigurer" class="PropertiesUtils">
        <property name="ignoreResourceNotFound" value="true" />
        <property name="locations">
            <list>
                <value>classpath*:*.properties</value>
            </list>
        </property>
    </bean>
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.max_total}" />
        <property name="minIdle" value="${redis.min_idle}" />
        <property name="maxIdle" value="${redis.max_idle}" />
        <property name="maxWaitMillis" value="${redis.max_wait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
        <property name="testOnReturn" value="${redis.testOnReturn}" />
        <property name="testWhileIdle" value="${redis.testWhileIdle}" />
    </bean>
<bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="poolConfig" ref="jedisPoolConfig" />
        <property name="hostName" value="${redis.ip}" />
        <property name="port" value="${redis.port}" />
        <property name="database" value="${redis.db.index}" />
    </bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory" />
    </bean>

然后写一个redis.property去保存对应的配置
然后写一个读取配置的文件

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;

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


public class PropertiesUtils  extends PropertyPlaceholderConfigurer {
    //所有属性文件的键值对
    private static Map<String, Object> ctxPropertiesMap;

    /**
     * 添加所有属性到map中
     * @see org.springframework.beans.factory.config.PropertyPlaceholderConfigurer#processProperties(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.Properties)
     */
    @Override
    protected synchronized void processProperties(
            ConfigurableListableBeanFactory beanFactoryToProcess,
            Properties props) throws BeansException {
        super.processProperties(beanFactoryToProcess, props);
        if (null==ctxPropertiesMap) {
        	ctxPropertiesMap = new HashMap<String, Object>();
        }
        for (Object key : props.keySet()) {
            String keyStr = key.toString();
            String value = props.getProperty(keyStr);
            ctxPropertiesMap.put(keyStr, value);
        }
    }

    
    public static String getContextProperty(String name) {
        return null == ctxPropertiesMap || ctxPropertiesMap.get(name) == null ? "" : ctxPropertiesMap.get(name).toString();
    }


    public static String getContextProperty(String name, String defaultValue) {
        return null == ctxPropertiesMap || ctxPropertiesMap.get(name) == null ? defaultValue : ctxPropertiesMap.get(name).toString();
    }

    public static Integer getInt(String name) {
        String value = getContextProperty(name);
        if ((value + "").matches("-?\\d+")) {
            return Integer.parseInt(value);
        } else {
            return null;
        }
    }

    /**
     * @param name         属性名
     */
    public static Integer getInt(String name, Integer defaultValue) {
        String value = getContextProperty(name);
        if ((value + "").matches("-?\\d+")) {
            return Integer.parseInt(value);
        } else {
            return defaultValue;
        }
    }

}

首先定义一个接口

import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;

import java.io.Serializable;
import java.util.List;
import java.util.Set;

public interface CacheService {


    /**
     * key
     *
     * @param key
     * @return 获取过期时间
     */
    public Long ttl(final String key);

    /**
     * 生成缓存 key
     *
     * @param namespace eg : carModle:{carFamily}:{id}:year
     * @param keys      eg:  audi,123
     * @return eg: carModle:audi:123:year
     */
    public String generateCacheKey(String namespace, Object... keys);


    public Boolean existsKey(String key);

    /**
     * 将对象添加到缓存中
     *
     * @param key   缓存的 key 值
     * @param value 对象
     */
    public void putIntoCache(final String key, final Object value);

    /**
     * 将对象添加到缓存中
     *
     * @param key   缓存的 key 值
     * @param value 对象
     * @param time  过期时间(多久之后过期) 单位为秒
     */
    public void putIntoCache(final String key, final Object value, final long time);

    /**
     * 清除缓存
     *
     * @param key 缓存的 key 值
     */
    public void clearCache(final String key);

    /**
     * 从缓存中获得对象
     *
     * @param key   缓存的 key
     * @param clazz 对象的类型
     * @return 缓存的 value
     */
    public <T> T getFromCache(final String key, final Class<T> clazz);

    /**
     * 从缓存中获取字符串
     * @param key
     * @return
     */
    String getStringFromCache(final String key);
    
    public <T> T getMapFromCache(final String key, final Class<T> clazz);
    public <T> T getObjectFromCache(final String key,final Class<T> clazz);
    /**
     * 根据 key ,从缓存中获取 list
     *
     * @param key   缓存的 key
     * @param clazz 对象的类型
     */
    public <T> List<T> getListFromCache(final String key, final Class<T> clazz);

    /**
     * 从缓存中批量获取 对象的值
     *
     * @param keys  缓存 key 的 list
     * @param clazz 对象的类型
     * @return
     */
    public <T> List<T> getListFromCache(final List<String> keys,
                                        final Class<T> clazz);

    /**
     * 自增 key
     *
     * @param key
     * @return 自增之后的 id
     */
    public Long incr(final String key);

    /**
     * 自增 key
     *
     * @param key
     * @return 自增之后的 id
     */
    public Long incr(final String key, final Long expireTime);

    /**
     * hashSet put操作
     *
     * @param hashName   hash hash表的名字
     * @param filedName  key 值
     * @param value      key 对应的 value值
     * @param expireTime 超时时间
     * @return
     */
    Boolean hset(String hashName, String filedName, Object value,
                 long expireTime);

    /**
     * hashSet 操作
     *
     * @param hashName  hash hash表的名字
     * @param filedName key 值
     * @param value     key 对应的value值
     * @return
     */
    Boolean hset(String hashName, String filedName, Object value);

    /**
     * hashGet hash get 操作
     *
     * @param hashName  hash 表的名字
     * @param filedName key 值
     * @return 对应的 value 的值
     */
    Object hget(String hashName, String filedName);

    /**
     * hashGet hash getAll 操作
     *
     * @param hashName  hash 表的名
     * @param filedName key 值
     * @return 对应的 value 的值
     */
    <T> List<T> hgetall(String hashName, final Class<T> clazz);

    /**
     * hashGet hash haskey 操作
     *
     * @param hashName  hash 表的名字
     * @param filedName key 值
     * @return
     */
    Boolean hhaskey(String hashName, String filedName);
    
    /**
	 * @param hashName
	 * @param filedName
	 * @return
	 */
	Boolean hExists(String hashName, String filedName);

    /**
     * hashGet hash delete 操作
     *
     * @param hashName  hash 表的名字
     * @param filedName key 值
     * @return
     */
    void hdelete(String hashName, String filedName);

    /**
     * 批量保存
     *
     * @param <DefaultTuple>
     * @param <T>
     * @param key
     * @param value
     * @param score
     * @param expireTime
     * @return
     */
    Long zsetBatch(final String key, final Set<Tuple> tuples, final long expireTime);

    /**
     * zset add 操作
     *
     * @param key
     * @param value
     * @param score
     * @param expireTime 如果该zet过期时间,则设置这个过期时间
     * @return
     */
    Boolean zset(String key, final Serializable value, double score, long expireTime);

    /**
     * 会有默认值的设置有效期
     *
     * @param key
     * @param value
     * @param score
     * @return
     */
    Boolean zset(String key, final Serializable value, double score);

    /**
     * 不改变设置有效期的zset插入
     *
     * @param key
     * @param value
     * @param score
     * @return
     */
    Boolean zsetNoExpire(String key, final Serializable value, double score);

    /**
     * zset add 操作
     *
     * @param key
     * @param value
     * @param score
     * @param expireTime 如果该key不存在/zet无过期时间,则设置这个过期时间
     * @return
     */
    Boolean zset(String key, final Object value, double score, long expireTime);

    /**
     * zset add 操作
     *
     * @param key
     * @param value
     * @param score
     * @return
     */
    Boolean zset(String key, final Object value, double score);

    /**
     * zset get 操作
     *
     * @param key
     * @param value
     * @param score
     * @return
     */
    <T> Set<T> zget(String key, final Class<T> clazz);

    /**
     * zset顺序取数据
     *
     * @param key
     * @param startIndex
     * @param endIndex
     * @param clazz
     * @return
     */
    <T> Set<T> zrange(final String key, final Integer startIndex, final Integer endIndex, final Class<T> clazz);

    /**
     * zset集合总数
     *
     * @param key
     * @param startIndex
     * @param endIndex
     * @param clazz
     * @return
     */
    public Long zcount(final String key);

    /**
     * 删除KEY
     *
     * @param key
     * @return
     */
    Long delKey(final String key);

    /**
     * set add 操作
     *
     * @param key
     * @param value
     * @param expireTime
     * @return
     */
    Boolean set(String key, final Object value, long expireTime);

    /**
     * set remove 操作
     *
     * @param key
     * @param value
     * @return
     */
    Boolean sRem(String key, final Object value);

    /**
     * 获得set所有元素
     *
     * @param key
     * @param clazz
     * @return
     */
    <T> Set<T> sMembers(String key, final Class<T> clazz);

    /**
     * 增加value大小的值
     *
     * @param key
     * @param value
     * @return
     */
    Long incrBy(final String key, final Long value);

    /**
     * 分布式锁
     * 缓存减压使用
     *
     * @param key
     * @param value
     * @param expireTime
     * @return
     */
    Boolean setnx(final String key, final Long value, final Long expireTime);
    
    /**
	 * 检查set中是否包含这个值
	 * @param key
	 * @param value
	 * @return
	 */
	Boolean sIsMember(String key, final Object value);
}

然后定义redis的实现类

import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.Resource;

import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.parser.Feature;
import com.alibaba.fastjson.serializer.JSONSerializer;
import com.alibaba.fastjson.serializer.SerializeWriter;
import com.ttpai.api.cache.CacheService;

@Service
public class RedisCacheServiceImpl implements CacheService {

    private static final String pattern = "\\{[^}]*\\}";
    private static final long oneDayExexpire = 22 * 60 * 60L;// 默认22小时有效期
    private static final String DEFAULT_CHARSET = "utf-8";

    @Resource
    private RedisTemplate<String, Serializable> redisTemplate;

    protected Feature T;

    @Override
    public String generateCacheKey(String namespace, Object... keys) {
        checkRedisKeyParamCount(namespace, keys);

        // 创建 Pattern 对象
        Pattern r = Pattern.compile(pattern);

        // 现在创建 matcher 对象
        Matcher m = r.matcher(namespace);
        int count = 0;
        String replaceName = null;
        while (m.find()) {
            replaceName = m.replaceFirst(keys[count].toString());
            m = r.matcher(replaceName);
            count++;
        }
        int argsLength = keys.length;
        if (count != argsLength) {
            throw new IllegalArgumentException("字符串占位符个数和传入的参数数量不相等");
        }
        return replaceName;
    }

    @Override
    public void putIntoCache(final String key, final Object value, final long expireTime) {
        redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                connection.set(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        out.toBytes(DEFAULT_CHARSET));
                if(expireTime > -1) {
                    connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
                }
                return true;
            }
        });
    }

    @Override
    public void putIntoCache(final String key, final Object value) {
        putIntoCache(key, value, Constants.REDIS_DEFAULT_CACHE_TIME);
    }

    @Override
    public void clearCache(final String key) {
        redisTemplate.execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                connection.del(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                return true;
            }
        });
    }

    @Override
    public <T> T getFromCache(final String key, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<T>() {
            @Override
            public T doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (out == null) {
                    return null;
                }
                return JSONObject.parseObject(out, clazz);
            }
        });
    }

    @Override
    public String getStringFromCache(final String key){
        return redisTemplate.execute((RedisCallback<String>) connection -> {
            byte[] out=connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
            if(out==null){
                return null;
            }
            return new String(out);
        });
    }

    @Override
    public <T> T getMapFromCache(final String key, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<T>() {
            @Override
            public T doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (out == null) {
                    return null;
                }
                String resultStr = new String(out, Charset.forName(DEFAULT_CHARSET));
                resultStr = resultStr.substring(1, resultStr.length());
                resultStr = resultStr.substring(0, resultStr.length() - 1);
                return JSONObject.parseObject(resultStr.replace("\\", ""), clazz);
            }
        });
    }

    @SuppressWarnings("all")
    @Override
    public <T> T getObjectFromCache(final String key, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<T>() {
            @Override
            public T doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (out == null) {
                    return null;
                }
                String resultStr = new String(out, Charset.forName(DEFAULT_CHARSET));
                resultStr = resultStr.substring(1, resultStr.length());
                resultStr = resultStr.substring(0, resultStr.length() - 1);
                resultStr.replace("\\", "");
                return JSONObject.parseObject(resultStr.replace("\\", ""), clazz);
            }
        });
    }

    // public static void main(String[] args) throws ClassNotFoundException {
    // String str =
    // "{\"别克\":[],\"大众\":[],\"奥迪\":[],\"宝马\":[],\"日产\":[],\"本田\":[{\"carAge\":5,\"rate\":18}],\"比亚迪\":[],\"现代\":[],\"雪佛兰\":[]}";
    // Class clazz = Class.forName("java.util.Map");
    // Map map = JSONObject.parseObject(str, clazz);
    // System.out.println();
    // }

    @Override
    public <T> List<T> getListFromCache(final List<String> keys, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<List<T>>() {
            @SuppressWarnings("unchecked")
            @Override
            public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
                if (keys.size() == 0) {
                    return new ArrayList<T>();
                }
                List<byte[]> keySet = new ArrayList<byte[]>();
                for (String key : keys) {
                    keySet.add(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                }
                List<T> out = new ArrayList<T>();
                if (keySet.size() <= Constants.REDIS_MGET_LIMIT) {
                    List<byte[]> results =
                            connection.mGet(keySet.toArray(new byte[keySet.size()][]));
                    if (results == null) {
                        return null;
                    }
                    for (byte[] result : results) {
                        if (result != null) {
                            T t = JSONObject.parseObject(result, clazz);
                            out.add(t);
                        }
                    }
                } else {
                    connection.openPipeline();
                    int limitCount = keySet.size() / Constants.REDIS_MGET_LIMIT;
                    int leftCount = keySet.size() % Constants.REDIS_MGET_LIMIT;
                    for (int i = 0; i < limitCount; i++) {
                        connection.mGet(keySet
                                .subList(i * Constants.REDIS_MGET_LIMIT,
                                        (i + 1) * Constants.REDIS_MGET_LIMIT)
                                .toArray(new byte[Constants.REDIS_MGET_LIMIT][]));
                    }
                    if (leftCount > 0) {
                        connection.mGet(keySet
                                .subList(limitCount * Constants.REDIS_MGET_LIMIT, keySet.size())
                                .toArray(new byte[leftCount][]));
                    }
                    List<Object> results = connection.closePipeline();
                    for (Object object : results) {
                        if (object != null) {
                            for (byte[] o : (List<byte[]>) object) {
                                if (o != null) {
                                    T t = JSONObject.parseObject(o, clazz);
                                    out.add(t);
                                }
                            }
                        }
                    }
                }
                return out;
            }
        });
    }

    @Override
    public <T> List<T> getListFromCache(final String key, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<List<T>>() {
            @Override
            public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] out = connection.get(key.getBytes(Charset.forName(DEFAULT_CHARSET)));

                if (out == null) {
                    return null;
                }
                return JSONObject.parseArray(new String(out, Charset.forName(DEFAULT_CHARSET)),
                        clazz);
            }
        });
    }

    @Override
    public Long incr(final String key) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {

                Long result = connection.incr(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                return result;
            }
        });
    }

    @Override
    public Long incr(final String key, final Long expireTime) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {

                Long result = connection.incr(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
                return result;
            }
        });
    }

    @Override
    public Boolean hset(final String hashName, final String filedName, final Object value,
            final long expireTime) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                Boolean result =
                        connection.hSet(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)),
                                filedName.getBytes(Charset.forName(DEFAULT_CHARSET)),
                                out.toBytes(DEFAULT_CHARSET));

                if (result && expireTime > 0) {
                    connection.expire(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)),
                            expireTime);
                }
                return result;
            }

        });
    }

    @Override
    public Boolean hset(String hashName, String filedName, Object value) {
        return hset(hashName, filedName, value, Constants.REDIS_DEFAULT_CACHE_TIME);
    }

    @Override
    public Object hget(final String hashName, final String filedName) {

        return this.redisTemplate.execute(new RedisCallback<Object>() {

            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {

                byte[] bytes = connection.hGet(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        filedName.getBytes(Charset.forName(DEFAULT_CHARSET)));

                if (bytes == null) {
                    return null;
                }
                Object obj = JSONObject.parseObject(
                        new String(bytes, Charset.forName(DEFAULT_CHARSET)), Object.class);
                return obj;
            }

        });
    }

    private void checkRedisKeyParamCount(String key, Object... args) {

        Pattern r = Pattern.compile(pattern);

        Matcher m = r.matcher(key);

        int count = 0;
        while (m.find()) {
            count++;
        }

        int argsLength = args.length;

        if (count != argsLength) {
            throw new IllegalArgumentException("缓存skey中的字符串占位符个数和传入的参数数量不相等");
        }
    }


    @Override
    public Boolean hhaskey(String hashName, String filedName) {
        return redisTemplate.opsForHash().hasKey(hashName, filedName);
    }

    @Override
    public Boolean hExists(final String hashName, final String filedName) {

        return redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {

                Boolean flag = connection.hExists(hashName.getBytes(), filedName.getBytes());

                return flag;
            }
        });
    }

    @Override
    public void hdelete(String hashName, String filedName) {
        redisTemplate.opsForHash().delete(hashName, filedName);
    }

    @Override
    public Boolean zset(final String key, final Serializable value, final double score,
            final long expireTime) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                /*
                 * Boolean haskey =
                 * connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                 */
                // 已有key不需要重复设置有效期
                Boolean result = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        score, out.toBytes(DEFAULT_CHARSET));
                if (result && expireTime > 0) {
                    connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
                }

                return result;
            }

        });
    }

    @Override
    public Boolean zset(final String key, final Serializable value, final double score) {
        return zset(key, value, score, oneDayExexpire);
    }

    @Override
    public Boolean zsetNoExpire(final String key, final Serializable value, final double score) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                /*
                 * Boolean haskey =
                 * connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                 */
                // 已有key不需要重复设置有效期
                Boolean result = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        score, out.toBytes(DEFAULT_CHARSET));

                return result;
            }

        });
    }

    /**
     * 批量插入zset
     */
    @Override
    public Long zsetBatch(final String key, final Set<Tuple> tuples, final long expireTime) {
        if (null == tuples || tuples.size() == 0) return 0L;
        return this.redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                Long cnt = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)), tuples);
                connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
                return cnt;
            }

        });
    }

    @Override
    public Boolean zset(final String key, final Object value, final double score,
            final long expireTime) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                // connection.ttl(key.getBytes());//获取有效时间

                Boolean result = connection.zAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        score, out.toBytes(DEFAULT_CHARSET));
                if (!haskey && result && expireTime > 0) {
                    connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
                }
                return result;
            }

        });
    }

    @Override
    public Boolean zset(final String key, final Object value, final double score) {
        return this.zset(key, value, score, oneDayExexpire);
    }

    @Override
    public <T> Set<T> zget(final String key, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<Set<T>>() {
            @SuppressWarnings("unchecked")
            @Override
            public Set<T> doInRedis(RedisConnection connection) throws DataAccessException {
                Long sum = connection.zCard(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (sum < 1) {
                    return null;
                }
                Set<T> res = new HashSet<T>(sum.intValue());
                Set<byte[]> out =
                        connection.zRange(key.getBytes(Charset.forName(DEFAULT_CHARSET)), 0l, sum);
                for (byte[] bs : out) {
                    res.add((T) JSONObject.parseObject(bs, clazz));
                }
                return res;
            }
        });
    }

    /**
     * zset集合中取出某一段范围数据,不包含分数scoure
     *
     * @param key
     * @param startIndex
     * @param endIndex
     * @param clazz
     * @return
     */
    public <T> Set<T> zrange(final String key, final Integer startIndex, final Integer endIndex,
            final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<Set<T>>() {
            @SuppressWarnings("unchecked")
            @Override
            public Set<T> doInRedis(RedisConnection connection) throws DataAccessException {
                LinkedHashSet<T> res = new LinkedHashSet<T>();
                Set<byte[]> out = connection.zRange(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        startIndex, endIndex);
                for (byte[] bs : out) {
                    res.add((T) JSONObject.parseObject(bs, clazz));
                }
                return res;
            }
        });
    }

    /**
     * zset集合总数
     *
     * @param key
     * @return
     */
    public Long zcount(final String key) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.zCount(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        Double.MIN_VALUE, Double.MAX_VALUE);
            }
        });
    }

    @Override
    public <T> List<T> hgetall(final String hashName, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<List<T>>() {
            @Override
            public List<T> doInRedis(RedisConnection connection) throws DataAccessException {
                List<byte[]> out =
                        connection.hVals(hashName.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (out == null) {
                    return null;
                }
                return RedisObjectUtil.getListFrom(out, clazz);
            }
        });
    }


    @Override
    public Boolean existsKey(final String key) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {

                Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                // connection.ttl(key.getBytes());//获取有效时间
                return haskey;
            }

        });
    }


    /**
     * 删除某个key
     *
     * @return long 被删除的数量
     * @author rickycoder
     */
    @Override
    public Long delKey(final String key) {
        return this.redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.del(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
            }

        });
    }

    /**
     * set add 操作
     */
    @Override
    public Boolean set(final String key, final Object value, final long expireTime) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                Long result = connection.sAdd(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                        out.toBytes(DEFAULT_CHARSET));
                if (!haskey && result != null && result == 1 && expireTime > 0) {
                    connection.expire(key.getBytes(Charset.forName(DEFAULT_CHARSET)), expireTime);
                }
                return result != null && result == 1;
            }

        });
    }

    /**
     * set remove 操作
     */
    @Override
    public Boolean sRem(final String key, final Object value) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                Boolean haskey = connection.exists(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (haskey) {
                    Long result = connection.sRem(key.getBytes(Charset.forName(DEFAULT_CHARSET)),
                            out.toBytes(DEFAULT_CHARSET));
                    return result == null || result.intValue() == 0 ? false : true;
                } else {
                    return false;
                }
            }

        });
    }

    /**
     * 获得set所有元素
     */
    @Override
    public <T> Set<T> sMembers(final String key, final Class<T> clazz) {
        return redisTemplate.execute(new RedisCallback<Set<T>>() {
            @Override
            public Set<T> doInRedis(RedisConnection connection) throws DataAccessException {
                Set<byte[]> out =
                        connection.sMembers(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
                if (out == null) {
                    return null;
                }
                return RedisObjectUtil.getSetFrom(out, clazz);
            }
        });
    }

    @Override
    public Long incrBy(final String key, final Long value) {
        return redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {

                Long result =
                        connection.incrBy(key.getBytes(Charset.forName(DEFAULT_CHARSET)), value);

                return result;
            }
        });
    }

    @Override
    public Boolean setnx(final String key, final Long value, final Long expireTime) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {
            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                final byte[] keyBytes = key.getBytes(Charset.forName(DEFAULT_CHARSET));
                Boolean result = connection.setNX(keyBytes, out.toBytes(DEFAULT_CHARSET));
                if (result) {
                    connection.expire(keyBytes, expireTime);
                }
                return result;
            }
        });
    }


    /**
     * 以秒为单位,返回给定 key 的剩余有效时间
     */
    @Override
    public Long ttl(final String key) {
        return this.redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.ttl(key.getBytes(Charset.forName(DEFAULT_CHARSET)));
            }
        });
    }


    @Override
    public Boolean sIsMember(final String key, final Object value) {
        return this.redisTemplate.execute(new RedisCallback<Boolean>() {

            @Override
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                SerializeWriter out = new SerializeWriter();
                JSONSerializer serializer = new JSONSerializer(out);
                serializer.write(value);
                Boolean result = connection.sIsMember(key.getBytes(Charset.forName("utf-8")),
                        out.toBytes("utf-8"));
                return result;
            }

        });
    }
}

其中 cacheService.generateCacheKey(“store_{mobile}”, mobile);使用正则去替换生成的key。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值