springBoot整合redis使用介绍（详细案例）

已于 2023-05-20 22:13:48 修改
阅读量5.9w 收藏
点赞数 79
分类专栏： # SpringBoot # redis 文章标签： redis spring boot spring
于 2021-09-19 22:26:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43811057/article/details/120382906
版权

文章预览：

简介

案例中使用的是StringRedisTemplate至于为什么不用RedisTemplate的原因如下：
实际生产项目当中使用StringRedisTemplate来进行缓存数据的更多；
对于使用RedisTemplate案例的分析

在我们为RedisTemplate指定序列化方式后（key为RedisSerializer.string()，value为GenericJackson2JsonRedisSerializer），我们存储value为实体类对象时，会产生如下现象：
在这里插入图片描述
这是因为，当我们传入的Value为实体类对象的时候，会用 GenericJackson2JsonRedisSerializer序列化器把java对象转为JSON格式，然后再存入Redis库中，在我们使用redisTemplate.opsForValue().get方法获取数据时，通过存入的@class属性，把JSON反序列化成JAVA对象。

这样一来我们在IDEA的控制器上很直观的就可以看到数据，但是也存在了一个缺点->浪费内存，因为我们要存放@class这一段额外的数据来反序列化JSON字符串。

那为了节约内存，我们在处理Value时不使用GenericJackson2JsonRedisSerializer序列化器，使用RedisSerializer.string序列化器。这样一下，我们只需要在存入数据时，手动的把JAVA对象转变为JSON格式字符串，然后取数据时，再把JSON转回JAVA对象就好了。

而StringRedisTemplate它的key和Value默认就是String方式，我们不用自己再去定义RedisTemplate的配置类。

一、创建springboot项目（采用骨架方式）

1.使用 StringRedisTemplate
2.写入 Redis 时,手动把对象序列化为 JSON
3.读取 Redis 时,手动把读取到的 JSON 反序列化为对象

案例源码
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
创建完成；
我们分析下pom文件中内容：
所使用到的关键依赖：

 <!--springBoot集成redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.5.4</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.5.4</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.5.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.75</version>
        </dependency>

二、配置文件

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

三、使用redis

package com.example.redis.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 wxl
 * @date 2021-08-15 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);
    }
}

1、添加字符串到redis

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

结果：
在这里插入图片描述

2、将对象转换成jsonString并存入redis

    /**
     * 功能描述：添加对象至redis
     */
    @Test
    void addObject() {
        User user = User.builder()
                .id(ID)
                .name("小萌")
                .age(AGE)
                .build();
        cacheService.add(user.getId(), user);
    }

结果：在这里插入图片描述

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

    /**
     * 功能描述：添加对象集合至redis
     */
    @Test
    void addObjects() {
        ArrayList<User> users = new ArrayList<>();
        User user = User.builder()
                .id(ID)
                .name("小萌")
                .age(AGE)
                .build();
        users.add(user);
        cacheService.add("key", users, 1, TimeUnit.HOURS);
    }

结果：
在这里插入图片描述

4、获取对象

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

结果：

object = User(id=123, name=小萌, age=12)

5、获取对象集合

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

结果：

users = [User(id=123, name=小萌, age=12)]

6、添加 hash-set

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

结果：
在这里插入图片描述

7、获取 hash-setvalue

   /**
     * 功能描述：获取 hash-set
     */
    @Test
    void getHashCache() {
        Object hashCache = cacheService.getHashCache("hashKey", "key");
        System.out.println("hashCache = " + hashCache);
    }

结果：

hashCache = value

四 案例源码

springBoot整合redis源码

上一篇：SpringDataRedis

伏加特遇上西柚
关注
专栏目录
springboot整合redis的测试案例
11-06
以下是对"springboot整合redis的测试案例"的详细解析。 首先，让我们从环境准备开始。在Spring Boot项目中，我们需要引入Spring Data Redis模块，这可以通过在`pom.xml`文件中添加对应的Maven依赖来完成。根据描述...
SpringBoot整合redis简单例子
silin_Liu
03-19 488
前言 redis是一种noSQL的数据库，以<Key, Value>的形式存储数据，其速度相比MySQL之类的数据库快，相当于内存读写与硬盘读写的差别，所以常常用作缓存。接下来就分别看看再SpringBoot项目中如何使用redis 整合前提： 前提是你已经安装redis，redis的安装这里不再赘述，有需要参考我的另一篇文章。 SpringBoot整合redis 1.引入依赖:...
Spring Boot整合Redis
梁辰兴的博客
06-16 2万+
Redis是一个开源（BSD许可）的、内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件，并提供多种语言的API。Redis支持多种类型的数据结构，如 字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）与范围查询、bitmaps、 hyperloglogs 和 地理空间（geospatial）、索引半径查询。
中间件：SpringBoot集成Redis
最新发布
LiuYuHao_的博客
10-12 1454
在Java中与Redis交互通常涉及使用Jedis或Lettuce这样的客户端库。你需要添加依赖、创建连接对象、执行Redis命令，并在完成后关闭连接。虽然安装、配置和启动Redis服务器本身不涉及Java代码，但你可以使用Java代码来与运行中的Redis实例进行交互。
springboot整合redis
热门推荐
lwj_07的博客
08-10 4万+
创建springboot整合redis工程： 首先我们要知道什么是redis： 三个步骤：补充：RedisTemplate对象提供了各种往redis数据库中存储数据的类型： 代码演示如下所示：注意：下面所有的步骤，要保证Redis数据库是开启的状态，要不然肯定连接不上Redis数据库 第一步： 第二步： 第三步： 又因为我们知道Redis数据库支持多种格式的存储数据形式，因此还可以往Redis数据库中存储哈希类型的数据（哈希类型：就类似于一个key里面又放入一个key，value），因此Redis
Spring Boot中使用Redis
shaopengjie的博客
08-23 9732
1.Redis是基于内存的key-value结构数据库优点：基于内存存储，读写性能高适合存储热点数据（短时间被被大量用户读取的数据）2.NoSQL,泛指非关系型数据库，是关系型数据库的补充3.Redis应用场景：缓存，任务队列，消息队列，分布式锁,下载的redis是源文件，需要进行编译安装，Windows版本百度即可5.Linux下安装Redis安装过程中如果报错：You need tcl x.x or newer in order to run the Redis test。
springboot整合Redis详解完整篇
pengli
12-11 1万+
我们现在项目大都使用springboot，那如何在springboot中加入redis呢？ 主要有以下这几步： 1.需要加入Redis的依赖Jar，代码为： <! -redis依赖 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-redis</artifactId> <v
SpringBoot整合Redis[详细版]
wang20000102的博客
09-04 8588
SpringBoot整合Redis[详细版]Redis是现在最受欢迎的NoSQL数据库之一，Redis是一个使用ANSI C编写的开源。spring-boot-starter-data-redis在SpringBoot中集成了两个模版一个是RedisTemplate，另一个为 StringRedisTemplate而虽然StringRedisTempate帮助我们做了序列化，但是存储数据的时候只能存储Sting类型的数据，而RedisTemplate可以存储Object类型，所以我们一个使用RedisT
SpringBoot2.x整合Redis
02-24
最近在学习SpringBoot2.x整合Redis，在这里和大家分享一下，希望对大家有帮助。Redis是开源免费高性能的key-value数据库。有以下的优势（源于Redis官网）：1.性能极高–Redis能读的速度是110000次/s,写的速度是81000...
案例实战-SpringBoot整合Redis实现缓存分页数据查询
06-19
在本案例实战中，我们将探讨如何使用Spring Boot与Redis集成，以实现缓存分页数据查询，提升应用程序的性能和响应速度。Spring Boot是Java领域一个流行的微服务框架，它简化了Spring应用的初始搭建以及开发过程。而...
Redis分布式锁使用+Redis处理数据并发+springboot整合Redis
03-22
springboot整合Redis实现在分布式情况，使用分布式锁解决数据并发的方案，主要使用Redis提供的setIfAbsent方法实现，并且考虑到了setIfAbsent在极端情况下的多实例同时设置一个key成功的情况。 本案例通过实现对库存...
springboot使用redis
weixin_73310020的博客
04-26 5242
默认有三种方式连接redis.第一种:jedis—传统的项目–ssm第二种:lettuce:---->刚出现没有多久就被springboot整合进来。第三种:springboot连接redis。
SpringBoot教程（十四） | SpringBoot之集成Redis
qq_20236937的博客
04-09 1万+
Redis是我们Java开发中，使用频次非常高的一个nosql数据库，数据以key-value键值对的形式存储在内存中。redis的常用使用场景，可以做缓存，分布式锁，自增序列等，使用redis的方式和我们使用数据库的方式差不多，首先我们要在自己的本机电脑或者服务器上安装一个redis的服务器，通过我们的java客户端在程序中进行集成，然后通过客户端完成对redis的增删改查操作。
SpringBoot整合Redis
Java技术攻略的博客
04-19 2718
Bean// 默认的 RedisTemplate 没有过多的设置，redis 对象都是需要序列化！// 两个泛型都是 Object, Object 的类型，我们后使用需要强制转换 @Bean// 由于 String 是redis中最常使用的类型，所以说单独提出来了一个bean！复制代码首先我们编写一个实体类User@Component@Data//所有的pojo都要序列化复制代码在测试类中测试像Redis存储一个User对象@Test。
芋道 Spring Boot Redis 入门
YHJ
05-07 5278
摘要: 原创出处http://www.iocoder.cn/Spring-Boot/Redis/「芋道源码」欢迎转载，保留摘要，谢谢！ 1. 概述 2. 快速入门 3. 序列化 4. 项目实践 5. 示例补充 6. 尝试 Redisson 666. 彩蛋 本文在提供完整代码示例，可见https://github.com/YunaiV/SpringBoot-Labs的lab-11-spring-data-redis目录。 原创不易，给点个Star嘿，一起冲鸭！ 1. 概述...
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 4859
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
springboot整合redis注解使用
09-01
在Spring Boot中，你可以通过注解来方便地使用Redis。首先，确保你的Spring Boot应用程序中已经添加了Redis的依赖。 接下来，你可以使用`@EnableCaching`注解来开启缓存功能，并且指定使用Redis作为缓存管理器。在你的Spring Boot应用程序的主类上添加如下注解： ```java @EnableCaching @SpringBootApplication public class YourApplication { // ... } ``` 然后，你可以在需要使用缓存的方法上添加`@Cacheable`、`@CachePut`、`@CacheEvict`等注解来指定缓存的行为。 - `@Cacheable`：将方法结果缓存起来。在下次相同参数调用时，将直接从缓存中获取结果，而不执行方法体。 - `@CachePut`：将方法结果更新到缓存中。每次方法被调用时，都会执行方法体，并将结果缓存起来。 - `@CacheEvict`：从缓存中删除指定的缓存条目。 以下是一个示例： ```java @Service public class YourService { @Autowired private YourRepository repository; @Cacheable("yourCacheName") public List<YourObject> getCachedData(String key) { return repository.getData(key); } @CachePut("yourCacheName") public List<YourObject> updateCachedData(String key) { return repository.getData(key); } @CacheEvict("yourCacheName") public void clearCache(String key) { // 缓存清除后，方法体会被执行 } } ``` 在上述示例中，`@Cacheable("yourCacheName")`表示将方法的返回结果缓存起来，并指定缓存名为"yourCacheName"，方法参数作为缓存的键值。`@CachePut("yourCacheName")`表示每次方法调用都会执行方法体，并将结果更新到缓存中。`@CacheEvict("yourCacheName")`表示从缓存中删除指定的缓存条目。 在配置文件中，你还需要配置Redis的连接信息。可以在application.properties或application.yml文件中添加以下配置： ```properties spring.redis.host=localhost spring.redis.port=6379 spring.redis.password=yourpassword (如果有密码的话) ``` 通过以上步骤，你就可以在Spring Boot应用程序中方便地使用Redis进行缓存了。注意，你需要确保已经正确安装和启动了Redis服务器。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值