springboot整合Redis

最新推荐文章于 2023-04-17 13:33:32 发布
最新推荐文章于 2023-04-17 13:33:32 发布
阅读量247 收藏 1
点赞数
分类专栏： java springboot redis 数据库 文章标签： java redis springboot 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36254947/article/details/90723863
版权
java 同时被 3 个专栏收录
15 篇文章 0 订阅
订阅专栏
springboot
15 篇文章 0 订阅
订阅专栏
数据库
7 篇文章 0 订阅
订阅专栏

文章目录

springboot整合Redis

1.x

  • pom
       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
  • yml
#--------redis
#redis的数据库缩影,默认0
spring.redis.database=3
#服务器地址:
spring.redis.host=127.0.0.1
#服务器连接端口
spring.redis.port=6379
#连接密码,默认空
spring.redis.password=123456
#最大连接数(负值表示没有显示)
spring.redis.pool.max-active=1000
#最大阻塞等待时间(负值表示没有显示)
spring.redis.pool.max-wait=-1
#最大空闲连接
spring.redis.pool.max-idle=10
#最小空闲连接
spring.redis.pool.min-idle=2
#连接超时时间(ms)
spring.redis.timeout=0
  • redis配置:RedisConfig
package com.ucare.ucareschedule.utils;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
 * 缓存管理（注解用）
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * 生成key的策略
     *
     * @return
     */
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
    /**
     * 管理缓存
     *
     * @param redisTemplate
     * @return
     */
    @SuppressWarnings("rawtypes")
    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
        // 设置缓存过期时间
        // rcm.setDefaultExpiration(60);//秒
        // 设置value的过期时间
        Map<String, Long> map = new HashMap<String, Long>();
        map.put("test", 60L);
        rcm.setExpires(map);
        return rcm;
    }
    /**
     * RedisTemplate配置
     * 
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate template = new StringRedisTemplate(factory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
                Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setValueSerializer(jackson2JsonRedisSerializer);// 如果key是String
             // 需要配置一下StringSerializer,不然key会乱码
             // /XX/XX
        template.afterPropertiesSet();
        return template;
    }
}
  • 工具类
package com.ucare.ucareschedule.utils;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
​
/**
 * redicache 工具类
 * 
 */
@SuppressWarnings("unchecked")
@Component
public class RedisUtil {
​
    private static final Logger log = LoggerFactory.getLogger(RedisUtil.class);
​
    @SuppressWarnings("rawtypes")
    @Autowired
    private RedisTemplate redisTemplate;
​
    /**
     * 批量删除对应的value
     * 
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
​
    /**
     * 批量删除key
     * 
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
​
    /**
     * 删除对应的value
     * 
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
​
    /**
     * 判断缓存中是否有对应的value
     * 
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
​
    /**
     * redisTemplate.opsForValue();//操作字符串 redisTemplate.opsForHash();//操作hash
     * redisTemplate.opsForList();//操作list redisTemplate.opsForSet();//操作set
     * redisTemplate.opsForZSet();//操作有序set
     */
​
    /**
     * 读取缓存
     * 
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
​
    /**
     * 写入缓存
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            log.error("redis Set Exception", e);
        }
        return result;
    }
​
    /**
     * 写入缓存 ， +有效時間
     * 
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.error("redis Set with expireTime Exception", e);
        }
        return result;
    }
​
    /**
     * value是list类型 leftPush写入缓存
     */
    public boolean leftPush(final String key, Object value) {
        boolean result = false;
        try {
            ListOperations<Serializable, Object> listops = redisTemplate.opsForList();
            listops.leftPush(key, value);
            result = true;
        } catch (Exception e) {
            log.error("leftPush",e);
        }
        return result;
    }
​
    /**
     * value是list类型 rightPush写入缓存
     */
    public boolean rightPush(final String key, Object value) {
        boolean result = false;
        try {
            ListOperations<Serializable, Object> listops = redisTemplate.opsForList();
            listops.rightPush(key, value);
            result = true;
        } catch (Exception e) {
            log.error("rightPush",e);
        }
        return result;
    }
​
    /**
     * value是list类型 读取缓存
     * 
     * @param key
     * @return
     */
    public List<Object> getList(final String key, int start, int end) {
        List<Object> result = null;
        ListOperations<Serializable, Object> listops = redisTemplate.opsForList();
        result = listops.range(key, start, end);
        return result;
    }
​
    /**
     * value是hash 写入缓存
     */
    public boolean setHash(final String key, Object HK, Object HV) {
        boolean result = false;
        try {
            HashOperations<Serializable, Object, Object> hashops = redisTemplate.opsForHash();
            hashops.put(key, HK, HV);
            result = true;
        } catch (Exception e) {
            log.error("setHash",e);
        }
        return result;
    }
​
    /**
     * value是hash 读取缓存
     * 
     * @param key
     * @return
     */
    public Object getHash(final String key, Object HK) {
        Object result = null;
        HashOperations<Serializable, Object, Object> hashops = redisTemplate.opsForHash();
        result = hashops.get(key, HK);
        return result;
    }
​
    /**
     * value是set 写入缓存
     */
    public boolean setSet(final String key, Object value) {
        boolean result = false;
        try {
            SetOperations<Serializable, Object> setops = redisTemplate.opsForSet();
            setops.add(key, value);
            result = true;
        } catch (Exception e) {
            log.error("setSet",e);
        }
        return result;
    }
​
    /**
     * value是set 读取缓存
     * 
     * @param key
     * @return
     */
    public Set<Object> getSet(final String key) {
        Set<Object> result = null;
        SetOperations<Serializable, Object> setops = redisTemplate.opsForSet();
        result = setops.members(key);
        return result;
    }
​
    /**
     * value是sorted set 写入缓存
     */
    public boolean sortedSet(final String key, Object value, double score) {
        boolean result = false;
        try {
            ZSetOperations<Serializable, Object> zsetops = redisTemplate.opsForZSet();
            zsetops.add(key, value, score);
            result = true;
        } catch (Exception e) {
            log.error("sortedSet",e);
        }
        return result;
    }
​
    /**
     * value是sorted set 读取缓存
     * 
     * @param key
     * @return
     */
    public Set<Object> getSortedSet(final String key, long start, long end) {
        Set<Object> result = null;
        ZSetOperations<Serializable, Object> zsetops = redisTemplate.opsForZSet();
        result = zsetops.range(key, start, end);
        return result;
    }
​
}
  • 测试
    @Autowired
    private RedisUtil redisUtil;
    
    @Test
    public void  edit() {
        redisUtil.set("aa2", "1237eeeeezzh中89");
        System.out.println(redisUtil.get("aa2"));
    }

2.x

  • pom
<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
  • yml
spring:
  redis:
    host: localhost
    port: 6379
    password: 123456
    jedis:
      pool:
        max-active: 1000
        max-wait: -1
        max-idle: 10
        min-idle: 2
    lettuce:
      pool:
        max-active: 1000
        max-wait: -1
        max-idle: 10
        min-idle: 2
        shutdown-timeout: 100ms
  cache:
    type: redis
  • 配置
package net.cc.schedule.redis.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
​
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
​
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
​
/**
 * Redis 配置类
 *
 * @author Leon
 * @version 2018/6/17 17:46
 */
@Configuration
// 必须加，使配置生效
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
​
    /**
     * Logger
     */
    private static final Logger lg = LoggerFactory.getLogger(RedisConfig.class);
​
​
    @Autowired
    private JedisConnectionFactory jedisConnectionFactory;
​
    @Bean
    @Override
    public KeyGenerator keyGenerator() {
        //  设置自动key的生成规则，配置spring boot的注解，进行方法级别的缓存
        // 使用：进行分割，可以很多显示出层级关系
        // 这里其实就是new了一个KeyGenerator对象，只是这是lambda表达式的写法，我感觉很好用，大家感兴趣可以去了解下
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(":");
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(":" + String.valueOf(obj));
            }
            String rsToUse = String.valueOf(sb);
            lg.info("自动生成Redis Key -> [{}]", rsToUse);
            return rsToUse;
        };
    }
​
    @Bean
    @Override
    public CacheManager cacheManager() {
        // 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，我这里默认没有配置
        lg.info("初始化 -> [{}]", "CacheManager RedisCacheManager Start");
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
                .RedisCacheManagerBuilder
                .fromConnectionFactory(jedisConnectionFactory);
        return builder.build();
    }
​
    @Bean
    public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory ) {
        //设置序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        RedisSerializer stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer); // key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer); // value序列化
        redisTemplate.setHashKeySerializer(stringSerializer); // Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer); // Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
​
    @Override
    @Bean
    public CacheErrorHandler errorHandler() {
        // 异常处理，当Redis发生异常时，打印日志，但是程序正常走
        lg.info("初始化 -> [{}]", "Redis CacheErrorHandler");
        CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
            @Override
            public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
                lg.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
            }
​
            @Override
            public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
                lg.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
            }
​
            @Override
            public void handleCacheEvictError(RuntimeException e, Cache cache, Object key)    {
                lg.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
            }
​
            @Override
            public void handleCacheClearError(RuntimeException e, Cache cache) {
                lg.error("Redis occur handleCacheClearError：", e);
            }
        };
        return cacheErrorHandler;
    }
​
    /**
     * 此内部类就是把yml的配置数据，进行读取，创建JedisConnectionFactory和JedisPool，以供外部类初始化缓存管理器使用
     * 不了解的同学可以去看@ConfigurationProperties和@Value的作用
     *
     */
    @ConfigurationProperties
    class DataJedisProperties{
        @Value("${spring.redis.host}")
        private  String host;
        @Value("${spring.redis.password}")
        private  String password;
        @Value("${spring.redis.port}")
        private  int port;
        @Value("${spring.redis.timeout}")
        private  int timeout;
        @Value("${spring.redis.jedis.pool.max-idle}")
        private int maxIdle;
        @Value("${spring.redis.jedis.pool.max-wait}")
        private long maxWaitMillis;
​
        @Bean
        JedisConnectionFactory jedisConnectionFactory() {
            lg.info("Create JedisConnectionFactory successful");
            JedisConnectionFactory factory = new JedisConnectionFactory();
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout);
            factory.setPassword(password);
            return factory;
        }
        @Bean
        public JedisPool redisPoolFactory() {
            lg.info("JedisPool init successful，host -> [{}]；port -> [{}]", host, port);
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
​
            JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);
            return jedisPool;
        }
    }
​
}
  • 工具类
package net.cc.schedule.redis.impl;
​
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
​
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
​
import net.cc.schedule.redis.inter.RedisInter;
​
/**
 * 
 * @desc redis实现类
 * @author zhangjing
 * @date 2018年12月4日 下午5:42:34
 */
@SuppressWarnings("unchecked")
@Component
public class RedisImpl implements RedisInter {
​
    private static final Logger log = LoggerFactory.getLogger(RedisImpl.class);
​
    @SuppressWarnings("rawtypes")
    @Autowired
    private RedisTemplate redisTemplate;
​
    /**
     * 批量删除对应的value
     * 
     * @param keys
     */
    @Override
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
​
    /**
     * 批量删除key
     * 
     * @param pattern
     */
    @Override
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
​
    /**
     * 删除对应的value
     * 
     * @param key
     */
    @Override
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
​
    /**
     * 判断缓存中是否有对应的value
     * 
     * @param key
     * @return
     */
    @Override
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
​
    /**
     * redisTemplate.opsForValue();//操作字符串 redisTemplate.opsForHash();//操作hash
     * redisTemplate.opsForList();//操作list redisTemplate.opsForSet();//操作set
     * redisTemplate.opsForZSet();//操作有序set
     */
​
    /**
     * 读取缓存
     * 
     * @param key
     * @return
     */
    @Override
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
​
    /**
     * 写入缓存
     * 
     * @param key
     * @param value
     * @return
     */
    @Override
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            log.error("redis Set Exception", e);
        }
        return result;
    }
​
    /**
     * 写入缓存 ， +有效時間
     * 
     * @param key
     * @param value
     * @return
     */
    @Override
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            log.error("redis Set with expireTime Exception", e);
        }
        return result;
    }
​
    /**
     * value是list类型 leftPush写入缓存
     */
    @Override
    public boolean leftPush(final String key, Object value) {
        boolean result = false;
        try {
            ListOperations<Serializable, Object> listops = redisTemplate.opsForList();
            listops.leftPush(key, value);
            result = true;
        } catch (Exception e) {
            log.error("leftPush", e);
        }
        return result;
    }
​
    /**
     * value是list类型 rightPush写入缓存
     */
    @Override
    public boolean rightPush(final String key, Object value) {
        boolean result = false;
        try {
            ListOperations<Serializable, Object> listops = redisTemplate.opsForList();
            listops.rightPush(key, value);
            result = true;
        } catch (Exception e) {
            log.error("rightPush", e);
        }
        return result;
    }
​
    /**
     * value是list类型 读取缓存
     * 
     * @param key
     * @return
     */
    @Override
    public List<Object> getList(final String key, int start, int end) {
        List<Object> result = null;
        ListOperations<Serializable, Object> listops = redisTemplate.opsForList();
        result = listops.range(key, start, end);
        return result;
    }
​
    /**
     * value是hash 写入缓存
     */
    @Override
    public boolean setHash(final String key, Object HK, Object HV) {
        boolean result = false;
        try {
            HashOperations<Serializable, Object, Object> hashops = redisTemplate.opsForHash();
            hashops.put(key, HK, HV);
            result = true;
        } catch (Exception e) {
            log.error("setHash", e);
        }
        return result;
    }
​
    /**
     * value是hash 读取缓存
     * 
     * @param key
     * @return
     */
    @Override
    public Object getHash(final String key, Object HK) {
        Object result = null;
        HashOperations<Serializable, Object, Object> hashops = redisTemplate.opsForHash();
        result = hashops.get(key, HK);
        return result;
    }
​
    /**
     * value是set 写入缓存
     */
    @Override
    public boolean setSet(final String key, Object value) {
        boolean result = false;
        try {
            SetOperations<Serializable, Object> setops = redisTemplate.opsForSet();
            setops.add(key, value);
            result = true;
        } catch (Exception e) {
            log.error("setSet", e);
        }
        return result;
    }
​
    /**
     * value是set 读取缓存
     * 
     * @param key
     * @return
     */
    @Override
    public Set<Object> getSet(final String key) {
        Set<Object> result = null;
        SetOperations<Serializable, Object> setops = redisTemplate.opsForSet();
        result = setops.members(key);
        return result;
    }
​
    /**
     * value是sorted set 写入缓存
     */
    @Override
    public boolean sortedSet(final String key, Object value, double score) {
        boolean result = false;
        try {
            ZSetOperations<Serializable, Object> zsetops = redisTemplate.opsForZSet();
            zsetops.add(key, value, score);
            result = true;
        } catch (Exception e) {
            log.error("sortedSet", e);
        }
        return result;
    }
​
    /**
     * value是sorted set 读取缓存
     * 
     * @param key
     * @return
     */
    @Override
    public Set<Object> getSortedSet(final String key, long start, long end) {
        Set<Object> result = null;
        ZSetOperations<Serializable, Object> zsetops = redisTemplate.opsForZSet();
        result = zsetops.range(key, start, end);
        return result;
    }
}
  • 测试
    @Autowired
    private RedisImpl redisUtil;
    @Test
    public void  edit() {
        redisUtil.set("aa2", "1237eeeeezzh中89");
        System.out.println(redisUtil.get("aa2"));
    }
ziyue7575
关注
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
redis，@Cacheable报错和二进制问题
wasd986523的博客
12-01 1021
代码上报错，如时间LocalDateTime，记得加入JsonDeserialize。
走过路过别错过，redis遇到的坑 真的是坑
qq_42719318的博客
09-18 2049
这两天刚刚写完几个工程，然后做后期维护修改的时候发现一个问题，就是这几个项目用的是一个获取第三方的token信息，由于当时着急开发没想太多，现在回头看过来想到一个问题就是token每天最多获取2000次，好在上线期间没出现问题，现在想想万一哪天token获取次数上限了，那么我这个就是一个bug了 随后我就开始进行改动，首先我是想将这个共同的token获取到之后用redis缓存起来，复...
redis序列化
weixin_44338092的博客
04-17 138
【代码】redis序列化。
JetCache中使用Cache注解缓存到远程redis以及踩过的坑
nb7474的博客
11-26 2万+
目前网上关于jetcache的使用大多是基于官网的解释，给初学者造成很大的困扰，这里就将我使用的过程中遇到的坑总结一下。 项目是一个springboot项目，目前需要在一个接口方法上加@cache注解，希望将方法返回的结果连同自定义的key一起存到远程redis中。在实现的过程中遇到了如下的问题： 1. 希望将方法中传入的参数经过处理后做为缓存的key,但是不知道jetcache中spel表...
记录使用JetCache遇到的问题
qq_45163910的博客
07-31 7551
简介 JetCache是一个基于Java的缓存系统封装，提供统一的API和注解来简化缓存的使用。 JetCache提供了比SpringCache更加强大的注解，可以原生的支持TTL、两级缓存、分布式自动刷新，还提供了Cache接口用于手工缓存操作。 当前有四个实现，RedisCache、TairCache（此部分未在github开源）、CaffeineCache(in memory)和一个简易的LinkedHashMapCache(in memory)，要添加新的实现也是非常简单的。 全部特性: 通过统一
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
最新发布
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
**SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
Springboot集成Redis缓存及分布式锁示例
yancaobisi的专栏
07-28 448
redis缓存及分布式锁示例
SpringBoot之整合Redis分析和实现-基于Spring Boot2.0.2版本
热门推荐
瘦子没有夏天
06-20 6万+
背景介绍 公司最近的新项目在进行技术框架升级，基于的Spring Boot的版本是2.0.2，整合Redis数据库。网上基于2.X版本的整个Redis少之又少，中间踩了不少坑，特此把整合过程记录，以供小伙伴们参考。 本文的基于在于会搭建Spring Boot项目的基础上进行的，入门是小白的话，请自行学习相关基础知识，网上或相关书籍很多。 由于我本人对Maven比较熟悉，所以是以Maven进行的...
2021-10-08
qq_43645280的博客
10-08 201
** Redis缓存配置 ** 文章目录Redis缓存配置前言案例 前言 Redis作为分布式缓存使用，缓存配置中需要设置数据的过期时间，对于频繁更改的情况，我们需要设置较短的过期时间。因为数据修改频繁，缓存也会频繁去同步数据库。同样也需要设置序列化方式。还有需要定义key的生成策略，当发生异常的时候，如何抛出异常。这些都是我们需要关注的问题。 Cache作为缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、ConcurrentMapCache等 CacheManager是缓
SpringBoot2.0整合Redis实践详解
小小默：进无止境
08-09 3740
【1】pom依赖 添加redis依赖如下： &amp;lt;!--整合redis--&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;spring-boot-starter-data-red
SpringBoot(2.1.1)集成redis及缓存操作失败的异常处理
青鸟飞鱼
01-10 7685
1.添加spring-boot-starter-data-redis依赖 &lt;!-- Spring Boot Redis依赖 --&gt; &lt;!-- 注意：1.5版本的依赖和2.0的依赖不一样，注意看哦 1.5我记得名字里面应该没有“data”, 2.0必须是“spring-boot-starter-data-redis” 这个才行...
redis单机springboot连接使用
wasd986523的博客
07-01 222
这里是集群其他配置 集群环境https://blog.csdn.net/wasd986523/article/details/107002163 集群代码https://blog.csdn.net/wasd986523/article/details/107062807 单记安装：https://blog.csdn.net/wasd986523/article/details/85331813 redis配置aof：https://blog.csdn.net/wasd986523/article/d
SpringBoot中缓存的使用（基于Redis）
hanxiaozhang的博客
07-17 491
前言：
安装redis教程
F_xiao_chou的博客
09-22 255
RedisRedishttps://redis.io/download#download Redis 安装步骤按照下面命令一行一行的输入 1 下载 wget http://download.redis.io/releases/redis-5.0.5.tar.gz 2 解压 tar xzf redis-5.0.5.tar.gz 3 进入文件夹 cd redis-5.0.5 4 初始化 make 5 安装 make install 6启动服务 src/redis-server 7
Spring Cache与Redis结合使用
流水不腐小夏
11-19 1万+
Spring Cache与Redis结合使用 Spring Cache与Redis结合使用 Redis 创建Spring项目 集成Redis Cache部分代码 前不久做了一个需要查询多，更新少的功能，老司机同事建议用Redis来做缓存，同时结合Spring Cache来做，特来总结下。RedisRedis 是一个高性能key-value数据库，个人感觉就像java中的Map，不过比它更加强大。由
SpringBoot之整合Redis分析和实现
蔡定努
03-09 188
创建Spring Boot项目（2.0.2版本） 利用idea提供的接口进行创建，创建后目录结构如下：(请忽略mybatis.log4j2等相关代码和文件) pom依赖 &lt;!-- Spring Boot Redis依赖 --&gt; &lt;!-- 注意：1.5版本的依赖和2.0的依赖不一样，注意看哦 1.5我记得名字里面应该没有“data”, 2.0必须是“sp...
SpringBoot整合Redis
04-27
好的，下面是SpringBoot整合Redis的步骤： 1. 在pom.xml中引入Redis的依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 2. 在application.properties或application.yml中配置Redis连接信息，例如： ``` spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= spring.redis.database=0 ``` 3. 创建RedisConfig类，配置RedisTemplate和StringRedisTemplate： ``` @Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(redisConnectionFactory); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return redisTemplate; } @Bean public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) { StringRedisTemplate stringRedisTemplate = new StringRedisTemplate(); stringRedisTemplate.setConnectionFactory(redisConnectionFactory); return stringRedisTemplate; } } ``` 4. 在需要使用Redis的地方注入RedisTemplate或StringRedisTemplate，并使用相应方法操作Redis，例如： ``` @Autowired private RedisTemplate<String, Object> redisTemplate; public void set(String key, Object value) { redisTemplate.opsForValue().set(key, value); } public Object get(String key) { return redisTemplate.opsForValue().get(key); } ``` 以上就是SpringBoot整合Redis的基本步骤，希望能够帮到你。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值