RedisTemplate的缓存工具类

最新推荐文章于 2024-10-02 06:04:55 发布
最新推荐文章于 2024-10-02 06:04:55 发布
阅读量2.2k 收藏
点赞数

1.CacheUtils

package com.lh.core.core.util;  
  
import java.util.Map;  
import java.util.Set;  
import java.util.concurrent.TimeUnit;  
  
import org.springframework.data.redis.core.BoundHashOperations;  
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.data.redis.core.StringRedisTemplate;  
import org.springframework.util.CollectionUtils;  
  
import com.alibaba.fastjson.JSON;  
import com.alibaba.fastjson.JSONObject;  
import com.rd.ifaes.common.dict.ExpireTime;  
import com.lh.common.util.JsonMapper;  
import com.rd.ifaes.common.util.SpringContextHolder;  
import com.rd.ifaes.common.util.StringUtils;  
  
/** 
 * 通用缓存工具类 
 * @author lh 
 * @version 3.0 
 * @since 2016-6-22 
 * 
 */  
public class CacheUtils {  
      
    private static StringRedisTemplate stringRedisTemplate = SpringContextHolder.getBean("stringRedisTemplate");  
    private static RedisTemplate<String, Object> redisTemplate = SpringContextHolder.getBean("redisTemplate");  
          
    /** 
     * 删除缓存<br> 
     * 根据key精确匹配删除 
     * @param key 
     */  
    @SuppressWarnings("unchecked")  
    public static void del(String... key){  
        if(key!=null && key.length > 0){  
            if(key.length == 1){  
                redisTemplate.delete(key[0]);  
            }else{  
                redisTemplate.delete(CollectionUtils.arrayToList(key));               
            }  
        }  
    }  
      
    /** 
     * 批量删除<br> 
     * （该操作会执行模糊查询，请尽量不要使用，以免影响性能或误删） 
     * @param pattern 
     */   
    public static void batchDel(String... pattern){  
        for (String kp : pattern) {  
            redisTemplate.delete(redisTemplate.keys(kp + "*"));  
        }  
    }  
      
    /** 
     * 取得缓存（int型） 
     * @param key 
     * @return 
     */  
    public static Integer getInt(String key){  
        String value = stringRedisTemplate.boundValueOps(key).get();  
        if(StringUtils.isNotBlank(value)){  
            return Integer.valueOf(value);  
        }  
        return null;  
    }  
      
    /** 
     * 取得缓存（字符串类型） 
     * @param key 
     * @return 
     */  
    public static String getStr(String key){  
        return stringRedisTemplate.boundValueOps(key).get();  
    }  
      
    /** 
     * 取得缓存（字符串类型） 
     * @param key 
     * @return 
     */  
    public static String getStr(String key, boolean retain){  
        String value = stringRedisTemplate.boundValueOps(key).get();  
        if(!retain){  
            redisTemplate.delete(key);  
        }  
        return value;  
    }  
      
    /** 
     * 获取缓存<br> 
     * 注：基本数据类型(Character除外)，请直接使用get(String key, Class<T> clazz)取值 
     * @param key 
     * @return 
     */  
    public static Object getObj(String key){  
        return redisTemplate.boundValueOps(key).get();  
    }  
      
    /** 
     * 获取缓存<br> 
     * 注：java 8种基本类型的数据请直接使用get(String key, Class<T> clazz)取值 
     * @param key        
     * @param retain    是否保留 
     * @return 
     */  
    public static Object getObj(String key, boolean retain){  
        Object obj = redisTemplate.boundValueOps(key).get();  
        if(!retain){  
            redisTemplate.delete(key);  
        }  
        return obj;  
    }  
      
    /** 
     * 获取缓存<br> 
     * 注：该方法暂不支持Character数据类型 
     * @param key   key 
     * @param clazz 类型 
     * @return 
     */  
    @SuppressWarnings("unchecked")  
    public static <T> T get(String key, Class<T> clazz) {  
        return (T)redisTemplate.boundValueOps(key).get();  
    }  
      
    /** 
     * 获取缓存json对象<br> 
     * @param key   key 
     * @param clazz 类型 
     * @return 
     */  
    public static <T> T getJson(String key, Class<T> clazz) {  
        return JsonMapper.fromJsonString(stringRedisTemplate.boundValueOps(key).get(), clazz);  
    }  
      
    /** 
     * 将value对象写入缓存 
     * @param key 
     * @param value 
     * @param time 失效时间(秒) 
     */  
    public static void set(String key,Object value,ExpireTime time){  
        if(value.getClass().equals(String.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());                 
        }else if(value.getClass().equals(Integer.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());  
        }else if(value.getClass().equals(Double.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());  
        }else if(value.getClass().equals(Float.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());  
        }else if(value.getClass().equals(Short.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());  
        }else if(value.getClass().equals(Long.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());  
        }else if(value.getClass().equals(Boolean.class)){  
            stringRedisTemplate.opsForValue().set(key, value.toString());  
        }else{  
            redisTemplate.opsForValue().set(key, value);              
        }  
        if(time.getTime() > 0){  
            redisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);  
        }  
    }  
      
    /** 
     * 将value对象以JSON格式写入缓存 
     * @param key 
     * @param value 
     * @param time 失效时间(秒) 
     */  
    public static void setJson(String key,Object value,ExpireTime time){  
        stringRedisTemplate.opsForValue().set(key, JsonMapper.toJsonString(value));  
        if(time.getTime() > 0){  
            stringRedisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);  
        }  
    }  
      
    /** 
     * 更新key对象field的值 
     * @param key   缓存key 
     * @param field 缓存对象field 
     * @param value 缓存对象field值 
     */  
    public static void setJsonField(String key, String field, String value){  
        JSONObject obj = JSON.parseObject(stringRedisTemplate.boundValueOps(key).get());  
        obj.put(field, value);  
        stringRedisTemplate.opsForValue().set(key, obj.toJSONString());  
    }  
      
      
    /** 
     * 递减操作 
     * @param key 
     * @param by 
     * @return 
     */  
    public static double decr(String key, double by){  
        return redisTemplate.opsForValue().increment(key, -by);  
    }  
      
    /** 
     * 递增操作 
     * @param key 
     * @param by 
     * @return 
     */  
    public static double incr(String key, double by){  
        return redisTemplate.opsForValue().increment(key, by);  
    }  
      
    /** 
     * 获取double类型值 
     * @param key 
     * @return 
     */  
    public static double getDouble(String key) {  
        String value = stringRedisTemplate.boundValueOps(key).get();  
        if(StringUtils.isNotBlank(value)){  
            return Double.valueOf(value);  
        }  
        return 0d;  
    }  
      
    /** 
     * 设置double类型值 
     * @param key 
     * @param value 
     * @param time 失效时间(秒) 
     */  
    public static void setDouble(String key, double value, ExpireTime time) {  
        stringRedisTemplate.opsForValue().set(key, String.valueOf(value));  
        if(time.getTime() > 0){  
            stringRedisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);  
        }  
    }  
      
    /** 
     * 设置double类型值 
     * @param key 
     * @param value 
     * @param time 失效时间(秒) 
     */  
    public static void setInt(String key, int value, ExpireTime time) {  
        stringRedisTemplate.opsForValue().set(key, String.valueOf(value));  
        if(time.getTime() > 0){  
            stringRedisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);  
        }  
    }  
      
    /** 
     * 将map写入缓存 
     * @param key 
     * @param map 
     * @param time 失效时间(秒) 
     */  
    public static <T> void setMap(String key, Map<String, T> map, ExpireTime time){  
        redisTemplate.opsForHash().putAll(key, map);  
    }  
      
    /** 
     * 将map写入缓存 
     * @param key 
     * @param map 
     * @param time 失效时间(秒) 
     */  
    @SuppressWarnings("unchecked")  
    public static <T> void setMap(String key, T obj, ExpireTime time){  
        Map<String, String> map = (Map<String, String>)JsonMapper.parseObject(obj, Map.class);  
        redisTemplate.opsForHash().putAll(key, map);  
    }  
      
      
      
    /** 
     * 向key对应的map中添加缓存对象 
     * @param key 
     * @param map 
     */  
    public static <T> void addMap(String key, Map<String, T> map){  
        redisTemplate.opsForHash().putAll(key, map);  
    }  
      
    /** 
     * 向key对应的map中添加缓存对象 
     * @param key   cache对象key 
     * @param field map对应的key 
     * @param value     值 
     */  
    public static void addMap(String key, String field, String value){  
        redisTemplate.opsForHash().put(key, field, value);  
    }  
      
    /** 
     * 向key对应的map中添加缓存对象 
     * @param key   cache对象key 
     * @param field map对应的key 
     * @param obj   对象 
     */  
    public static <T> void addMap(String key, String field, T obj){  
        redisTemplate.opsForHash().put(key, field, obj);  
    }  
      
    /** 
     * 获取map缓存 
     * @param key 
     * @param clazz 
     * @return 
     */  
    public static <T> Map<String, T> mget(String key, Class<T> clazz){  
        BoundHashOperations<String, String, T> boundHashOperations = redisTemplate.boundHashOps(key);   
        return boundHashOperations.entries();  
    }  
      
    /** 
     * 获取map缓存 
     * @param key 
     * @param clazz 
     * @return 
     */  
    public static <T> T getMap(String key, Class<T> clazz){  
        BoundHashOperations<String, String, String> boundHashOperations = redisTemplate.boundHashOps(key);   
        Map<String, String> map = boundHashOperations.entries();  
        return JsonMapper.parseObject(map, clazz);  
    }  
      
    /** 
     * 获取map缓存中的某个对象 
     * @param key 
     * @param field 
     * @param clazz 
     * @return 
     */  
    @SuppressWarnings("unchecked")  
    public static <T> T getMapField(String key, String field, Class<T> clazz){  
        return (T)redisTemplate.boundHashOps(key).get(field);  
    }  
      
    /** 
     * 删除map中的某个对象 
     * @author lh 
     * @date 2016年8月10日 
     * @param key   map对应的key 
     * @param field map中该对象的key 
     */  
    public void delMapField(String key, String... field){  
        BoundHashOperations<String, String, ?> boundHashOperations = redisTemplate.boundHashOps(key);   
        boundHashOperations.delete(field);  
    }  
      
    /** 
     * 指定缓存的失效时间 
     *  
     * @author FangJun 
     * @date 2016年8月14日 
     * @param key 缓存KEY 
     * @param time 失效时间(秒) 
     */  
    public static void expire(String key, ExpireTime time) {  
        if(time.getTime() > 0){  
            redisTemplate.expire(key, time.getTime(), TimeUnit.SECONDS);  
        }  
    }  
      
    /** 
     * 添加set 
     * @param key 
     * @param value 
     */  
    public static void sadd(String key, String... value) {  
        redisTemplate.boundSetOps(key).add(value);  
    }  
  
    /** 
     * 删除set集合中的对象 
     * @param key 
     * @param value 
     */  
    public static void srem(String key, String... value) {  
        redisTemplate.boundSetOps(key).remove(value);  
    }  
      
    /** 
     * set重命名 
     * @param oldkey 
     * @param newkey 
     */  
    public static void srename(String oldkey, String newkey){  
        redisTemplate.boundSetOps(oldkey).rename(newkey);  
    }  
      
    /** 
     * 短信缓存 
     * @author fxl 
     * @date 2016年9月11日 
     * @param key 
     * @param value 
     * @param time 
     */  
    public static void setIntForPhone(String key,Object value,int time){  
        stringRedisTemplate.opsForValue().set(key, JsonMapper.toJsonString(value));  
        if(time > 0){  
            stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);  
        }  
    }  
      
    /** 
     * 模糊查询keys 
     * @param pattern 
     * @return 
     */  
    public static Set<String> keys(String pattern){  
        return redisTemplate.keys(pattern);   
    }  
      
}

2.JsonMaper

package com.lh.common.util;  
  
import java.io.IOException;  
import java.util.TimeZone;  
  
import org.apache.commons.lang3.StringEscapeUtils;  
import org.apache.commons.lang3.StringUtils;  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
import com.alibaba.fastjson.JSON;  
import com.fasterxml.jackson.annotation.JsonInclude.Include;  
import com.fasterxml.jackson.core.JsonGenerator;  
import com.fasterxml.jackson.core.JsonParser.Feature;  
import com.fasterxml.jackson.core.JsonProcessingException;  
import com.fasterxml.jackson.databind.DeserializationFeature;  
import com.fasterxml.jackson.databind.JavaType;  
import com.fasterxml.jackson.databind.JsonSerializer;  
import com.fasterxml.jackson.databind.ObjectMapper;  
import com.fasterxml.jackson.databind.SerializationFeature;  
import com.fasterxml.jackson.databind.SerializerProvider;  
import com.fasterxml.jackson.databind.module.SimpleModule;  
import com.fasterxml.jackson.databind.util.JSONPObject;  
import com.fasterxml.jackson.module.jaxb.JaxbAnnotationModule;  
  
  
/** 
 * 简单封装Jackson，实现JSON String<->Java Object的Mapper. 
 * 
 */  
public class JsonMapper extends ObjectMapper {  
   
        private static final long serialVersionUID = 1L;  
  
        private final static Logger LOGGER = LoggerFactory.getLogger(JsonMapper.class);  
  
        private static JsonMapper mapper;  
  
        public JsonMapper() {  
            this(Include.NON_EMPTY);  
        }  
  
        public JsonMapper(Include include) {  
            // 设置输出时包含属性的风格  
            if (include != null) {  
                this.setSerializationInclusion(include);  
            }  
            // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性  
            this.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);  
            // 空值处理为空串  
            this.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>(){  
                @Override  
                public void serialize(Object value, JsonGenerator jgen,  
                        SerializerProvider provider) throws IOException,  
                        JsonProcessingException {  
                    jgen.writeString("");  
                }  
            });  
            // 进行HTML解码。  
            this.registerModule(new SimpleModule().addSerializer(String.class, new JsonSerializer<String>(){  
                @Override  
                public void serialize(String value, JsonGenerator jgen,  
                        SerializerProvider provider) throws IOException,  
                        JsonProcessingException {  
                    jgen.writeString(StringEscapeUtils.unescapeHtml4(value));  
                }  
            }));  
            // 设置时区  
            this.setTimeZone(TimeZone.getDefault());//getTimeZone("GMT+8:00")  
        }  
  
        /** 
         * 创建只输出非Null且非Empty(如List.isEmpty)的属性到Json字符串的Mapper,建议在外部接口中使用. 
         */  
        public static JsonMapper getInstance() {  
            if (mapper == null){  
                mapper = new JsonMapper().enableSimple();  
            }  
            return mapper;  
        }  
  
        /** 
         * 创建只输出初始值被改变的属性到Json字符串的Mapper, 最节约的存储方式，建议在内部接口中使用。 
         */  
        public static JsonMapper nonDefaultMapper() {  
            if (mapper == null){  
                mapper = new JsonMapper(Include.NON_DEFAULT);  
            }  
            return mapper;  
        }  
          
        /** 
         * Object可以是POJO，也可以是Collection或数组。 
         * 如果对象为Null, 返回"null". 
         * 如果集合为空集合, 返回"[]". 
         */  
        public String toJson(Object object) {  
            try {  
                return this.writeValueAsString(object);  
            } catch (IOException e) {  
                if(LOGGER.isWarnEnabled()){  
                    LOGGER.warn("write to json string error:" + object, e);  
                }  
                return null;  
            }  
        }  
  
        /** 
         * 反序列化POJO或简单Collection如List<String>. 
         *  
         * 如果JSON字符串为Null或"null"字符串, 返回Null. 
         * 如果JSON字符串为"[]", 返回空集合. 
         *  
         * 如需反序列化复杂Collection如List<MyBean>, 请使用fromJson(String,JavaType) 
         * @see #fromJson(String, JavaType) 
         */  
        public <T> T fromJson(String jsonString, Class<T> clazz) {  
            if (StringUtils.isEmpty(jsonString)) {  
                return null;  
            }  
            try {  
                return this.readValue(jsonString, clazz);  
            } catch (IOException e) {  
                if(LOGGER.isWarnEnabled()){  
                    LOGGER.warn("parse json string error:" + jsonString, e);  
                }  
                return null;  
            }  
        }  
  
        /** 
         * 反序列化复杂Collection如List<Bean>, 先使用函數createCollectionType构造类型,然后调用本函数. 
         * @see #createCollectionType(Class, Class...) 
         */  
        @SuppressWarnings("unchecked")  
        public <T> T fromJson(String jsonString, JavaType javaType) {  
            if (StringUtils.isEmpty(jsonString)) {  
                return null;  
            }  
            try {  
                return (T) this.readValue(jsonString, javaType);  
            } catch (IOException e) {  
                if(LOGGER.isWarnEnabled()){  
                    LOGGER.warn("parse json string error:" + jsonString, e);  
                }  
                return null;  
            }  
        }  
  
        /** 
         * 構造泛型的Collection Type如: 
         * ArrayList<MyBean>, 则调用constructCollectionType(ArrayList.class,MyBean.class) 
         * HashMap<String,MyBean>, 则调用(HashMap.class,String.class, MyBean.class) 
         */  
        public JavaType createCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {  
            return this.getTypeFactory().constructParametricType(collectionClass, elementClasses);  
        }  
  
        /** 
         * 當JSON裡只含有Bean的部分屬性時，更新一個已存在Bean，只覆蓋該部分的屬性. 
         */  
        @SuppressWarnings("unchecked")  
        public <T> T update(String jsonString, T object) {  
            try {  
                return (T) this.readerForUpdating(object).readValue(jsonString);  
            } catch (JsonProcessingException e) {  
                if(LOGGER.isWarnEnabled()){  
                    LOGGER.warn("update json string:" + jsonString + " to object:" + object + " error.", e);  
                }  
            } catch (IOException e) {  
                if(LOGGER.isWarnEnabled()){  
                    LOGGER.warn("update json string:" + jsonString + " to object:" + object + " error.", e);  
                }  
            }  
            return null;  
        }  
  
        /** 
         * 輸出JSONP格式數據. 
         */  
        public String toJsonP(String functionName, Object object) {  
            return toJson(new JSONPObject(functionName, object));  
        }  
  
        /** 
         * 設定是否使用Enum的toString函數來讀寫Enum, 
         * 為False時時使用Enum的name()函數來讀寫Enum, 默認為False. 
         * 注意本函數一定要在Mapper創建後, 所有的讀寫動作之前調用. 
         */  
        public JsonMapper enableEnumUseToString() {  
            this.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);  
            this.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);  
            return this;  
        }  
  
        /** 
         * 支持使用Jaxb的Annotation，使得POJO上的annotation不用与Jackson耦合。 
         * 默认会先查找jaxb的annotation，如果找不到再找jackson的。 
         */  
        public JsonMapper enableJaxbAnnotation() {  
            JaxbAnnotationModule module = new JaxbAnnotationModule();  
            this.registerModule(module);  
            return this;  
        }  
  
        /** 
         * 允许单引号 
         * 允许不带引号的字段名称 
         */  
        public JsonMapper enableSimple() {  
            this.configure(Feature.ALLOW_SINGLE_QUOTES, true);  
            this.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);  
            return this;  
        }  
          
        /** 
         * 取出Mapper做进一步的设置或使用其他序列化API. 
         */  
        public ObjectMapper getMapper() {  
            return this;  
        }  
  
        /** 
         * 对象转换为JSON字符串 
         * @param object 
         * @return 
         */  
        public static String toJsonString(Object object){  
            return JsonMapper.getInstance().toJson(object);  
        }  
          
        /** 
         * JSON字符串转换为对象 
         * @param jsonString 
         * @param clazz 
         * @return 
         */  
        public static <T> T fromJsonString(String jsonString, Class<T> clazz){  
            return JsonMapper.getInstance().fromJson(jsonString, clazz);  
        }  
          
          
        /** 
         * 将obj对象转换成 class类型的对象 
         * @param obj 
         * @param clazz 
         * @return 
         */  
        public static <T> T parseObject(Object obj, Class<T> clazz){  
            return JSON.parseObject(JSON.toJSONString(obj), clazz);  
        }  
          
}

lanmei618
关注
基于 RedisTemplate 实现的 RedisUtil 工具类
洛阳泰山的博客
12-15 2009
RedisUtil 代码如下 import java.io.Serializable; import java.nio.charset.StandardCharsets; import java.time.Duration; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Date; import java.util.HashSet; impor..
配置RedisTemplate以及编写工具类
qq_42476834的博客
06-03 1065
配置RedisTemplate以及编写工具类
RedisTemplate工具类
01-19
基于spring和redis的redisTemplate工具类 针对所有的hash 都是以h开头的方法 针对所有的Set 都是以s开头的方法 针对所有的List 都是以l开头的方法
Redis和Spring的整合
weixin_34184561的博客
12-11 139
因为经常用到几个工具类，因此备份一下，后续可以直接copy过去 spring配置 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> <property name="maxIdle" value="${redis.pool.maxI...
java缓存工具类（CacheUtils）
最新发布
Flying_Fish_roe的博客
10-02 1094
CacheUtils是一个Java缓存工具类，用于简化在应用中使用缓存的操作。它提供了一组静态方法，用于存储、获取和删除缓存数据。存储缓存数据：通过put方法可以将数据存储到缓存中。可以指定一个键（key）来标识数据，并设置一个过期时间（expiration），以确保缓存数据在一定时间后自动失效。获取缓存数据：通过get方法可以根据指定的键获取缓存数据。如果缓存数据已过期或不存在，则返回null。删除缓存数据：通过remove方法可以根据指定的键从缓存中删除数据。如果指定的键不存在，则操作无效。
基于RedisTemplate封装的工具类
花开的博客
06-26 782
基于RedisTemplate封装的工具类 期望简化redisTemplate的操作 package com.huakai.utils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.data.redis.core.RedisTemplate;
RedisTemplate实现常用数据的缓存存储操作
qq_42390993的博客
05-20 392
RedisTemplate常用工具类
Spring boot项目redisTemplate实现轻量级消息队列的方法
08-26
主要给大家介绍了关于Spring boot项目redisTemplate实现轻量级消息队列的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
redistemplate封装工具类
07-29
RedisTemplate封装工具类是一个用于简化Redis操作的工具类。它提供了一些方法来方便地进行Redis的操作，包括将任意Java对象序列化为json并存储在string类型的key中，设置TTL过期时间，处理缓存击穿问题，查询缓存并...
Redis缓存穿透、缓存击穿解决方案及工具类
m0_64656436的博客
06-29 501
Redis缓存穿透、缓存击穿解决方案及工具类
redistemplate 缓存时间
05-17
RedisTemplate 是 Spring 提供的一个操作 Redis 的工具类，它提供了对 Redis 的基本操作，包括存储、读取、删除等。在使用 RedisTemplate 进行缓存时，可以使用 `expire` 方法来设置缓存的时间，例如： ```java ...
Redis缓存过期策略
qq_41194023的博客
05-29 4042
基于时间的过期策略通过设置生存时间来实现，而基于LRU算法的淘汰机制则根据访问频率和时间排序来删除最近没有使用的key。定期删除是与惰性删除相对应的一种过期策略，它会每隔一段时间主动检查过期 key，并删除过期的 key。与惰性删除不同，定期删除会消耗一定的CPU资源和IO资源，但相对惰性删除而言，它可以更快的将大量过期 key 删除掉。它不会把所有的过期 key 都删除掉，而是等到有客户端来查询这个 key 的时候才检查该 key 是否已过期，并在发现过期的情况下删除该 key。
StringRedisTemplate常用操作及RedisUtils工具类
凡是过往，皆为序章
03-25 3513
stringRedisTemplate的一些常用操作： stringRedisTemplate.opsForValue().set("test", "100",60*10,TimeUnit.SECONDS);//向redis里存入数据和设置缓存时间 stringRedisTemplate.boundValueOps("test").increment(-1);//val做-1操作 st...
Redis五种基本数据类型实践
qq_40537587的博客
03-29 766
opsForValue和boundValueOps在操作目的上没有什么区别，仅仅是boundValueOps提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations。先获取对应类型的数据操作对象。
基于spring的redisTemplate的缓存工具类
Flyer的后花园
07-20 3202
1、spring相关配置如下： Xml代码           bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">       property name="maxIdle" value="${redis.pool.maxIdle}" />        property nam
StringRedisTemplate操作redis数据及与RedisTemplate区别点
qq_43612779的博客
08-11 744
本文是为了个人学习使用，原链接地址：https://blog.csdn.net/qq_25135655/article/details/80357137 https://www.cnblogs.com/slowcity/p/9002660.html StringRedisTemplate与RedisTemplate区别点 1.两者的关系是StringRedisTemplate继承RedisTemplate。 2.两者的数据是不共通的也就是说StringRedisTemplate只能管理StringRedis
redis基础命令
weixin_53585291的博客
03-29 710
Redis 支持多数据库， Redis 在没有任何改动的情况下默认包含 16 个数据库， 数据库名称是用数字 0-15 来依次命名的。使用 Select 命令可以进行 Redis 的多数据库之间的切换，命令格式为select index,其中 index 表示数据库的序号。其命令格式与rename 的命令格式除命令关键字不同外基本相同， renamenx 源 key 目标 key。使用rename 命令进行重命名时， 无论目标 key 是否存在都进行重命名， 且源 key 的值会覆盖目。
史上最全的RedisTemplate和StringRedisTemplate以及Jedis的入门使用讲解
热门推荐
weixin_44012722的博客
04-23 1万+
RedisTemplate和StringRedisTemplate的入门使用讲解 如果你的业务不这么复杂，比较简单要求快速开发可以使用 SpringCache它是基于spring-boot-starter-data-redis的依赖开发的框架具体如何使用看我这篇博客https://blog.csdn.net/weixin_44012722/article/details/105655417 但是如...
详细比较StringRedisTemplate和RedisTemplate的区别及使用方法，及解决融合使用方法
阿啄debugIT
03-09 9089
前言 感觉StringRedisTemplate和RedisTemplate非常的相识，到底有什么区别和联系呢？点开idea，打开其依赖关系，可以看出只需使用maven依赖包spring-boot-starter-data-redis，然后在service中注入StringRedisTemplate或者RedisTemplate即可使用。 从下图StringRedisTemplate继承了RedisTemplate,所以两者对Redis的操作方法具有相同之处 实验软件：RedisDesktopMa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值