SpringBoot整合Redis(包含工具类)

已于 2024-06-26 15:39:21 修改
阅读量1.9k 收藏 4
点赞数 2
分类专栏： Redis java 文章标签： redis java spring
于 2020-07-04 10:47:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40739917/article/details/107120277
版权

1、SpringBoot pom.xml导入相关依赖依赖

        <!--Redis 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--json操作工具-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!--连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2、配置Redis连接 application.yml 配置

spring:
#配置redis  测试 使用 1 数据库
  redis:
    database: 1
    host: 127.0.0.1
    port: 6379
    password:
#redis 最大连接数 负数 没有限制
    lettuce:
      pool:
        max-active: -1
        max-wait: 1
        max-idle: 200
        min-idle: 50

3、简单测试操作Redis 

使用@Autowired 就可以获取到由Spring默认装载的 RedisTemplate

@Autowired
	private RedisTemplate<String,String> redisTemplate;

	@Autowired
	private RedisTemplate<String,String> redisTemplate;
	//我使用的是Spring默认序列化方式，key 用String方式存储，Value使用 JSON字符串存储
	//如果要存储其他类型Value 只需要更改序列化方式就行，不使用Spring默认序列化方式

	@Test
	void contextLoads() {

		System.out.println("redisTemplate==>"+redisTemplate);
		//操作String
		redisTemplate.opsForValue().set("object:str1","哈喽啊！树哥");
		System.out.println(redisTemplate.opsForValue().get("object:str1"));
		//操作Hash 单个属性值设置值
		redisTemplate.opsForHash().put("object:map1","name","韩寒");
		//操作Hash 多个属性值设置值
		Map<String,String> map  = new HashMap<>();
		map.put("name","樱桃小丸子");
		map.put("age","18");
		map.put("text","老板，你这樱桃上过大学吗！");
		redisTemplate.opsForHash().putAll("object:map2",map);
		//获取hash值  个人还是喜欢 直接把对象或者集合转为json字符串储存进redis Hash保存，简单
		redisTemplate.opsForHash().get("object:map2","name");

	}

效果图(小提示 redis Key命名 最好使用:可以增加redis数据 可阅读性)

在这里插入图片描述
3、配置自定义序列化 RedisTemplate
在SpringBoot启动类加入 @Bean配置 个人习惯 也可以单独创建一个类 加入注解配置 @Configuration

有哪些序列化器?
GenericToStringSerializer:

可以将任何对象泛化为字符串并序列化

Jackson2JsonRedisSerializer:

跟JacksonJsonRedisSerializer实际上是一样的

JacksonJsonRedisSerializer:

序列化object对象为json字符串

JdkSerializationRedisSerializer:

序列化java对象（被序列化的对象必须实现Serializable接口）

StringRedisSerializer:

简单的字符串序列化

GenericToStringSerializer:

类似StringRedisSerializer的字符串序列化

GenericJackson2JsonRedisSerializer:

类似Jackson2JsonRedisSerializer，但使用时构造函数不用特定的类参考以上序列化,自定义序列化类; 

推荐使用：

得根据场景，一般我key使用StringRedisSerializer，value使用GenericJackson2JsonRedisSerializer。

@Bean
  public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory connectionFactory){
    System.out.println("创建Bean===>RedisTemplate");
    RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
    redisTemplate.setKeySerializer(new StringRedisSerializer());//key 使用String序列化
    redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
    redisTemplate.setConnectionFactory(connectionFactory);
    System.out.println("创建Bean完成===>"+redisTemplate);
    return redisTemplate;
  }

在这里插入图片描述
还是 使用@Autowired 不过这次获取到的是自己定义的 RedisTemplate

使用RediTemaplate工具类操作Redis

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @Author ani
 * @CreateTime $ 2021-08-07
 **/
@Component
@SuppressWarnings("all")
public class redisUtils {
	private final static Logger log = LoggerFactory.getLogger(redisUtils.class);
	@Autowired
	private RedisTemplate redisTemplate;
	
	/**
	 * 指定缓存失效时间
	 *
	 * @param key  键
	 * @param time 时间(秒)
	 * @return
	 */
	public boolean expire(String key, long time) {
		try {
			if (time > 0) {
				redisTemplate.expire(key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "expire", e);
			return false;
		}
	}
	
	/**
	 * 根据key 获取过期时间
	 *
	 * @param key 键 不能为null
	 * @return 时间(秒) 返回0代表为永久有效
	 */
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}
	
	/**
	 * 判断key是否存在
	 *
	 * @param key 键
	 * @return true 存在 false不存在
	 */
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "hasKey", e);
			return false;
		}
	}
	
	/**
	 * 删除缓存
	 *
	 * @param key 可以传一个值 或多个
	 */
	@SuppressWarnings("unchecked")
	public void del(String... key) {
		if (key != null && key.length > 0) {
			if (key.length == 1) {
				redisTemplate.delete(key[0]);
			} else {
				redisTemplate.delete(CollectionUtils.arrayToList(key));
			}
		}
	}
	
	//============================String=============================
	
	/**
	 * 普通缓存获取
	 *
	 * @param key 键
	 * @return 值
	 */
	public Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}
	
	/**
	 * 普通缓存放入
	 *
	 * @param key   键
	 * @param value 值
	 * @return true成功 false失败
	 */
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "set", e);
			return false;
		}
		
	}
	
	/**
	 * 普通缓存放入并设置时间
	 *
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
	 * @return true成功 false 失败
	 */
	public boolean set(String key, Object value, long time) {
		try {
			if (time > 0) {
				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
			} else {
				set(key, value);
			}
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "set", e);
			return false;
		}
	}
	
	/**
	 * 递增
	 *
	 * @param key 键
	 * @param by  要增加几(大于0)
	 * @return
	 */
	public long incr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递增因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, delta);
	}
	
	/**
	 * 递减
	 *
	 * @param key 键
	 * @param by  要减少几(小于0)
	 * @return
	 */
	public long decr(String key, long delta) {
		if (delta < 0) {
			throw new RuntimeException("递减因子必须大于0");
		}
		return redisTemplate.opsForValue().increment(key, -delta);
	}
	
	//================================Map=================================
	
	/**
	 * HashGet
	 *
	 * @param key  键 不能为null
	 * @param item 项 不能为null
	 * @return 值
	 */
	public Object hget(String key, String item) {
		return redisTemplate.opsForHash().get(key, item);
	}
	
	/**
	 * 获取hashKey对应的所有键值
	 *
	 * @param key 键
	 * @return 对应的多个键值
	 */
	public Map<Object, Object> hmget(String key) {
		return redisTemplate.opsForHash().entries(key);
	}
	
	/**
	 * HashSet
	 *
	 * @param key 键
	 * @param map 对应多个键值
	 * @return true 成功 false 失败
	 */
	public boolean hmset(String key, Map<String, Object> map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "hmset", e);
			return false;
		}
	}
	
	/**
	 * HashSet 并设置时间
	 *
	 * @param key  键
	 * @param map  对应多个键值
	 * @param time 时间(秒)
	 * @return true成功 false失败
	 */
	public boolean hmset(String key, Map<String, Object> map, long time) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "hmset", e);
			return false;
		}
	}
	
	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 *
	 * @param key   键
	 * @param item  项
	 * @param value 值
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "hset", e);
			return false;
		}
	}
	
	/**
	 * 向一张hash表中放入数据,如果不存在将创建
	 *
	 * @param key   键
	 * @param item  项
	 * @param value 值
	 * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
	 * @return true 成功 false失败
	 */
	public boolean hset(String key, String item, Object value, long time) {
		try {
			redisTemplate.opsForHash().put(key, item, value);
			if (time > 0) {
				expire(key, time);
			}
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "hset", e);
			return false;
		}
	}
	
	/**
	 * 删除hash表中的值
	 *
	 * @param key  键 不能为null
	 * @param item 项 可以使多个 不能为null
	 */
	public void hdel(String key, Object... item) {
		redisTemplate.opsForHash().delete(key, item);
	}
	
	/**
	 * 判断hash表中是否有该项的值
	 *
	 * @param key  键 不能为null
	 * @param item 项 不能为null
	 * @return true 存在 false不存在
	 */
	public boolean hHasKey(String key, String item) {
		return redisTemplate.opsForHash().hasKey(key, item);
	}
	
	/**
	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
	 *
	 * @param key  键
	 * @param item 项
	 * @param by   要增加几(大于0)
	 * @return
	 */
	public double hincr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, by);
	}
	
	/**
	 * hash递减
	 *
	 * @param key  键
	 * @param item 项
	 * @param by   要减少记(小于0)
	 * @return
	 */
	public double hdecr(String key, String item, double by) {
		return redisTemplate.opsForHash().increment(key, item, -by);
	}
	
	//============================set=============================
	
	/**
	 * 根据key获取Set中的所有值
	 *
	 * @param key 键
	 * @return
	 */
	public Set<Object> sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "sGet", e);
			return null;
		}
	}
	
	/**
	 * 根据value从一个set中查询,是否存在
	 *
	 * @param key   键
	 * @param value 值
	 * @return true 存在 false不存在
	 */
	public boolean sHasKey(String key, Object value) {
		try {
			return redisTemplate.opsForSet().isMember(key, value);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "sHasKey", e);
			return false;
		}
	}
	
	/**
	 * 将数据放入set缓存
	 *
	 * @param key    键
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "sSet", e);
			return 0;
		}
	}
	
	/**
	 * 将set数据放入缓存
	 *
	 * @param key    键
	 * @param time   时间(秒)
	 * @param values 值 可以是多个
	 * @return 成功个数
	 */
	public long sSetAndTime(String key, long time, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().add(key, values);
			if (time > 0) expire(key, time);
			return count;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "sSetAndTime", e);
			return 0;
		}
	}
	
	/**
	 * 获取set缓存的长度
	 *
	 * @param key 键
	 * @return
	 */
	public long sGetSetSize(String key) {
		try {
			return redisTemplate.opsForSet().size(key);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "sGetSetSize", e);
			return 0;
		}
	}
	
	/**
	 * 移除值为value的
	 *
	 * @param key    键
	 * @param values 值 可以是多个
	 * @return 移除的个数
	 */
	public long setRemove(String key, Object... values) {
		try {
			Long count = redisTemplate.opsForSet().remove(key, values);
			return count;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "setRemove", e);
			return 0;
		}
	}
	//===============================list=================================
	
	/**
	 * 获取list缓存的内容
	 *
	 * @param key   键
	 * @param start 开始
	 * @param end   结束  0 到 -1代表所有值
	 * @return
	 */
	public List<Object> lGet(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lGet", e);
			return null;
		}
	}
	
	/**
	 * 获取list缓存的长度
	 *
	 * @param key 键
	 * @return
	 */
	public long lGetListSize(String key) {
		try {
			return redisTemplate.opsForList().size(key);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lGetListSize", e);
			return 0;
		}
	}
	
	/**
	 * 通过索引 获取list中的值
	 *
	 * @param key   键
	 * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
	 * @return
	 */
	public Object lGetIndex(String key, long index) {
		try {
			return redisTemplate.opsForList().index(key, index);
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lGetIndex", e);
			return null;
		}
	}
	
	/**
	 * 将list放入缓存
	 *
	 * @param key   键
	 * @param value 值
	 * @return
	 */
	public boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lSet", e);
			return false;
		}
	}
	
	/**
	 * 将list放入缓存
	 *
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, Object value, long time) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			if (time > 0) expire(key, time);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lSet", e);
			return false;
		}
	}
	
	/**
	 * 将list放入缓存
	 *
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lSet", e);
			return false;
		}
	}
	
	/**
	 * 将list放入缓存
	 *
	 * @param key   键
	 * @param value 值
	 * @param time  时间(秒)
	 * @return
	 */
	public boolean lSet(String key, List<Object> value, long time) {
		try {
			redisTemplate.opsForList().rightPushAll(key, value);
			if (time > 0) expire(key, time);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lSet", e);
			return false;
		}
	}
	
	/**
	 * 根据索引修改list中的某条数据
	 *
	 * @param key   键
	 * @param index 索引
	 * @param value 值
	 * @return
	 */
	public boolean lUpdateIndex(String key, long index, Object value) {
		try {
			redisTemplate.opsForList().set(key, index, value);
			return true;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lUpdateIndex", e);
			return false;
		}
	}
	
	/**
	 * 移除N个值为value
	 *
	 * @param key   键
	 * @param count 移除多少个
	 * @param value 值
	 * @return 移除的个数
	 */
	public long lRemove(String key, long count, Object value) {
		try {
			Long remove = redisTemplate.opsForList().remove(key, count, value);
			return remove;
		} catch (Exception e) {
			log.error("Redis工具类：【{}】方法异常，原因：", "lRemove", e);
			return 0;
		}
	}
}
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 22万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
SpringBoot整合Redis工具类
m0_52653999的博客
05-31 579
可以使用windows版的redis，方便开发顺便安装了一个Redis图形化界面工具，Another Redis Desktop，除了不能在里面输入命令，没什么大问题。
Redis简单介绍以及在Springboot中使用redis
m0_54853503的博客
08-02 1866
Redis是一个使用c语言开发的数据库，它的数据是存在内存中的，读写速度很快，因此被广泛的应用于缓存方面。
spring boot-引入Redis并封装redistemplate操作工具类
西京刀客
03-28 2189
springboot引入Redis及其使用案例
Spring Boot中引入Redis，以及RedisUtils完整工具类
最新发布
neo_Ggx23的博客
03-12 453
Spring Boot中引入Redis，以及RedisUtils完整工具类
SpringBoot整合redis及工具类
04-19
本项目代码包括，最基本的SpringBoot2.0,+Swagger-ui,以及redis的测试类，redis各种类型数据存储的工具类以及测试的sql文件
springboot整合redis
Big Data
08-13 307
Jedis和Lettuce的区别在哪？ 1、Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。 2、Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，如果你不知道Netty也没事，大致意思就是一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。通过异步的方式可以让我们更好地利用系统资源。 既然有这么大的好处，干脆就用了这个，跟上时代的变化。下面新建一个Spri
SpringBoot整合Redis(配置 + 工具类)
憨憨小江的博客
01-25 962
整合redis
SpringBoot整合Redis及Redis工具类撰写
张志强的博客
10-24 1601
SpringBoot整合Redis及Redis工具类撰写 一、Maven依赖 （1）本文所采用的SpringBoot的版本如下 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-st...
微服务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`文件...
Redis工具类
chenyuanju的博客
10-10 535
  import java.util.Collection; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.concurrent.TimeUnit; import org....
springboot整合redis工具类
qq_39400373的博客
10-21 596
springboot整合redis工具类 引入jar包： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>${spring-boot.version}</version>
SpringBoot整合Redis及Redis的工具类
学不死就往死里学
09-20 527
说起SpringBoot整合什么什么，那就太简单了 但是要注意的是，SpringBoot在 2.x后 ，原来底层使用的 Jedis 被 lettuce 替换。 jedis：采用的直连，多个线程操作的话，是不安全的。如果要避免不安全，使用jedis pool连接池！更像BIO模式 lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况！可以减少线程数据了，更像NIO模式 一些什么原理我就不说了，直接入主题吧 简单的了解 1、当然要新建一个SpringBoot的项目，并导入
SpringBoot整合Redis及Redis工具类撰写（RedisTemplate）
一蓑烟雨任平生
11-10 202
https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html
Spring Boot 整合redis工具类
GinChou的萌新博客
06-13 206
记录，以后要用避免忘了 1.配置依赖 第一个spring Boot 整合的redis 第二三个是需要的依赖条件 #只是个需要的springboot <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-start...
Redis学习2——SpringBoot整合Redis，Redis工具类
weixin_55850954的博客
05-06 713
依赖和配置 pom.xml SpringBoot整合Redis，需要引入spring-boot-starter-data-redis依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depen
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值