redis缓存数据库详解(四)：redis与springboot整合

最新推荐文章于 2025-04-07 21:33:34 发布

明天就不写java了

最新推荐文章于 2025-04-07 21:33:34 发布

阅读量436

点赞数 1

分类专栏： redis 文章标签： redis

本文链接：https://blog.youkuaiyun.com/LLstudyJava/article/details/104625827

版权

redis 专栏收录该内容

6 篇文章

订阅专栏

作为一个稀有的Java妹子，所写的所有博客都只是当作自己的笔记，留下证据自己之前是有用心学习的～哈哈哈哈（如果有不对的地方，也请大家指出，不要悄悄咪咪的不告诉我）

概述

在之前的一篇文章中介绍了redis的数据结构，以及每种数据结构对应的命令，这些命令是通过redis-cli连接redis服务器后，直接在控制台中输入的。所以本片文章介绍怎样实现在代码里操作redis。

一、引入依赖

<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

二、配置属性

# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379  
# Redis服务器连接密码（默认为空）
spring.redis.password=

三、配置类

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * retemplate相关配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

四、配置服务类

@Component
public class RedisService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Autowired
    private ListOperations listOperations;

    @Autowired
    private ZSetOperations zSetOperations;

    /**
     * 是否存在key
     * @param key
     * @return
     */
    public boolean hasKey(String key){
        return redisTemplate.hasKey(key);
    }

    /**
     *
     * @param pattern
     * @return
     */
    public Set<String> keys(String pattern){
        return redisTemplate.keys(pattern);
    }


    /**
     * 更换key的名字
     * @param oldKey
     * @param newKey
     */
    public void rename(String oldKey,String newKey){
        redisTemplate.rename(oldKey,newKey);
    }

    //########################String相关的操作########################
    /**
     * 添加数据
     * @param key
     * @param value
     */
    public void set(String key,String value){
        redisTemplate.opsForValue().set(key,value);
    }

    /**
     * 添加数据并设置过期时间
     * @param key
     * @param value
     * @param time
     */
    public void set(String key,String value,long time){
        redisTemplate.opsForValue().set(key,value,time,TimeUnit.MICROSECONDS);
    }

    /**
     * 获取数据
     * @param key
     * @return
     */
    public Object get(String key){
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除数据
     * @param key
     */
    public void del(String key){
        redisTemplate.delete(key);
    }
    /**
     * 在对应key的value后面追加值
     * @param key
     * @param value
     */
    public void append(String key,String value){
        redisTemplate.opsForValue().append(key,value);
    }

    /**
     * 使对应key的value减少num或者1
     * @param key
     * @param num
     */
    public void decrement(String key,Long num){
        if(num==null){
            redisTemplate.opsForValue().decrement(key);
        }else {
            redisTemplate.opsForValue().decrement(key,num);
        }

    }

    /**
     * 使对应key的value增加num或者1
     * @param key
     */
    public void increment(String key,Object num){
        if(num==null){
            redisTemplate.opsForValue().increment(key);
        }else if(String.valueOf(num).contains(".")){
            redisTemplate.opsForValue().increment(key,Double.parseDouble(String.valueOf(num)));
        }else {
            redisTemplate.opsForValue().increment(key,Long.parseLong(String.valueOf(num)));
        }

    }

    /**
     * 获取多个key对应的value的集合
     * @param collection
     * @return
     */
    public List<String> multiGet(Collection collection){
        return redisTemplate.opsForValue().multiGet(collection);
    }

    /**
     * 一次性设置多个值
     * @param map
     */
    public void multiSet(Map<String,String> map){
        redisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 获取key对应的value的字符串长度
     * @param key
     * @return
     */
    public long size(String key){
        return redisTemplate.opsForValue().size(key);
    }

    /**
     * 添加数据，并且返回value
     * @param key
     * @param value
     * @return
     */
    public String getAndSet(String key,String value){
        return redisTemplate.opsForValue().getAndSet(key,value);
    }

    /**
     * 当key不存在时添加数据，否则什么也不做
     * @param key
     * @param value
     * @return
     */
    public boolean setIfAbsent(String key,String value){
        return redisTemplate.opsForValue().setIfAbsent(key,value);
    }

    /**
     * 当key存在时，更新key的value
     * @param key
     * @param value
     * @return
     */
    public boolean setIfPresent(String key,String value){
        return redisTemplate.opsForValue().setIfPresent(key,value);
    }

    //########################list集合相关的操作########################
    /**
     * 在集合头部添加元素
     * @param key
     * @param value
     */
    public void lpush(Object key, Object value){
        listOperations.leftPush(key,value);
    }

    /**
     * 集合头部添加若干元素
     * @param key
     * @param collection
     */
    public void lpushAll(Object key,Collection collection){
        listOperations.leftPushAll(key,collection);
    }
    /**
     * 移除集合尾部元素
     * @param key
     */
    public void rpop(Object key){
        listOperations.rightPop(key);
    }

    /**
     * 获取集合中某下标的数据
     * @param key
     * @param index
     * @return
     */
    public Object index(Object key,long index){
        return listOperations.index(key,index);
    }

    /**
     * 获取集合从起始位置-终止位置的所有元素
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List listRange(Object key,long start,long end){
        return listOperations.range(key,start,end);
    }

    /**
     * 返回集合的长度
     * @param key
     * @return
     */
    public long listSize(Object key){
        return listOperations.size(key);
    }
     /**
     * 阻塞的获取元素
     * @param key
     * @param time
     * @return
     */
    public Object brpop(Object key,long time){
        return listOperations.rightPop(key,time,TimeUnit.SECONDS);
    }


    //########################zset集合相关的操作########################
    /**
     * 添加元素
     * @param key
     * @param value
     * @param score
     */
    public void addZset(Object key,Object value,double score){
        zSetOperations.add(key,value,score);
    }

    public void incrementScore(Object key, Object value,double score){
        zSetOperations.incrementScore(key,value,score);
    }

    /**
     * 获取集合从起始位置-结束位置的所有元素
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set zsetRange(Object key,long start,long end){
        return zSetOperations.range(key,start,end);

    }

    /**
     * 获取集合的长度
     * @param key
     * @return
     */
    public long zSize(Object key){
        return zSetOperations.size(key);
    }

    /**
     * 移除元素
     * @param key
     * @param value
     */
    public void zsetRemove(Object key,Object value){
        zSetOperations.remove(key,value);
    }
}

五、示例

举例其中几个方法

1.set

 public void set(String key,String value,long time){
        redisTemplate.opsForValue().set(key,value);
    }
public void testRedisService() {
        redisService.set("test","test");
}

查询redis

127.0.0.1:6379> get test
"test"

2.increment

可以递增1，指定整数或者浮点数

public void increment(String key,Object num){
        if(num==null){
            redisTemplate.opsForValue().increment(key);
        }else if(String.valueOf(num).contains(".")){
            redisTemplate.opsForValue().increment(key,Double.parseDouble(String.valueOf(num)));
        }else {
            redisTemplate.opsForValue().increment(key,Long.parseLong(String.valueOf(num)));
        }

    }
//当age不存在时，直接初始化为0，并且将值增加指定数值
redisService.increment("age","5.9");

一开始没有age，查询redis

127.0.0.1:6379> get age
"5.9"

3.leftPush

//添加一个
public void lpush(Object key, Object value){
        listOperations.leftPush(key,value);
    }
//添加多个
public void lpushAll(Object key,Collection collection){
       listOperations.leftPushAll(key,collection);
}

redisService.lpush("mylist","haha");
List<String> list = new ArrayList<>();
list.add("xixi");
list.add("heihei");
redisService.lpushAll("mylist",list);

结果：

127.0.0.1:6379> lrange mylist 0 -1
1) "\"heihei\""
2) "\"xixi\""
3) "\"haha\""

4.rightPop

public void rpop(Object key){
        listOperations.rightPop(key);
    }
    
redisService.rpop("mylist");

结果：

127.0.0.1:6379> lrange mylist 0 -1
1) "\"heihei\""
2) "\"xixi\""

5.add

public void addZset(Object key,Object value,double score){
        zSetOperations.add(key,value,score);
    }
    
redisService.addZset("myset","hh",3);

结果：

127.0.0.1:6379> zrange myset 0 -1
1) "\"hh\""

6.remove

public void zsetRemove(Object key,Object value){
        zSetOperations.remove(key,value);
    }
 redisService.zsetRemove("myset","hh");

结果：

127.0.0.1:6379> zrange myset 0 -1
(empty list or set)