spring boot + redis-优快云博客

本文介绍了如何在SpringBoot项目中配置和使用Redis，包括修改配置文件、添加依赖、创建Redis服务类并实现各种缓存操作方法，以及提供测试示例展示了字符串、对象、列表和哈希集的CRUD操作。

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

一、创建spring boot项目
打开IDEA，按图操作
special_time_id_seq
在这里插入图片描述

至此 spring boot + redis 项目创建完成；
二、配置redis
1、将application.properties改为application.yml

2、添加下列配置

server:
  port: 8088

spring:
  redis:
    host: 127.0.0.1
  #Redis服务器连接端口
    port: 6379
  #Redis服务器连接密码（默认为空）
    password: 123456
  #连接池最大连接数（使用负值表示没有限制）
    pool:
      max-active: 8
    #连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: -1
    #连接池中的最大空闲连接
      max-idle: 8
    #连接池中的最小空闲连接
      min-idle: 0
  #连接超时时间（毫秒）
    timeout: 30000

3、创建redis公共类及方法
在这里插入图片描述
拷贝下面的代码，需要的相关jar包在pom.xml中添加

<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>

        <!-- 阿里JSON解析器 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>

package com.example.redisdemo.cache;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author tym
 * @date 2022-08-30 18:44
 */
@Slf4j
@Component
public class CacheService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    private final String DEFAULT_KEY_PREFIX = "";
    private final int EXPIRE_TIME = 1;
    private final TimeUnit EXPIRE_TIME_TYPE = TimeUnit.DAYS;


    /**
     * 数据缓存至redis
     *
     * @param key
     * @param value
     * @return
     */
    public <K, V> void add(K key, V value) {
        try {
            if (value != null) {
                redisTemplate
                        .opsForValue()
                        .set(DEFAULT_KEY_PREFIX + key, JSON.toJSONString(value));
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("数据缓存至redis失败");
        }
    }

    /**
     * 数据缓存至redis并设置过期时间
     *
     * @param key
     * @param value
     * @return
     */
    public <K, V> void add(K key, V value, long timeout, TimeUnit unit) {
        try {
            if (value != null) {
                redisTemplate
                        .opsForValue()
                        .set(DEFAULT_KEY_PREFIX + key, JSON.toJSONString(value), timeout, unit);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("数据缓存至redis失败");
        }
    }

    /**
     * 写入 hash-set,已经是key-value的键值，不能再写入为hash-set
     *
     * @param key    must not be {@literal null}.
     * @param subKey must not be {@literal null}.
     * @param value  写入的值
     */
    public <K, SK, V> void addHashCache(K key, SK subKey, V value) {
        redisTemplate.opsForHash().put(DEFAULT_KEY_PREFIX + key, subKey, value);
    }

    /**
     * 写入 hash-set,并设置过期时间
     *
     * @param key    must not be {@literal null}.
     * @param subKey must not be {@literal null}.
     * @param value  写入的值
     */
    public <K, SK, V> void addHashCache(K key, SK subKey, V value, long timeout, TimeUnit unit) {
        redisTemplate.opsForHash().put(DEFAULT_KEY_PREFIX + key, subKey, value);
        redisTemplate.expire(DEFAULT_KEY_PREFIX + key, timeout, unit);
    }

    /**
     * 获取 hash-setvalue
     *
     * @param key    must not be {@literal null}.
     * @param subKey must not be {@literal null}.
     */
    public <K, SK> Object getHashCache(K key, SK subKey) {
        return  redisTemplate.opsForHash().get(DEFAULT_KEY_PREFIX + key, subKey);
    }


    /**
     * 从redis中获取缓存数据，转成对象
     *
     * @param key   must not be {@literal null}.
     * @param clazz 对象类型
     * @return
     */
    public <K, V> V getObject(K key, Class<V> clazz) {
        String value = this.get(key);
        V result = null;
        if (!StringUtils.isEmpty(value)) {
            result = JSONObject.parseObject(value, clazz);
        }
        return result;
    }

    /**
     * 从redis中获取缓存数据，转成list
     *
     * @param key   must not be {@literal null}.
     * @param clazz 对象类型
     * @return
     */
    public <K, V> List<V> getList(K key, Class<V> clazz) {
        String value = this.get(key);
        List<V> result = Collections.emptyList();
        if (!StringUtils.isEmpty(value)) {
            result = JSONArray.parseArray(value, clazz);
        }
        return result;
    }

    /**
     * 功能描述：Get the value of {@code key}.
     *
     * @param key must not be {@literal null}.
     * @return java.lang.String
     * @date 2021/9/19
     **/
    public <K> String get(K key) {
        String value;
        try {
            value = redisTemplate.opsForValue().get(DEFAULT_KEY_PREFIX + key);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("从redis缓存中获取缓存数据失败");
        }
        return value;
    }

    /**
     * 删除key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 批量删除key
     */
    public void delete(Collection<String> keys) {
        redisTemplate.delete(keys);
    }

    /**
     * 序列化key
     */
    public byte[] dump(String key) {
        return redisTemplate.dump(key);
    }

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

    /**
     * 设置过期时间
     */
    public Boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 设置过期时间
     */
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key, date);
    }


    /**
     * 移除 key 的过期时间，key 将持久保持
     */
    public Boolean persist(String key) {
        return redisTemplate.persist(key);
    }

    /**
     * 返回 key 的剩余的过期时间
     */
    public Long getExpire(String key, TimeUnit unit) {
        return redisTemplate.getExpire(key, unit);
    }

    /**
     * 返回 key 的剩余的过期时间
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key);
    }
}

三、使用redis
1、添加字符串到redis
在这里插入图片描述

package com.example.redisdemo.cache;

import org.junit.Test;

public class testMain {

    CacheService cacheService;

    /**
     * 功能描述：添加字符串到redis
     */
    @Test
    void add() {
        cacheService.add("你好", 1234123);
    }

}

2、将对象转换成jsonString并存入redis
此次用到了建造者模式，可以学习一下

 /**
     * 功能描述：添加对象至redis
     */
    @Test
    void addObject() {
        TestC test = new TestC.Builder()
                .setId(1232321)
                .setName("小明明")
                .setAge(12)
                .setHeight(1L)
                .build();
        cacheService.add(test.getId(), test);
    }

3、获取对象

 /**
     * 功能描述：获取对象
     */
    @Test
    void getObject() {
        TestC object = cacheService.getObject(123, TestC.class);
        System.out.println("object = " + object);
    }

4、将对象集合转换成jsonString，并设置过期时间存入至redis

/**
     * 功能描述：添加对象集合至redis
     */
    @Test
    void addObjects() {
        ArrayList<TestC> list = new ArrayList<>();
        TestC test =  new TestC.Builder()
                .setId(123)
                .setName("小明明")
                .setAge(12)
                .setHeight(1L)
                .build();
        list.add(test);
        cacheService.add("key", list, 1, TimeUnit.HOURS);
    }

5、获取对象集合

    /**
     * 功能描述：获取对象集合
     */
    @Test
    void getObjects() {
        List<TestC> list = cacheService.getList("key", TestC.class);
        System.out.println("TestC = " + list);
    }

6、添加 hash-set

/**
     * 功能描述：添加 hash-set
     */
    @Test
    void addHashCache() {
        cacheService.addHashCache("hashKey", "key", "value");
    }