springboot+redis持久化存储数据（不使用MySQL）
Posted 符华-
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了springboot+redis持久化存储数据（不使用MySQL）相关的知识，希望对你有一定的参考价值。
前言
1、
前段时间，做过一个项目，一开始甲方给的需求文档里没有说明数据存储用什么数据库，因为我也做过甲方的其他项目都是用的mysql，所以这次我也就默认使用MySQL了。
2、
就一个电量电能统计分析工具，功能也很简单，做完了之后甲方跟我说这个工具是要可以在任意一台电脑上运行的，开发者的电脑安装了jdk和mysql可以运行，但是普通用户肯定不可能都给他们装上jdk和mysql吧，然后叫我看一下要怎么解决，数据存储不使用mysql。最后我就干脆把mysql改成redis。（因为之前对redis的使用一直都停留在配合shiro做权限控制，对于它单独像mysql一样持久化存储数据还是云里雾里的。网上看了一些案例大都不全，可能对于刚接触redis的小伙伴来说不太友好，特此整理写了个完整齐全的案例。）
3、
改完之后项目打包成jar包，将redis服务整个文件夹 、 jdk1.8里面的jre文件夹 、前端打包的exe程序 放在和jar包同一目录下，并且使用vbs脚本，同时启动redis-service、jar包、exe程序。只要不在任务管理器中将redis-service和jar结束进程，后续要使用这个工具时，只需要双击启动exe程序即可。
这样即使电脑没有jdk环境和redis服务，也可以运行这个工具。有个缺点就是这工具实在是大，前端打包出来的exe就有两百兆，再加上jre也有一百八十兆，加上jar包六十兆，总共就有四百多兆了。。。
4、
后面我突然想到，其实可以把jar包和jdk环境用exe4j打包成exe程序的，就不用另外将jre文件夹放到里面了 。不过项目交都交了，甲方那边也没说啥，也就懒得跟他们说了。
这个电量电能统计分析工具不适合作为案例来写，就整理了一下，写了个更易懂明了的例子，实际项目中可以按照这种方式拓展业务。
一、依赖
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- @ConfigurationProperties 注解 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
<!-- cache缓存 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- gson：redis存取数据格式化 -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
<!-- 分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper-spring-boot-starter</artifactId>
<version>1.2.9</version>
</dependency>
<!-- StringUtilS工具 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>3.5</version>
</dependency>
二、启动类
//不使用mysql数据库，所以排除数据源
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableCaching
三、yml配置
server:
port: 8082
spring:
cache:
type: redis
redis:
host: localhost
port: 6379
password: 123456
database: 0
四、RedisConfig配置
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.*;
import java.lang.reflect.Method;
import java.net.UnknownHostException;
/**
* @author fuHua
* @date 2021年06月17日 14:31
*/
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
/*
* 定义缓存数据 key 生成策略的bean 包名+类名+方法名+所有参数
*/
@Bean
public KeyGenerator wiselyKeyGenerator(){
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
//初始化一个RedisCacheWriter
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
//设置CacheManager的值序列化方式为json序列化
RedisSerializer<Object> jsonSerializer = new GenericJackson2JsonRedisSerializer();
RedisSerializationContext.SerializationPair<Object> pair = RedisSerializationContext.SerializationPair
.fromSerializer(jsonSerializer);
RedisCacheConfiguration defaultCacheConfig=RedisCacheConfiguration.defaultCacheConfig()
.serializeValuesWith(pair);
//我们需要redis中的数据永久存储，所以不设置过期时间
// defaultCacheConfig.entryTtl(Duration.ofSeconds(1800));
//初始化RedisCacheManager
return new RedisCacheManager(redisCacheWriter, defaultCacheConfig);
}
/**
* redis序列化
*/
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
//我们为了自己开发使用方便，一般使用<String, Object>类型
RedisTemplate<String, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
//序列化配置
//json序列化
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om=new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
//String序列化
StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
//key使用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
//hash的key也使用String序列化
template.setHashKeySerializer(stringRedisSerializer);
//value使用json序列化
template.setValueSerializer(jackson2JsonRedisSerializer);
//hash的value使用json序列化
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
五、GsonUtil 数据格式化
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
/**
* 数据格式化：
* 数据以json字符串的方式存储；
* 再通过json字符串和实体类.class进行解析，返回实体类对象
* @author fuHua
* @date 2021年06月17日
*/
public class GsonUtil {
/**
* 存储数据
* @param object 需要存储的对象
* @return json字符串
*/
public static String object2Json(Object object) {
Gson gson = new GsonBuilder().create();
return gson.toJson(object);
}
/**
* 解析数据
* @param json json字符串
* @param clazz 返回的实体类的class对象
* @param <T>
* @return
*/
public static <T> T json2Object(String json, Class<T> clazz) {
Gson gson = new GsonBuilder().create();
return gson.fromJson(json, clazz);
}
}
六、RedisUtil（需要存取哪种数据类型，调用对应的存取方法）
import org.springframework.data.redis.core.RedisTemplate;
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;
/**
* redis工具类
*/
@Component
public class RedisUtil {
@Resource
private RedisTemplate<String, Object> redisTemplate;
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
*/
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 可以传一个值 或多个
*/
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));
}
}
}
/**
* 普通缓存获取
* @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)
*/
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)
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().decrement(key,delta);
// return redisTemplate.opsForValue().increment(key, -delta);
}
public long strLen(String key){
return redisTemplate.opsForValue().get(key).toString().length();
}
/*
* 追加字符
* @param key 键
* @param str 要追加的字符
* */
public boolean append(String key,String str){
try {
redisTemplate.opsForValue().append(key,str);
return true;
}catch (Exception e){
return false;
}
}
/**
* HashGet
* @param key 键 不能为null
* @param item 项 不能为null
*/
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 对应多个键值
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();以上是关于springboot+redis持久化存储数据（不使用MySQL）的主要内容，如果未能解决你的问题，请参考以下文章