36.SpringBoot整合redis
-
SpringBoot操作数据：使用spring-data项目。例如：jpa、jdbc 、mongodb 、redis…
-
SpringData也是和SpringBoot齐名的项目！说明：在SpringBoot2.×之后，原来使用的jedis被替换为了lettuce?
-
jedis和lettuce的区别：
- jedis采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全的，需使用jedis pool连接池。类似BIO阻塞通信方式，但会带来一些问题。如：线程数量多、redis服务太大了。
- 采用高性能网络框架netty，采用异步请求NIO的方式。实例可以在多个线程中共享，不存在线程不安全的情况,可以减少线程数量，不需要开连接池了。（dubbo底层也是用的netty）。涉及到这种网络框架netty、dubbo等nio类型的框架，里面的对象都需要序列化才能进行通信。
36.1 整合步骤
- 1.创建一个springboot整合项目：springboot-redis。其中的pom需要涉及的包为：
<dependencies>
<!--操作redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
- 源码分析：
#SpringBoot所有的配置类，都有一个自动配置类 redis在springboot 中的自动配置类 RedisAutoConfiguration
#自动配置类都会绑定一个properties配置属性类，来绑定配置文件application.properties/application.yml中的配置项 RedisProperties
@AutoConfiguration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
@Bean
@ConditionalOnMissingBean(name = "redisTemplate") //可以自定义一个redisTemplate来替换默认的
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//默认的redisTemplate没有做过多的设置，比如：redis对象都需要序列化
//RedisTemplate<Object, Object>两个都是Object，后续使用要进行强制转换为<String,Object>
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
//由于string是redis中最常使用的类型，所以说单独提出来了一个bean!
@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
return new StringRedisTemplate(redisConnectionFactory);
}
}
注意：RedisConnectionFactory接口有两个实现类：JedisConnectionFactory、LettuceConnectionFactory
由于JedisConnectionFactory里面一些类不存在，所以JedisConnectionFactory不生效。所以配置redis的连接池、集群使用Lettuce的配置项
- 2.配置连接，在application.yml进行配置
#配置redis
spring:
redis:
host: 121.x.x.x
password: 123456
ssl: false
port: 6379
- 链接测试，测试步骤：
- 1.使用原生RedisTemplate、StringRedisTemplate进行存值测试：发现StringRedisTemplate存值不乱码，且无法存取对象；使用RedisTemplate存对象值乱码，且无法存取为序列化的对象；
- 2.将对象进行序列化进行测试，使用RedisTemplate能够进行存值，但存在乱码，原因jdk序列化引起；
- 3.自定义RedisTemplate替代jdk序列化，然后进行RedisTemplate能够进行存值不乱码；
- 4.将RedisTemplate的常用方法进行封装为RedisUtil(网上一大堆)，进行测试。期间有两种改造RedisTemplate的方法。一种是在配置类中自定义RedisTemplate，第二种是对原有的RedisTemplate进行序列化重新设置，二者任选一使用。
@SpringBootTest
class SpringbootRedisApplicationTests {
@Autowired //按照 Bean 的类型进行装配Type。
@Qualifier("redisTemplate") //存在多个RedisTemplate,可以使用Qualifier使用bean的name
private RedisTemplate redisTemplate; //当无法使用第一种自定义RedisTemplate方法
//先将Qualifier注释掉使用原生redisTemplate对象测试
@Resource
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisUtil redisUtil; //第二种对原来的RedisTemplate进行改造
@Test
void contextLoads() {
/*
* stringRedisTemplate操作不同的数据类型
* opsForValue() 操作String
* opsForList() 操作list
* opsForHash() 操作Hash
* opsForGeo() 操作地图
* opsForSet() 操作set
* opsForZSet() 操作zset
* opsForHyperLogLog() 操作HyperLogLog基数统计
*stringRedisTemplate.opsForValue().getBit() 操作bitmap
* */
/*
* 除了基本的操作，常用的方法还可以直接通过stringRedisTemplate进行操作。
* 如：绑定操作、事务、过期时间、移除、删除、复制、重命名、排序、主从复制等操作
* */
System.out.println("redisTemplate:"+redisTemplate.opsForValue().get("name"));
System.out.println(stringRedisTemplate.opsForValue().get("name"));
System.out.println(stringRedisTemplate.opsForValue().get("num"));
List mycourselist = stringRedisTemplate.opsForList().range("mycourselist", 0, -1);
Object user = stringRedisTemplate.opsForHash().get("user", "id:1");
Boolean mybit = stringRedisTemplate.opsForValue().getBit("mybit", 1);
System.out.println(mycourselist);
System.out.println(user.toString());
System.out.println(mybit);
//获取redis链接对象
RedisConnection connection = stringRedisTemplate.getConnectionFactory().getConnection();
/*
connection.shutdown();
connection.flushAll();
connection.flushDb();
connection.close();*/
stringRedisTemplate.opsForValue().set("redisTemplate","redis模板");
System.out.println(stringRedisTemplate.opsForValue().get("redisTemplate"));
}
}
--结果--
redisTemplate:null
tony
98
[c#, python, php, java]
wu
true
redis模板
36.2 对象序列化乱码配置
- RedisTemplate源码序列化分析：
RedisTemplate:默认的序列化是jdk序列化，会使字符串转义，需要使用json进行序列化，为实现这个改造序列化，需要自定义配置类
- 保存对象序列化测试，先将对象进行序列化为字符串之后进行保存：
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;
import java.io.Serializable; //实现序列化接口
/**
* @author CNCLUKZK
* @create 2023/3/18-0:48
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User { //先不序列化对象测试
private String name;
private int age;
}
//StringRedisTemplate.opsForValue.set()方法只有String,String参数 , 要传对象需要自己先手动装json
@Test
public void testJson(){
//真实的开发一般都使用5son来传递对象,用的json字符串加密后存储的
User user = new User("张三", 18);
//jackson将对象转为字符串
ObjectMapper objectMapper = new ObjectMapper();
String asString = "";
try {
//该方法可用于将任何Java值序列化为字符串
asString = objectMapper.writeValueAsString(user);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
System.out.println(asString);
System.out.println("user.toString():"+user.toString());
/*stringRedisTemplate无法存对象
stringRedisTemplate.opsForValue().set("user2",user);*/
//stringRedisTemplate对象存string值key不乱码
stringRedisTemplate.opsForValue().set("user3",asString);
stringRedisTemplate.opsForValue().set("user4",user.toString());
System.out.println("stringRedisTemplate对象json序列化："+stringRedisTemplate.opsForValue().get("user3"));
System.out.println("stringRedisTemplate对象toString:"+stringRedisTemplate.opsForValue().get("user4"));
/*redisTemplate无法存未序列化的对象
redisTemplate.opsForValue().set("user1",user);*/
//原生redisTemplate对象存string值key乱码，jdk序列化引起的
redisTemplate.opsForValue().set("user5",asString);
System.out.println("redisTemplate对象json序列化："+redisTemplate.opsForValue().get("user5"));
redisTemplate.opsForValue().set("user6",user.toString());
System.out.println("redisTemplate对象toString："+redisTemplate.opsForValue().get("user6"));
}
--结果--
{"name":"张三","age":18}
user.toString():User(name=张三, age=18)
stringRedisTemplate对象json序列化：{"name":"张三","age":18}
stringRedisTemplate对象toString:User(name=张三, age=18)
redisTemplate对象json序列化：{"name":"张三","age":18}
redisTemplate对象toString：User(name=张三, age=18)
- 注意在保存对象时会报序列化错误，未将对象序列化时：
- 然后在定义对象时进行序列化，结果发现在redis中存放的确实是序列化的对象
import java.io.Serializable; //实现序列化接口
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable{ //在企业中，我们的所有pojo都会序列化！SpringBoot
private String name;
private int age;
}
Test{
//autowired是mybatis里面工厂生产对象的注解，springboot里面用的是resource，
// 如果你不想爆红就加上mybatis-springboot的包
@Autowired //按照 Bean 的类型进行装配Type。
@Qualifier("redisTemplate") //存在多个RedisTemplate,可以使用Qualifier使用bean的name
private RedisTemplate redisTemplate; //当无法使用(跳不过去自定义方法)第一种自定义RedisTemplate方法
//之后在使用原生redisTemplate进行测试可以存对象了，但存在乱码
@Test
public void testJson2(){
//对user对象进行序列化，之后用原生redisTemplate进行存值
//原生redisTemplate对象存序列化后的对象或着是普通字符串key乱码，jdk序列化引起的
User user = new User("李四", 18);
redisTemplate.opsForValue().set("user7",user);
System.out.println("对象user7序列化："+redisTemplate.opsForValue().get("user7"));
redisTemplate.opsForValue().set("simpleStr","简单字符");
System.out.println(redisTemplate.opsForValue().get("simpleStr"));
//自定义redisTemplate对象存序列化后的对象或着是普通字符串key不乱码
}
}
--结果--
对象user7序列化：User(name=李四, age=18)
简单字符
- 之后自定义RedisTemplate解决乱码问题
package com.zk.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.DefaultBaseTypeLimitingValidator;
import com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator;
import com.zk.util.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConnection;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
* @author CNCLUKZK
* @create 2023/3/17-16:14
*/
@Configuration
public class RedisConfig {
/*@Bean
public RedisConnectionFactory redisConnectionFactory() {
LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory();
//lettuceConnectionFactory.setHostName("远程地址"); //默认为本地redis数据库
return lettuceConnectionFactory;
}*/
//方式1.自定义RedisTemplate,固定模板。与下面的方式2，可以2选一
//redisTemplate 序列化使用的jdkSerializeable，存储二进制字节码, 所以自定义序列化类
//对比xml中bean方式返回值为class,name为方法名
@Bean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//我们为了自己开发方使，一般直接使用<String,Object>
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
//配置具体的序列化方式,要实现RedisSerializer接口，其实现类
//key采用string的序列化方式
template.setKeySerializer(RedisSerializer.string());
//Hash的key也采用string的序列化方式
template.setHashKeySerializer(RedisSerializer.string());
//value采用Jackson序列化方式序列化为json字符串
template.setValueSerializer(RedisSerializer.json());
//Hash的value采用Jackson序列化方式序列化为json字符串
template.setHashValueSerializer(RedisSerializer.json());
template.afterPropertiesSet();
return template;
}
//旧版自定义redisTemplate，发现序列化后还是用的jdk乱码
public RedisTemplate<String, Object> redisTemplateOld(RedisConnectionFactory redisConnectionFactory) {
//我们为了自己开发方使，一般直接使用<String,Object>
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setConnectionFactory(redisConnectionFactory);
//json序列化配置，用json解析任意配置
Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
//进行ObjectMapper进行转义
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//objectMapper.activateDefaultTyping(); // 过期使用这个
/*//PolymorphicTypeValidator抽象类，DefaultBaseTypeLimitingValidator继承类
DefaultBaseTypeLimitingValidator defaultBaseTypeLimitingValidator = new DefaultBaseTypeLimitingValidator();
objectMapper.activateDefaultTyping(defaultBaseTypeLimitingValidator,ObjectMapper.DefaultTyping.NON_FINAL);*/
objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
objectJackson2JsonRedisSerializer.setObjectMapper(objectMapper);
//String序列化配置
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//配置具体的序列化方式,要实现RedisSerializer接口，其实现类
template.setValueSerializer(objectJackson2JsonRedisSerializer);
//Hash的value采用Jackson序列化方式序列化为json字符串
template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
//key采用string的序列化方式
template.setKeySerializer(stringRedisSerializer);
//Hash的key也采用string的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
template.afterPropertiesSet();
return template;
}
//方式2.使用原有的RedisTemplate，在使用前替换掉序列化类(initMethod = "init")
@Bean(initMethod = "init")
public RedisUtil redisUtil(){
return new RedisUtil();
}
}
-
RedisSerializer接口的实现类
-
再使用testJson2()方法进行测试，发现存值不乱码
@Test
public void testJson2(){
//对user对象进行序列化，之后用原生redisTemplate进行存值
//原生redisTemplate对象存序列化后的对象或着是普通字符串key乱码，jdk序列化引起的
User user = new User("李四", 18);
redisTemplate.opsForValue().set("user7",user);
System.out.println("对象user7序列化："+redisTemplate.opsForValue().get("user7"));
redisTemplate.opsForValue().set("simpleStr","简单字符");
System.out.println(redisTemplate.opsForValue().get("simpleStr"));
//自定义redisTemplate对象存序列化后的对象或着是普通字符串key不乱码
}
36.3 封装RedisTemplate方法RedisUtil
- 将RedisTemplate的常用方法封装为RedisUtil,除了封装常用方法也可以替代前面的自定义RedisTemplate对原有的RedisTemplate的序列化方式进行替换，然后将RedisUtil作为bean配置到配置类中，供后续测试使用。RedisUtil方法：
package com.zk.util;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @author CNCLUKZK
* @create 2023/3/18-3:22
*/
/*在企业开发中，我们8©%的情况下，都不会使用这个原生的方式去编写代码！
般都可以看到一个公司自己封装Redisutils
*/
public class RedisUtil {
@Autowired
private RedisTemplate redisTemplate; //当无法使用(跳不过去自定义方法)第一种自定义RedisTemplate方法
//2.使用原有的RedisTemplate，在使用前替换掉序列化类
public void init(){
//配置具体的序列化方式,要实现RedisSerializer接口，其实现类
//value采用Jackson序列化方式序列化为json字符串
redisTemplate.setValueSerializer(RedisSerializer.json());
//Hash的value采用Jackson序列化方式序列化为json字符串
redisTemplate.setHashValueSerializer(RedisSerializer.json());
//key采用string的序列化方式
redisTemplate.setKeySerializer(RedisSerializer.string());
//Hash的key也采用string的序列化方式
redisTemplate.setHashKeySerializer(RedisSerializer.string());
}
// =============================common============================
public Set<String> keys(String pattern) {
return redisTemplate.keys(pattern);
}
/**
* 指定缓存失效时间
*
* @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) {
e.printStackTrace();
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) {
e.printStackTrace();
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((Collection<String>) 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) {
e.printStackTrace();
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) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于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 delta 要减少几(小于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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
* @return
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
* @return
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
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) {
e.printStackTrace();
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) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
return redisTemplate.opsForList().remove(key, count, value);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
}
//方式2.使用原有的RedisTemplate，在使用前替换掉序列化类(initMethod = "init")
@Bean(initMethod = "init")
public RedisUtil redisUtil(){
return new RedisUtil();
}
- 对RedisUtil进行测试，未出现乱码
@Autowired
private RedisUtil redisUtil; //第二种对原来的RedisTemplate进行改造
@Test
public void testRedisUtil(){
//如果将redisUtil里面的redisTemplate进行init则序列化乱码
User user = new User("李四", 18);
redisUtil.set("user8",user);
redisUtil.set("redistool","redis工具类");
System.out.println(redisUtil.get("user8"));
System.out.println(redisUtil.get("redistool"));
}
--结果---
User(name=李四, age=18)
redis工具类
- 所有的redis操作，其实对于java开发人员来说，十分的简单，更重要是要去理解redis的思想和每一种数据结构的用处和作用场景！
1253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
