比地招标网官网网站排名软件优化
前言：简单分享一下我在实际开发当中如何使用SpringBoot操作Redis数据库的技术分享，完整的代码我都提供了出来，大家按需复制使用即可！
目录
一、导入pom依赖
二、yml配置文件
三、使用FastJson序列化
四、核心配置类
五、工具类
六、User实体类
七、五种基本数据类型
7.1、String类型
7.2、List类型
7.3、Set类型
7.4、Map类型
7.5、ZSet类型
八、Gitee源码
九、总结
一、导入pom依赖
<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- lombok依赖 --><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><!-- redis依赖 对象池 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><!-- pool 对象池 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId><version>2.11.1</version></dependency><!-- 阿里JSON解析器 --><dependency><groupId>com.alibaba.fastjson2</groupId><artifactId>fastjson2</artifactId><version>2.0.34</version></dependency></dependencies>二、yml配置文件
spring:redis:host: localhostport: 6379database: 0password:timeout: 10slettuce:pool:min-idle: 0max-idle: 8max-active: 8max-wait: -1ms
三、使用FastJson序列化
这个FastJson2JsonRedisSerializer类实现了Spring Redis的RedisSerializer接口，作用是使用FastJson来实现对象的序列化和反序列化。
1、在构造方法中传入了泛型类Class<T>，表示需要序列化的对象类型。
private Class<T> clazz;public FastJson2JsonRedisSerializer(Class<T> clazz){super();this.clazz = clazz;}2、serialize方法实现序列化，将对象转换为JSON字符串，并转为byte数组，使用JSONWriter.Feature.WriteClassName特性，在序列化时写入类名称，方便反序列化。
@Overridepublic byte[] serialize(T t) throws SerializationException{if (t == null){return new byte[0];}return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);}3、deserialize方法实现反序列化，将byte数组转换为String，然后使用FastJson的parseObject方法反序列化为对象，使用JSONReader.Feature.SupportAutoType特性，在反序列化时自动选择类类型。
@Overridepublic T deserialize(byte[] bytes) throws SerializationException{if (bytes == null || bytes.length <= 0){return null;}String str = new String(bytes, DEFAULT_CHARSET);return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);}完整代码：
package com.example.redis.config;import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONReader;
import com.alibaba.fastjson2.JSONWriter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;import java.nio.charset.Charset;/*** Redis使用FastJson序列化*/
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");private Class<T> clazz;public FastJson2JsonRedisSerializer(Class<T> clazz){super();this.clazz = clazz;}@Overridepublic byte[] serialize(T t) throws SerializationException{if (t == null){return new byte[0];}return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);}@Overridepublic T deserialize(byte[] bytes) throws SerializationException{if (bytes == null || bytes.length <= 0){return null;}String str = new String(bytes, DEFAULT_CHARSET);return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);}
}
四、核心配置类
1、创建RedisTemplate对象。
RedisTemplate<Object, Object> template = new RedisTemplate<>();2、设置Redis连接工厂。
template.setConnectionFactory(redisConnectionFactory);3、创建JSON序列化器，使用FastJson。
FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);4、设置Key的序列化方式为StringRedisSerializer。
template.setKeySerializer(new StringRedisSerializer());5、设置Value的序列化方式为之前创建的JSON序列化器。
template.setValueSerializer(serializer);6、设置Hash类型Key的序列化方式。
template.setHashKeySerializer(new StringRedisSerializer());7、设置Hash类型Value的序列化方式。
template.setHashValueSerializer(serializer);8、初始化模板对象。
template.afterPropertiesSet();完整代码：
package com.example.redis.config;import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;/*** redis配置*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{@Bean@SuppressWarnings(value = { "unchecked", "rawtypes" })public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){RedisTemplate<Object, Object> template = new RedisTemplate<>();template.setConnectionFactory(redisConnectionFactory);FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);// 使用StringRedisSerializer来序列化和反序列化redis的key值template.setKeySerializer(new StringRedisSerializer());template.setValueSerializer(serializer);// Hash的key也采用StringRedisSerializer的序列化方式template.setHashKeySerializer(new StringRedisSerializer());template.setHashValueSerializer(serializer);template.afterPropertiesSet();return template;}}
五、工具类
完整代码：
package com.example.redis.utils;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;import java.util.*;
import java.util.concurrent.TimeUnit;/*** spring redis 工具类**/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{@Autowiredpublic RedisTemplate redisTemplate;/*** 缓存基本的对象，Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值*/public <T> void setCacheObject(final String key, final T value){redisTemplate.opsForValue().set(key, value);}/*** 缓存基本的对象，Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值* @param timeout 时间* @param timeUnit 时间颗粒度*/public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit){redisTemplate.opsForValue().set(key, value, timeout, timeUnit);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @return true=设置成功；false=设置失败*/public boolean expire(final String key, final long timeout){return expire(key, timeout, TimeUnit.SECONDS);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @param unit 时间单位* @return true=设置成功；false=设置失败*/public boolean expire(final String key, final long timeout, final TimeUnit unit){return redisTemplate.expire(key, timeout, unit);}/*** 获取有效时间** @param key Redis键* @return 有效时间*/public long getExpire(final String key){return redisTemplate.getExpire(key);}/*** 判断 key是否存在** @param key 键* @return true 存在 false不存在*/public Boolean hasKey(String key){return redisTemplate.hasKey(key);}/*** 获得缓存的基本对象。** @param key 缓存键值* @return 缓存键值对应的数据*/public <T> T getCacheObject(final String key){ValueOperations<String, T> operation = redisTemplate.opsForValue();return operation.get(key);}/*** 删除单个对象** @param key*/public boolean deleteObject(final String key){return redisTemplate.delete(key);}/*** 删除集合对象** @param collection 多个对象* @return*/public boolean deleteObject(final Collection collection){return redisTemplate.delete(collection) > 0;}/*** 缓存List数据** @param key 缓存的键值* @param dataList 待缓存的List数据* @return 缓存的对象*/public <T> long setCacheList(final String key, final List<T> dataList){Long count = redisTemplate.opsForList().rightPushAll(key, dataList);return count == null ? 0 : count;}/*** 获得缓存的list对象** @param key 缓存的键值* @return 缓存键值对应的数据*/public <T> List<T> getCacheList(final String key){return redisTemplate.opsForList().range(key, 0, -1);}/*** 缓存Set** @param key 缓存键值* @param dataSet 缓存的数据* @return 缓存数据的对象*/public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet){BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);Iterator<T> it = dataSet.iterator();while (it.hasNext()){setOperation.add(it.next());}return setOperation;}/*** 获得缓存的set** @param key* @return*/public <T> Set<T> getCacheSet(final String key){return redisTemplate.opsForSet().members(key);}/*** 缓存Map** @param key* @param dataMap*/public <T> void setCacheMap(final String key, final Map<String, T> dataMap){if (dataMap != null) {redisTemplate.opsForHash().putAll(key, dataMap);}}/*** 获得缓存的Map** @param key* @return*/public <T> Map<String, T> getCacheMap(final String key){return redisTemplate.opsForHash().entries(key);}/*** 往Hash中存入数据** @param key Redis键* @param hKey Hash键* @param value 值*/public <T> void setCacheMapValue(final String key, final String hKey, final T value){redisTemplate.opsForHash().put(key, hKey, value);}/*** 获取Hash中的数据** @param key Redis键* @param hKey Hash键* @return Hash中的对象*/public <T> T getCacheMapValue(final String key, final String hKey){HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();return opsForHash.get(key, hKey);}/*** 获取多个Hash中的数据** @param key Redis键* @param hKeys Hash键集合* @return Hash对象集合*/public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys){return redisTemplate.opsForHash().multiGet(key, hKeys);}/*** 删除Hash中的某条数据** @param key Redis键* @param hKey Hash键* @return 是否成功*/public boolean deleteCacheMapValue(final String key, final String hKey){return redisTemplate.opsForHash().delete(key, hKey) > 0;}/*** 获得缓存的基本对象列表** @param pattern 字符串前缀* @return 对象列表*/public Collection<String> keys(final String pattern){return redisTemplate.keys(pattern);}/*** 存储有序集合* @param key 键* @param value 值* @param score 排序*/public void zSet(Object key, Object value, double score){redisTemplate.opsForZSet().add(key, value, score);}/*** 存储值* @param key 键* @param set 集合*/public void zSet(Object key, Set set){redisTemplate.opsForZSet().add(key, set);}/*** 获取key指定范围的值* @param key 键* @param start 开始位置* @param end 结束位置* @return 返回set*/public Set zGet(Object key, long start, long end){Set set = redisTemplate.opsForZSet().range(key, start, end);return set;}/*** 获取key对应的所有值* @param key 键* @return 返回set*/public Set zGet(Object key){Set set = redisTemplate.opsForZSet().range(key, 0, -1);return set;}/*** 获取对用数据的大小* @param key 键* @return 键值大小*/public long zGetSize(Object key){Long size = redisTemplate.opsForZSet().size(key);return size;}
}
六、User实体类
需要实现序列化接口
package com.example.redis.domain;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;import java.io.Serializable;@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable{private String username;private String password;
}
七、五种基本数据类型
下面介绍一下每种代码的使用示例
7.1、String类型
@Autowiredprivate RedisCache redisCache;public void string(){User user = new User("mike","123456");redisCache.setCacheObject("user",user);User redisUser = redisCache.getCacheObject("user");System.out.println(redisUser);}7.2、List类型
@Autowiredprivate RedisCache redisCache;public void list(){List<String> list = new ArrayList<>();list.add("aaa");list.add("bbb");redisCache.setCacheList("list",list);List<Object> redisList = redisCache.getCacheList("list");System.out.println(redisList);}7.3、Set类型
@Autowiredprivate RedisCache redisCache;public void set(){Set<String> set = new HashSet<>();set.add("aaa");set.add("bbb");redisCache.setCacheSet("set",set);Set<String> redisSet = redisCache.getCacheSet("set");System.out.println(redisSet);}7.4、Map类型
@Autowiredprivate RedisCache redisCache;public void map(){User user = new User("mike","123456");Map<String,String> map = new HashMap<>(16);map.put("username", user.getUsername());map.put("password", user.getPassword());redisCache.setCacheMap("map",map);Map<String,String> redisMap = redisCache.getCacheMap("map");System.out.println(redisMap);}7.5、ZSet类型
@Autowiredprivate RedisCache redisCache;public void ZSet(){String key = "ZSet_key";User user1 = new User("Tom", "123");User user2 = new User("Jack", "123");Set<User> hashSet = new HashSet<>();hashSet.add(user1);hashSet.add(user2);redisCache.zSet(key,user1,0);redisCache.zSet(key,user2,1);Set set = redisCache.zGet(key, 0, -1);System.out.println(set);}八、Gitee源码
源码我都上传到了码云上，需要的可以拉取看一下：
地址：SpringBoot整合RedisTemplate操作Redis数据完整代码分享
九、总结
以上就是对于实际项目开发中SpringBoot如何操作Redis数据库常用的一些代码分享，如有问题，欢迎评论区讨论！