SpringBoot整合redis中的JSON序列化文件夹操作小结

目录
  • 前言
  • 快速配置
  • JSON序列化
    • jackson序列化
    • Fastjson序列化
    • 分析参考对比
    • 更多问题参考
  • redis数据库操作

前言

最近在开发项目,用到了redis作为缓存,来提高系统访问速度和缓解系统压力,提高用户响应和访问速度,这里遇到几个问题做一下总结和整理

快速配置

SpringBoot整合redis有专门的场景启动器整合起来还是非常方便的

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

如果使用redis连接池引入

  <!-- redis连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

集成配置文件

#------------------redis缓存配置------------
# Redis数据库索引(默认为 0)
spring.redis.database=1
# Redis服务器地址
spring.redis.host= 127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis 密码
spring.redis.password
# 连接超时时间(毫秒)
spring.redis.timeout= 5000
# redis连接池
# 连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=10
# 连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle= 500
# 连接池最大连接数(使用负值表示没有限制)
spring.redis.lettuce.pool.max-active=2000
# 连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.lettuce.pool.max-wait=10000

JSON序列化

由于缓存数据默认使用的是jdk自带的序列化 二进制
需要序列化的实体类继承Serializable接口。而且序列化后的内容在redis中看起来也不是很方便。

\xAC\xED\x00\x05sr\x00Lorg.springframework.security.oauth2.common.DefaultExpiringOAuth2RefreshToken/\xDFGc\x9D\xD0\xC9\xB7\x02\x00\x01L\x00\x0Aexpirationt\x00\x10Ljava/util/Date;xr\x00Dorg.springframework.security.oauth2.common.DefaultOAuth2RefreshTokens\xE1\x0E\x0AcT\xD4^\x02\x00\x01L\x00\x05valuet\x00\x12Ljava/lang/String;xpt\x00$805a75f7-2ee2-4a27-a598-591bfa1cf17dsr\x00\x0Ejava.util.Datehj\x81\x01KYt\x19\x03\x00\x00xpw\x08\x00\x00\x01}y\x81\xDB\x9Ax

于是萌生了需要将数据序列化成json的想法。

jackson序列化

在使用spring-data-redis,默认情况下是使用org.springframework.data.redis.serializer.JdkSerializationRedisSerializer这个类来做序列化,Jackson redis序列化是spring中自带的.我们使用jackson方式

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

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //序列化包括类型描述 否则反向序列化实体会报错,一律都为JsonObject
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用 String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的 key也采用 String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用 jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的 value序列化方式采用 jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

序列化后存储在redis后内容

[
  "com.qhong.test.dependBean.Person",
  {
    "age": 20,
    "name": "name0",
    "iss": true
  }
]
[
  "java.util.ArrayList",
  [
    [
      "com.qhong.test.dependBean.Person",
      {
        "age": 20,
        "name": "name0",
        "iss": true
      }
    ],
    [
      "com.qhong.test.dependBean.Person",
      {
        "age": 21,
        "name": "name1",
        "iss": true
      }
    ],
    [
      "com.qhong.test.dependBean.Person",
      {
        "age": 22,
        "name": "name2",
        "iss": true
      }
    ]
  ]
]

上面的不是严格符合json格式规范,虽然比默认二进制好

注意这里序列化json代类型 "com.qhong.test.dependBean.Person" 如果没有这个反序列化会报类型转换异常错误

也就是代码中这一段必须设置,我之前就是没有设置,反序列化都是JsonObject必须自己转换类型,否则会报错

//序列化包括类型描述 否则反向序列化实体会报错,一律都为JsonObject
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(mapper.getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

Fastjson序列化

需要倒入Fastjson到依赖

<!-- JSON工具 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.76</version>
</dependency>

实现RedisSerializer接口

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> {
    public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
    static {
        ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    }
    private final Class<T> clazz;
    public FastJson2JsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    /**
     * 序列化
     */
    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (null == t) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
     * 反序列化
    public T deserialize(byte[] bytes) throws SerializationException {
        if (null == bytes || bytes.length <= 0) {
            return null;
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);
}

配置redisTemplate

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
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;

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        FastJson2JsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJson2JsonRedisSerializer<>(Object.class);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用fastJson
        template.setValueSerializer(fastJsonRedisSerializer);
        // hash的value序列化方式采用fastJson
        template.setHashValueSerializer(fastJsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

注意这是一种方式自己实现RedisSerializer 序列化接口

但是FastJson 1.2.36版本以后不需要自己实现RedisSerializer

为我们提供序列化支持在com.alibaba.fastjson.support.spring中 有GenericFastJsonRedisSerializerFastJsonRedisSerializer 两个实现类 ,

区别在于GenericFastJsonRedisSerializer 可以自动转换对象类型,FastJsonRedisSerializer 需要自定义转换需要的类型。

通常使用 GenericFastJsonRedisSerializer 即可满足大部分场景,如果你想定义特定类型专用的 RedisTemplate 可以使用 FastJsonRedisSerializer 来代替 GenericFastJsonRedisSerializer”

FastJson github有对应问题描述lssues 我已入坑 ,刚开始一直使用FastJsonRedisSerializer****无法自动反向序列化

序列化后存储在redis后内容

{
  "@type": "com.qhong.test.dependBean.Person",
  "age": 20,
  "iss": true,
  "name": "name0"
}
[
  {
    "@type": "com.qhong.test.dependBean.Person",
    "age": 20,
    "iss": true,
    "name": "name0"
  },
  {
    "@type": "com.qhong.test.dependBean.Person",
    "age": 21,
    "iss": true,
    "name": "name1"
  },
  {
    "@type": "com.qhong.test.dependBean.Person",
    "age": 22,
    "iss": true,
    "name": "name2"
  }
]

正常情况是格式是正确的,但是如果你存储内容出现set或者doubble类型,会带上Set,D类型描述如下

会出现问题无法解析,但是在程序里是可以反向序列化的

分析参考对比

  • jdkSerializationRedisSerializer: 使用JDK提供的序列化功能。 优点是反序列化时不需要提供类型信息(class),但缺点是需要实现Serializable接口,还有序列化后的结果非常庞大,是JSON格式的5倍左右,这样就会消耗redis服务器的大量内存。
  • Jackson2JsonRedisSerializer: 使用Jackson库将对象序列化为JSON字符串。优点是速度快,序列化后的字符串短小精悍,不需要实现Serializable接口。但缺点也非常致命,那就是此类的构造函数中有一个类型参数,必须提供要序列化对象的类型信息(.class对象)。 通过查看源代码,发现其只在反序列化过程中用到了类型信息。
  • FastJsonRedisSerializer 性能最优号称最快的json解析库,但是反序列化后类字段顺序和原来实体类不一致发生改变,在某些set,double字段情况下json格式不正确,但是在程序可以解析

更多问题参考

RedisTemplate序列化方式解读

redis数据库操作

在整合了spring-boot-starter-data-redis后会自动帮我们注入redisTemplate 对象,专门用来操作reids数据库的

在reids中如果想用文件夹方式存储key的话类似这样

我们只需要在存储使用使用::表示文件夹就可以了

redisTemplate.opsForValue().set("userLoginCache::Kenx_6003783582be4c368af14daf3495559c", "user");

如果需要模糊查询key话使用*来表示 如

获取所有key

public static Set<String> getAllKey(String keys) {
        Set<String> key = redisTemplate.keys(keys + "*");
        return key;
    }

模糊批量删除

 /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    public static void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
            }
        }
    }
public static void delByPrefix(String key) {
        if (key != null) {
            Set<String> keys = redisTemplate.keys(key + "*");
            redisTemplate.delete(keys);
        }
    }

    public static void delBySuffix(String key) {
        if (key != null) {
            Set<String> keys = redisTemplate.keys("*" + key);
            redisTemplate.delete(keys);
        }
    }

    public static  void clean(){
        Set<String> keys = redisTemplate.keys("*");
        redisTemplate.delete(keys);
    }

因为使用很频繁所以我写成工具库RedisUtil 通过静态方法方式去调用就可以了

基本上包含工作中用到的所有方法, 这里附上源码

package cn.soboys.kmall.cache.utils;

import cn.hutool.extra.spring.SpringUtil;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
 * 定义常用的 Redis操作
 *
 * @author kenx
 */
public class RedisUtil {
    private static final RedisTemplate<String, Object> redisTemplate = SpringUtil.getBean("redisTemplate", RedisTemplate.class);
    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return Boolean
     */
    public static 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 static Long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
     * 判断 key是否存在
     * @param key 键
     * @return true 存在 false不存在
    public static Boolean hasKey(String key) {
            return redisTemplate.hasKey(key);
     * 删除缓存
     * @param key 可以传一个值 或多个
    public static void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(Arrays.asList(key));
    public static void delByPrefix(String key) {
        if (key != null) {
            Set<String> keys = redisTemplate.keys(key + "*");
            redisTemplate.delete(keys);
    public static void delBySuffix(String key) {
            Set<String> keys = redisTemplate.keys("*" + key);
    public static  void clean(){
        Set<String> keys = redisTemplate.keys("*");
        redisTemplate.delete(keys);
     * 普通缓存获取
     * @return 值
    public static Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
     * 普通缓存放入
     * @param key   键
     * @param value 值
     * @return true成功 false失败
    public static Boolean set(String key, Object value) {
            redisTemplate.opsForValue().set(key, value);
     * 普通缓存放入并设置时间
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
    public static Boolean set(String key, Object value, Long time) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                set(key, value);
     * 递增
     * @param delta 要增加几(大于0)
     * @return Long
    public static Long incr(String key, Long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        return redisTemplate.opsForValue().increment(key, delta);
     * 递减
     * @param delta 要减少几
    public static Long decr(String key, Long delta) {
            throw new RuntimeException("递减因子必须大于0");
        return redisTemplate.opsForValue().increment(key, -delta);
     * HashGet
     * @param key  键 不能为 null
     * @param item 项 不能为 null
    public static Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
     * 获取 hashKey对应的所有键值
     * @return 对应的多个键值
    public static Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
     * 获取 hashKey对应的所有键
     * @return 对应的多个键
    public static Set<String> hmgetKey(String key) {
        Map map = redisTemplate.opsForHash().entries(key);
        return map.keySet();
     * HashSet
     * @param map 对应多个键值
     * @return true 成功 false 失败
    public static Boolean hmset(String key, Map<String, Object> map) {
            redisTemplate.opsForHash().putAll(key, map);
     * HashSet 并设置时间
     * @param map  对应多个键值
    public static Boolean hmset(String key, Map<String, Object> map, Long time) {
                expire(key, time);
     * 向一张hash表中放入数据,如果不存在将创建
     * @param item  项
     * @return true 成功 false失败
    public static Boolean hset(String key, String item, Object value) {
            redisTemplate.opsForHash().put(key, item, value);
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    public static Boolean hset(String key, String item, Object value, Long time) {
     * 删除hash表中的值
     * @param item 项 可以使多个不能为 null
    public static void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
     * 判断hash表中是否有该项的值
    public static Boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param item 项
     * @param by   要增加几(大于0)
     * @return Double
    public static Double hincr(String key, String item, Double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
     * hash递减
     * @param by   要减少记(小于0)
    public static Double hdecr(String key, String item, Double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
     * 根据 key获取 Set中的所有值
     * @return Set
    public static Set<Object> sGet(String key) {
            return redisTemplate.opsForSet().members(key);
            return null;
     * 根据value从一个set中查询,是否存在
    public static Boolean sHasKey(String key, Object value) {
            return redisTemplate.opsForSet().isMember(key, value);
     * 将数据放入set缓存
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
    public static Long sSet(String key, Object... values) {
            return redisTemplate.opsForSet().add(key, values);
            return 0L;
     * 将set数据放入缓存
     * @param time   时间(秒)
    public static Long sSetAndTime(String key, Long time, Object... values) {
            Long count = redisTemplate.opsForSet().add(key, values);
            return count;
     * 获取set缓存的长度
    public static Long sGetSetSize(String key) {
            return redisTemplate.opsForSet().size(key);
     * 移除值为value的
     * @return 移除的个数
    public static Long setRemove(String key, Object... values) {
            return redisTemplate.opsForSet().remove(key, values);
     * 获取list缓存的内容
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return List
    public static List<Object> lGet(String key, Long start, Long end) {
            return redisTemplate.opsForList().range(key, start, end);
     * 获取list缓存的长度
    public static Long lGetListSize(String key) {
            return redisTemplate.opsForList().size(key);
     * 通过索引 获取list中的值
     * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;
     *              index<0时,-1,表尾,-2倒数第二个元素,依次类推
     * @return Object
    public static Object lGetIndex(String key, Long index) {
            return redisTemplate.opsForList().index(key, index);
     * 将list放入缓存
    public static Boolean lSet(String key, Object value) {
            redisTemplate.opsForList().rightPush(key, value);
     * @param time  时间(秒)
    public static Boolean lSet(String key, Object value, Long time) {
    public static Boolean lSet(String key, List<Object> value) {
            redisTemplate.opsForList().rightPushAll(key, value);
    public static Boolean lSet(String key, List<Object> value, Long time) {
     * 根据索引修改list中的某条数据
     * @param index 索引
    public static Boolean lUpdateIndex(String key, Long index, Object value) {
            redisTemplate.opsForList().set(key, index, value);
     * 移除N个值为value
     * @param count 移除多少个
    public static Long lRemove(String key, Long count, Object value) {
            return redisTemplate.opsForList().remove(key, count, value);
    public static Set<String> getAllKey(String keys) {
        Set<String> key = redisTemplate.keys(keys + "*");
        return key;
}

到此这篇关于SpringBoot整合edis之JSON序列化文件夹操作的文章就介绍到这了,更多相关SpringBoot整合edis JSON序列化内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot整合Redis入门之缓存数据的方法

    目录 前言 为什么要使用Redis呢? 相关依赖 配置 数据库 实体类 RedisConfig Mapper Service接口 Service实现类 测试Redis Controller 前言 Redis是一个开源的使用ANSI C语言编写.支持网络.可基于内存亦可持久化的日志型.Key-Value数据库,并提供多种语言的API.从2010年3月15日起,Redis的开发工作由VMware主持.从2013年5月开始,Redis的开发由Pivotal赞助. 为什么要使用Redis呢? 举个例子,

  • SpringBoot Redis配置Fastjson进行序列化和反序列化实现

    FastJson是阿里开源的一个高性能的JSON框架,FastJson数据处理速度快,无论序列化(把JavaBean对象转化成Json格式的字符串)和反序列化(把JSON格式的字符串转化为Java Bean对象),都是当之无愧的fast:功能强大(支持普通JDK类,包括javaBean, Collection, Date 或者enum):零依赖(没有依赖其他的任何类库). 1.写一个自定义序列化类 /** * 自定义序列化类 * @param <T> */ public class FastJ

  • SpringBoot整合Redis实现访问量统计的示例代码

    目录 前言 Spring Boot 整合 Redis 引入依赖.增加配置 翠花!上代码 前言 之前开发系统的时候客户提到了一个需求:需要统计某些页面的访问量,记得当时还纠结了一阵子,不知道怎么去实现这个功能,后来还是在大佬的带领下借助 Redis 实现了这个功能.今天又回想起了这件事,正好和大家分享一下 Spring Boot 整合 Redis 实现访问量统计的全过程. 首先先解释一下为什么需要借助 Redis,其实原因也很简单,就是因为它非常快(每秒可执行大约110000次的 SET 操作,每

  • SpringBoot整合redis中的JSON序列化文件夹操作小结

    目录 前言 快速配置 JSON序列化 jackson序列化 Fastjson序列化 分析参考对比 更多问题参考 redis数据库操作 前言 最近在开发项目,用到了redis作为缓存,来提高系统访问速度和缓解系统压力,提高用户响应和访问速度,这里遇到几个问题做一下总结和整理 快速配置 SpringBoot整合redis有专门的场景启动器整合起来还是非常方便的 <dependency> <groupId>org.springframework.boot</groupId>

  • SpringBoot整合Redis实现序列化存储Java对象的操作方法

    目录 一.背景 1.思考 2.方案 二.源码分析 三.注入RedisTemplate 1.引入依赖 2.Redis 连接信息 3.Redis 核心配置类 4.Redis工具类 四.测试 1.创建 Java 实体类 UserInfo 2.测试用例 3.测试结果 之前介绍过 https://www.jb51.net/article/223539.htm 我们可以看出,在 SpringBoot 对 Redis 做了一系列的自动装配,使用还是非常方便的 一.背景 1.思考 通过我们前面的学习,我们已经可

  • SpringBoot整合Redis正确的实现分布式锁的示例代码

    前言 最近在做分块上传的业务,使用到了Redis来维护上传过程中的分块编号. 每上传完成一个分块就获取一下文件的分块集合,加入新上传的编号,手动接口测试下是没有问题的,前端通过并发上传调用就出现问题了,并发的get再set,就会存在覆盖写现象,导致最后的分块数据不对,不能触发分块合并请求. 遇到并发二话不说先上锁,针对执行代码块加了一个JVM锁之后问题就解决了. 仔细一想还是不太对,项目是分布式部署的,做了负载均衡,一个节点的代码被锁住了,请求轮询到其他节点还是可以进行覆盖写,并没有解决到问题啊

  • springBoot整合redis使用案例详解

    一.创建springboot项目(采用骨架方式) 创建完成: 我们分析下pom文件中内容: 所使用到的关键依赖: <!--springBoot集成redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.5.4<

  • Springboot整合Redis与数据持久化

    目录 Springboot整合Redis 使用json方式存储 序列化方式存储数据 MySQL与Redis一致性解决同步问题 Redis持久化机制 全量同步与增量同步 RDB与AOF RDB AOF Springboot整合Redis 有两种存储数据的方式: 方案1:在Redis存放一个对象 使用json序列化与反序列化 方案2:直接使用redis自带序列化方式存储对象 maven依赖 <parent> <groupId>org.springframework.boot</g

  • SpringBoot 整合Redis 数据库的方法

    Redis简介 Redis(官网: https://redis.io )是一个基于内存的日志型可持久化的缓存数据库,保存形式为key-value格式,Redis完全免费开源,它使用ANSI C语言编写.与其他的key - value缓存产品一样,Redis具有以下三个特点. • Redis支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用: • Redis不仅支持简单的key-value类型数据,同时还提供字符串.链表.集合.有序集合和哈希等数据结构的存储: • R

  • 关于SpringBoot整合redis使用Lettuce客户端超时问题

    参考的博客 问题起因 做毕设的时候,使用到Lettuce连接redis,一段时间后不操作,再去操作redis,会报连接超时错误,在其重连后又可使用. 原因是:Lettuce 自适应拓扑刷新(Adaptive updates)与定时拓扑刷新(Periodic updates) 是默认关闭的导致问题的出现 解决的方案 1.重写连接工厂实例,更改其LettuceClientConfiguration 为开启拓扑更新 @Configuration public class RedisConfig { @

  • springboot整合redis实现发送邮箱并验证

    目录 1.起步 2.工具类 邮箱工具类 redis乱码解决 3.controller搭建 4.前端搭建 结果 总结 1.起步 pom文件 <!--集成redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-redis</artifactId> <version>1.4.1.RELEAS

  • SpringBoot整合Redis之编写RedisConfig

    编写RedisConfig首先我们要明白RedisConfig中需要包含什么,首先看看我们直接使用RedisTemplate的问题,我们就知道RedisConfig要包含什么了,我们在RedisConfig需要规定好根据不同的查询生成的key,key和value的序列化和反序列化 我们在RedisConfig中配置的自定义方法,最终通过注解引用的就是我们自定义的方法 RedisConfig.java   : 对redis提供的两个Template的序列化配置 /** * @Author: JCc

  • springboot整合redis之消息队列

    目录 一.项目准备 二.配置类 三.redis中list数据类型 定时器监听队列 运行即监控队列 四.发布/订阅模式 五.ZSet实现延迟队列 一.项目准备 依赖 <!-- RedisTemplate --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> &

随机推荐