springboot配置Redis，并封装工具类

于 2024-10-03 22:54:19 发布
阅读量941 收藏 23
点赞数 15
文章标签： spring boot redis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XINLOVEBO/article/details/142692638
版权

Redis简介

        Redis（Remote Dictionary Server）是一个开源的高性能键值对（Key-Value）数据库。它通常用作数据结构服务器，因为除了基本的字符串键值对存储之外，它还支持更复杂的数据结构，如哈希、列表、集合、有序集合、位图、超日志和地理空间索引等。

以下是Redis的一些关键特性和优势：

  1. 内存存储：Redis将所有数据存储在内存中，这使得它能够提供极高的读写速度。

  2. 持久化：虽然Redis是内存数据库，但它提供了持久化功能，可以将内存中的数据保存到磁盘，以防系统故障导致数据丢失。

  3. 支持数据结构：Redis支持丰富的数据结构，包括字符串、列表、集合、有序集合、散列、位图、超日志和地理空间索引等。

  4. 原子操作：Redis的所有操作都是原子的，这意味着它们可以在并发环境下安全地执行，而不会出现竞态条件。

  5. 发布/订阅：Redis提供了发布/订阅功能，允许客户端订阅频道以接收消息，这对于实现消息系统非常有用。

  6. 事务：Redis支持事务，可以通过MULTI和EXEC命令将多个操作组合成一个事务执行。

  7. Lua脚本：Redis允许用户使用Lua脚本在服务器端执行复杂的逻辑。

  8. 高可用：Redis提供了主从复制和哨兵系统来提高数据的可用性和容错能力。

  9. 分布式：Redis支持分布式数据存储，可以通过Redis Cluster实现数据的自动分片和高可用。

  10. 性能：Redis的性能非常高，可以处理大量的并发请求，是许多实时应用程序的理想选择。

  11. 简单易用：Redis有一个简单的客户端和服务器协议，客户端库丰富，易于使用。

  12. 灵活的过期策略：可以为键设置过期时间，支持灵活的过期策略。

springboot整合Redis的Maven依赖

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

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

</dependencies>

application.yml配置

spring:
  data:
    redis:
      #数据库索引
      database: 0
      #redis 服务器地址
      host: 127.0.0.1
      #redis 端口
      port: 6379
      #redis 密码 默认为空
      password:

配置redisTemplate

/**
 * Redis配置类
 *
 * @author WangWenXin
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        final RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // 设置key的序列化规则
        template.setKeySerializer(new StringRedisSerializer());
        // 设置value的序列化规则
        template.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));

        // 设置hash key的序列化规则
        template.setHashKeySerializer(new StringRedisSerializer());
        // 设置hash value的序列化规则
        template.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));

        template.afterPropertiesSet();
        return template;
    }
}

为什么要重新配置RedisTemplate的序列化和反序列化？

如果不配置序列化和反序列化策略，RedisTemplate默认使用JDK自带的序列化方式，即使用JDK的ObjectOutputStream进行序列化，使用ObjectInputStream进行反序列化。这种方式的问题是，它会将对象序列化成字节流时，会包含一些额外的信息，如类名、字段名等等，导致存储在Redis中的值非常冗余。

因此，为了更高效地使用Redis存储对象，并且减少存储空间的占用，我们通常需要配置RedisTemplate的序列化和反序列化策略，例如使用JSON或者其他更紧凑的序列化方式。这样可以确保对象能够正确地序列化和反序列化存储到Redis中，并且可以在读取时正常还原成原始对象。

Redis工具类

/**
 * Redis 工具类，封装了常用的 Redis 操作方法
 *
 * @author WangWenXin
 */
@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 设置键值对。
     *
     * @param key   键
     * @param value 值
     */
    public void set(String key, Object value) {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        ops.set(key, value);
    }

    /**
     * 设置键值对，并设置过期时间。
     *
     * @param key      键
     * @param value    值
     * @param timeout  过期时间
     * @param timeUnit 时间单位（秒、分钟、小时等）
     */
    public void set(String key, Object value, long timeout, TimeUnit timeUnit) {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        ops.set(key, value, timeout, timeUnit);
    }

    /**
     * 如果键不存在，则设置键值对。
     *
     * @param key   键
     * @param value 值
     * @return 是否设置成功
     */
    public boolean setIfAbsent(String key, Object value) {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        return ops.setIfAbsent(key, value);
    }

    /**
     * 如果键不存在，则设置键值对，并设置过期时间。
     *
     * @param key      键
     * @param value    值
     * @param timeout  过期时间
     * @param timeUnit 时间单位（秒、分钟、小时等）
     * @return 是否设置成功
     */
    public boolean setIfAbsent(String key, Object value, long timeout, TimeUnit timeUnit) {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        return ops.setIfAbsent(key, value, timeout, timeUnit);
    }

    /**
     * 获取键对应的值。
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        ValueOperations<String, Object> ops = redisTemplate.opsForValue();
        return ops.get(key);
    }

    /**
     * 删除指定的键。
     *
     * @param key 键
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

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

    /**
     * 获取键的剩余生存时间。
     *
     * @param key 键
     * @return 剩余生存时间（毫秒）
     */
    public Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.MILLISECONDS);
    }

    /**
     * 设置哈希表中的字段值。
     *
     * @param key   键
     * @param field 字段
     * @param value 值
     */
    public void hset(String key, String field, Object value) {
        HashOperations<String, String, Object> ops = redisTemplate.opsForHash();
        ops.put(key, field, value);
    }

    /**
     * 获取哈希表中的字段值。
     *
     * @param key   键
     * @param field 字段
     * @return 字段值
     */
    public Object hget(String key, String field) {
        HashOperations<String, String, Object> ops = redisTemplate.opsForHash();
        return ops.get(key, field);
    }

    /**
     * 获取哈希表中的所有字段和值。
     *
     * @param key 键
     * @return 字段和值的映射
     */
    public Map<String, Object> hgetAll(String key) {
        HashOperations<String, String, Object> ops = redisTemplate.opsForHash();
        return ops.entries(key);
    }

    /**
     * 删除哈希表中的字段。
     *
     * @param key   键
     * @param field 字段
     */
    public void hdel(String key, String field) {
        HashOperations<String, String, Object> ops = redisTemplate.opsForHash();
        ops.delete(key, field);
    }

    /**
     * 获取集合中的所有元素。
     *
     * @param key 键
     * @return 元素集合
     */
    public Set<Object> sGet(String key) {
        SetOperations<String, Object> ops = redisTemplate.opsForSet();
        return ops.members(key);
    }

    /**
     * 向集合中添加元素。
     *
     * @param key   键
     * @param value 值
     */
    public void sAdd(String key, Object value) {
        SetOperations<String, Object> ops = redisTemplate.opsForSet();
        ops.add(key, value);
    }

    /**
     * 从集合中删除元素。
     *
     * @param key   键
     * @param value 值
     */
    public void sRemove(String key, Object value) {
        SetOperations<String, Object> ops = redisTemplate.opsForSet();
        ops.remove(key, value);
    }

    /**
     * 获取列表中的所有元素。
     *
     * @param key 键
     * @return 元素列表
     */
    public List<Object> lGet(String key) {
        ListOperations<String, Object> ops = redisTemplate.opsForList();
        return ops.range(key, 0, -1);
    }

    /**
     * 向列表中添加元素。
     *
     * @param key   键
     * @param value 值
     */
    public void lPush(String key, Object value) {
        ListOperations<String, Object> ops = redisTemplate.opsForList();
        ops.leftPush(key, value);
    }

    /**
     * 从列表中删除元素。
     *
     * @param key   键
     * @param value 值
     */
    public void lRemove(String key, Object value) {
        ListOperations<String, Object> ops = redisTemplate.opsForList();
        ops.remove(key, 0, value);
    }

    /**
     * 获取列表中的元素数量。
     *
     * @param key 键
     * @return 元素数量
     */
    public long lSize(String key) {
        ListOperations<String, Object> ops = redisTemplate.opsForList();
        return ops.size(key);
    }

    /**
     * 获取集合中的元素数量。
     *
     * @param key 键
     * @return 元素数量
     */
    public long sSize(String key) {
        SetOperations<String, Object> ops = redisTemplate.opsForSet();
        return ops.size(key);
    }

    /**
     * 获取哈希表中的字段数量。
     *
     * @param key 键
     * @return 字段数量
     */
    public long hSize(String key) {
        HashOperations<String, String, Object> ops = redisTemplate.opsForHash();
        return ops.size(key);
    }

    /**
     * 清空哈希表中的所有字段。
     *
     * @param key 键
     */
    public void hClear(String key) {
        HashOperations<String, String, Object> ops = redisTemplate.opsForHash();
        ops.delete(key, (String[]) ops.keys(key).toArray(new String[0]));
    }

    /**
     * 清空集合中的所有元素。
     *
     * @param key 键
     */
    public void sClear(String key) {
        SetOperations<String, Object> ops = redisTemplate.opsForSet();
        ops.remove(key, (Object[]) ops.members(key).toArray());
    }

    /**
     * 清空列表中的所有元素。
     *
     * @param key 键
     */
    public void lClear(String key) {
        ListOperations<String, Object> ops = redisTemplate.opsForList();
        while (ops.size(key) > 0) {
            ops.remove(key, 0, ops.range(key, 0, 0).get(0));
        }
    }
}

 方法说明

基本操作：
set：设置键值对。
set：设置键值对，并设置过期时间。
get：获取键对应的值。
delete：删除指定的键。
exists：判断键是否存在。
getExpire：获取键的剩余生存时间。

setIfAbsent：如果键不存在，则设置键值对。

哈希表操作：
hset：设置哈希表中的字段值。
hget：获取哈希表中的字段值。
hgetAll：获取哈希表中的所有字段和值。
hdel：删除哈希表中的字段。
hSize：获取哈希表中的字段数量。
hClear：清空哈希表中的所有字段。

集合操作：
sGet：获取集合中的所有元素。
sAdd：向集合中添加元素。
sRemove：从集合中删除元素。
sSize：获取集合中的元素数量。
sClear：清空集合中的所有元素。

列表操作：
lGet：获取列表中的所有元素。
lPush：向列表中添加元素。
lRemove：从列表中删除元素。
lSize：获取列表中的元素数量。
lClear：清空列表中的所有元素。

这个名字应该没人用吧
关注
Springboot中Redis工具类配置
KongJHong的博客
04-13 375
Maven工程准备 系统用了默认的springboot构建，版本是2.2.6.RELEASE，导入redis的依赖包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifac...
springboot整合redis
Big Data
08-13 247
Jedis和Lettuce的区别在哪？ 1、Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。 2、Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，如果你不知道Netty也没事，大致意思就是一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。通过异步的方式可以让我们更好地利用系统资源。 既然有这么大的好处，干脆就用了这个，跟上时代的变化。下面新建一个Spri
RedisTemplateUtil spring整合redis 的操作类,精心整合
Carey丶zsh 的博客
01-24 8863
使用 spring-data-redis 整合 redis 后,扫描该类,就可以使用了.在 service 注入方式加入此类即可使用.import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java...
springboot-redis小案例
zxy_a_lion的博客
01-15 318
pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org...
Redis工具类(基于spring boot)
做一个善良的码农
07-09 2326
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; import org.springframework.util....
spring boot-引入Redis并封装redistemplate操作工具类
西京刀客
03-28 2003
springboot引入Redis及其使用案例
SpringBoot 中操作 Redis 及工具类的封装
junkaione的博客
05-19 444
在我们项目开发中总是免不了会使用缓存，Redis现在基本是我们公司中非常常见的缓存方案，包括在用户token的缓存，热点信息的缓存等，这篇文章主要讲讲在SpringBoot项目中如何去操作Redis，及最后工具类的封装。
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
Redis工具类，封装了springboot操作redis的基本方法
10-14
Redis工具类，封装了springboot操作redis的基本方法
SpringBoot实战：整合Redis、mybatis，封装RedisUtils工具类等（附源码）
最新发布
2401_84003839的博客
04-30 658
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。
Redis Java Spring-Boot 操作封装类
01-11
Redis 的 Java Spring-Boot 操作封装类，可以摆脱redisTemplate 那冗长的操作方式，支持全部数据类型的存储和查询。
SpringBoot整合redis及工具类
04-19
本项目代码包括，最基本的SpringBoot2.0,+Swagger-ui,以及redis的测试类，redis各种类型数据存储的工具类以及测试的sql文件
springcloud、springboot中StringRedisTemplate封装.zip
09-02
springcloud、springbootz中StringRedisTemplate封装，支持定时失效，当天失效等
Springboot 整合redis配置类和封装redis服务
洛阳泰山的博客
11-19 1328
spring-boot-starter-data-redis是Spring Boot提供的一个用于集成Redis数据库的启动器（starter）。该启动器提供了与Redis相关的依赖管理、自动配置和常用功能，使得在Spring Boot应用中使用Redis变得更加简单和方便。
SpringBoot整合redis(封装redisUtil类)
qq_43767445的博客
03-13 2537
SpringBoot整合redis(封装redisUtil类) 首先，java操作redis有两种方式操作缓存 第一种是Jedis，这一种是redis官方推荐的面向java的操作的客户端。 第二种是在springboot中，springDataRedis中对JedisApi进行了精密的封装。 而springDataRedis相对于redis来说可以更加方便的更换redis的java客户端，比jed...
【精品】SpringBoot中整合Redis的简单封装及应用
哈
09-22 2416
工具类 为了实际应用中方便工具类的使用，特针对插入值为bytecode和JSON类型分别提代价工具类的两个实现类 key是字符串Value是bytecode的工具类实现类 测试 测试实体类：Province JsonRedisUtilTest 具体存储在Redis中的数据是Json形式的，比如： 具体存储在Redis中的数据是bytecode形式的，比如：
springboot：整合redis封装命令
拒绝熬夜啊的博客
06-24 347
springboot：整合redis封装命令
SpringBoot整合Redis(包含工具类)
半只
07-04 1581
1、SpringBoot pom.xml导入相关依赖依赖 <!--Redis 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependenc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值