精华内容
下载资源
问答
  • Redis自定义序列化

    2021-06-01 20:33:24
    Redis自定义序列化 配置类 /** * redis序列化配置 * @author dlz * @version 1.0.0 * @date 2021/6/1 19:49 */ @Configuration public class RedisSerializerConfig { @Bean public RedisTemplate<...

    Redis自定义序列化

    1. 配置类
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import java.time.Duration;
    import org.springframework.cache.CacheManager;
    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.connection.lettuce.LettuceConnectionFactory;
    import org.springframework.data.redis.core.HashOperations;
    import org.springframework.data.redis.core.ListOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.SetOperations;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.data.redis.core.ZSetOperations;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * redis序列化配置.
     *
     * @author dlz
     * @version 1.0.0
     * @since 2021/6/1 19:49
     */
    @Configuration
    public class RedisConfig {
      /**
       * redis生成.
       *
       * @param factory 工厂
       * @return redisTemplate
       */
      @Bean
      public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(factory);
    
        // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值(默认使用JDK的序列化方式)
        Jackson2JsonRedisSerializer<Object> jrs = new Jackson2JsonRedisSerializer<>(Object.class);
        // GenericJackson2JsonRedisSerializer jacksonSeial = new GenericJackson2JsonRedisSerializer();
    
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型,类必须是非final修饰的,final修饰的类,比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jrs.setObjectMapper(om);
    
        redisTemplate.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
        // 值采用json序列化
        redisTemplate.setValueSerializer(jrs);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        redisTemplate.setKeySerializer(new StringRedisSerializer());
    
        // 设置hash key 和value序列化模式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jrs);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
      }
    
      /**
       * 缓存配置管理器.
       *
       * @param factory 工厂
       * @return CacheManager
       */
      @Bean
      public CacheManager cacheManager(LettuceConnectionFactory factory) {
        // 配置序列化(缓存默认有效期 6小时)
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(6));
        RedisCacheConfiguration configuration = config.serializeKeysWith(RedisSerializationContext
            .SerializationPair.fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext
                .SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter(factory))
            .cacheDefaults(configuration).transactionAware().build();
      }
    
      /**
       * 对hash类型的数据操作.
       *
       * @param redisTemplate redisTemplate
       * @return HashOperations
       */
      @Bean
      public HashOperations<Object, Object, Object> hashOperations(RedisTemplate<Object, Object> redisTemplate) {
        return redisTemplate.opsForHash();
      }
    
      /**
       * 对redis字符串类型数据操作.
       *
       * @param redisTemplate redisTemplate
       * @return ValueOperations
       */
      @Bean
      public ValueOperations<Object, Object> valueOperations(RedisTemplate<Object, Object> redisTemplate) {
        return redisTemplate.opsForValue();
      }
    
      /**
       * 对链表类型的数据操作.
       *
       * @param redisTemplate redisTemplate
       * @return ListOperations
       */
      @Bean
      public ListOperations<Object, Object> listOperations(RedisTemplate<Object, Object> redisTemplate) {
        return redisTemplate.opsForList();
      }
    
      /**
       * 对无序集合类型的数据操作.
       *
       * @param redisTemplate redisTemplate
       * @return SetOperations
       */
      @Bean
      public SetOperations<Object, Object> setOperations(RedisTemplate<Object, Object> redisTemplate) {
        return redisTemplate.opsForSet();
      }
    
      /**
       * 对有序集合类型的数据操作.
       *
       * @param redisTemplate redisTemplate
       * @return ZSetOperations
       */
      @Bean
      public ZSetOperations<Object, Object> sortedSetOperations(RedisTemplate<Object, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
      }
    }
    
    
    1. 正常使用注入就可以了
    2. 效果(Redis可视化工具中看数据)
      在这里插入图片描述
    展开全文
  • 主要介绍了SpringBoot2.3整合redis缓存自定义序列化的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Redis实现自定义序列化方式

    千次阅读 2020-07-30 11:06:45
    1. 如何实现redis序列化序列化:把对象转换为字节序列的过程称为对象的序列化。 反序列化:把字节序列恢复为对象的过程称为对象的反序列化序列化主要用于存储对象状态为另一种通用格式,比如存储为二进制、...

    1. 如何实现redis的序列化?

    序列化:把对象转换为字节序列的过程称为对象的序列化。
    反序列化:把字节序列恢复为对象的过程称为对象的反序列化。

    序列化主要用于存储对象状态为另一种通用格式,比如存储为二进制、xml、json等等,把对象转换成这种格式就叫序列化,而反序列化通常是从这种格式转换回来。

    使用序列化主要是因为跨平台和对象存储的需求,因为网络上只允许字符串或者二进制格式,而文件需要使用二进制流格式,如果想把一个内存中的对象存储下来就必须使用序列化转换为xml(字符串)、json(字符串)或二进制(流)

    我们看看源码:redis的key和value为什么需要序列化?如何序列化?

    ① RedisAutoConfiguration的源码: Redis为我们提供了两个模板类RedisTemplate和StringRedisTemplate:

    public class RedisAutoConfiguration {
        public RedisAutoConfiguration() {
        }
    
        @Bean
        @ConditionalOnMissingBean(
            name = {"redisTemplate"}
        )
        //RedisTemplate的key和value都是Object类型的,如果进行网络传输或将数据存储到硬盘上就需对key和value进行序列化
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
            RedisTemplate<Object, Object> template = new RedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
        @Bean
        @ConditionalOnMissingBean
        public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
            StringRedisTemplate template = new StringRedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    }
    

    ② StringRedisTemplate的源码:可以看出他的键和值都只支持String类型

    //StringRedisTemplate类继承RedisTemplate<String, String>
    public class StringRedisTemplate extends RedisTemplate<String, String> {
        //将key和value都序列化为String类型的,也是只支持String类型的key和value
        public StringRedisTemplate() {
            this.setKeySerializer(RedisSerializer.string());
            this.setValueSerializer(RedisSerializer.string());
            this.setHashKeySerializer(RedisSerializer.string());
            this.setHashValueSerializer(RedisSerializer.string());
        }
    }
    

    ③ RedisSerializer 的源码:可以看到redis提供的几种序列化方式:

    StringRedisTemplate默认采用的是String的序列化策略**(StringRedisSerializer),保存的key和value都是采用此策略序列化保存的。
    RedisTemplate默认采用的是JDK的序列化策略
    (JdkSerializationRedisSerializer)**,保存的key和value都是采用此策略序列化保存的。用JdkSerializationRedisSerializer序列化的话,被序列化的对象必须实现Serializable接口。在存储内容时,除了属性的内容外还存了其它内容在里面,总长度长,且不容易阅读。

    public interface RedisSerializer<T> {
        @Nullable
        byte[] serialize(@Nullable T var1) throws SerializationException;
    
        @Nullable
        T deserialize(@Nullable byte[] var1) throws SerializationException;
    
        static RedisSerializer<Object> java() {
            return java((ClassLoader)null);
        }
    
        static RedisSerializer<Object> java(@Nullable ClassLoader classLoader) {
            return new JdkSerializationRedisSerializer(classLoader);
        }
    
        //保存对象为json,它不仅可以将对象序列化,还可以将对象转换为json字符串并保存到redis中,但需要和jackson配合一起使用。
        static RedisSerializer<Object> json() {
            return new GenericJackson2JsonRedisSerializer();
        }
    
        //将String字符串对象序列化为二进制字节数组,底层使用的StringRedisSerializer
        static RedisSerializer<String> string() {
            return StringRedisSerializer.UTF_8;
        }
    }
    

    RedisTemplate的key和value都支持Object类型;而StringRedisTemplate的key和value都支持String类型;现在我们希望Redis的key支持String类型,value支持Object类型:

    key和hashKey : 推荐使用 StringRedisSerializer: 简单的字符串序列化;

    value和hashValue: 推荐使用 GenericJackson2JsonRedisSerializer;

    @Configuration
    public class RedisConfig {
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
    
            // 设置key的序列化方式
            template.setKeySerializer(RedisSerializer.string());
            // 设置value的序列化方式
            template.setValueSerializer(RedisSerializer.json());
            // 设置hash的key的序列化方式
            template.setHashKeySerializer(RedisSerializer.string());
            // 设置hash的value的序列化方式
            template.setHashValueSerializer(RedisSerializer.json());
    
            template.afterPropertiesSet();
            return template;
        }
    }
    

    除此之外,还可以模仿StringRedisTemplate的序列化方式,自定义序列化方式对Object对象进行序列化:

    StringRedisSerializer的源码:将String序列化为二进制byte数组;

    public class StringRedisSerializer implements RedisSerializer<String> {
        private final Charset charset;
        public static final StringRedisSerializer US_ASCII;
        public static final StringRedisSerializer ISO_8859_1;
        public static final StringRedisSerializer UTF_8;
    
        public StringRedisSerializer() {
            this(StandardCharsets.UTF_8);
        }
    
        public StringRedisSerializer(Charset charset) {
            Assert.notNull(charset, "Charset must not be null!");
            this.charset = charset;
        }
    
        //将字节数组反序列化为String字符串
        public String deserialize(@Nullable byte[] bytes) {
            return bytes == null ? null : new String(bytes, this.charset);
        }
    
        //将String序列化为二进制byte[]数组
        public byte[] serialize(@Nullable String string) {
            return string == null ? null : string.getBytes(this.charset);
        }
    
        static {
            US_ASCII = new StringRedisSerializer(StandardCharsets.US_ASCII);
            ISO_8859_1 = new StringRedisSerializer(StandardCharsets.ISO_8859_1);
            UTF_8 = new StringRedisSerializer(StandardCharsets.UTF_8);
        }
    }
    

    模仿StringRedisTemplate的序列化实现源码,对Object对象进行序列化:

    public class MyStringRedisSerializer implements RedisSerializer<Object> {
        private final Charset charset;
    
        public MyStringRedisSerializer() {
            this(StandardCharsets.UTF_8);
        }
    
        public MyStringRedisSerializer(Charset charset) {
            Assert.notNull(charset, "Charset must not be null!");
            this.charset = charset;
        }
    
        @Override
        public String deserialize(byte[] bytes) {
            return (bytes == null ? null : new String(bytes, charset));
        }
    
        //将对象序列化为byte[]数组
        @Override
        public byte[] serialize(Object object) {
            //如果这个对象为null
            if (object == null) {
                return new byte[0];
            }
            //如果这个对象时String类型
            if (object instanceof String) {
                return object.toString().getBytes(charset);
            //如果这个对象不是String类型,就将这个对象转换为String类型后,然后转成byte字节数组
            } else {
                String string = JSON.toJSONString(object);
                return string.getBytes(charset);
            }
        }
    }
    

    配置一个RedisTemplate<String,Object>到Spring容器中:

    @Configuration
    public class RedisConfig {
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            //key--String:定义一个 StringRedisSerializer 
            StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
            //value---Object:定义一个 MyStringRedisSerializer
            MyStringRedisSerializer myStringRedisSerializer = new MyStringRedisSerializer();
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setValueSerializer(myStringRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            redisTemplate.setHashValueSerializer(myStringRedisSerializer);
            return redisTemplate;
        }
    }
    
    展开全文
  • 1. 引入依赖 ...--redis依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> ...

    1. 引入依赖

        <!--redis依赖-->
        <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

     

    2. application.yml配置文件:

    spring:
      redis:
        host: 106.53.89.106
        port: 6379
        password: 123456
        lettuce:
          pool:
            # 连接池最大连接数(使用负值表示没有限制)
            max-active: 1024
            # 连接池最大阻塞等待时间(使用负值表示没有限制)10秒
            max-wait: PT10S
            # 连接池中的最大空闲连接
            max-idle: 200
            # 连接池中的最小空闲连接
            min-idle: 0
        # 连接超时时间(10秒)
        timeout: PT10S
    

     

    3. 设置Redis 序列化方式

    先看一下目录结构:

     

    如上图所示 创建一个 serializer 包——>MyStringRedisSerializer.java 文件

    代码如下:

    
    import com.alibaba.fastjson.JSON;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.util.Assert;
    
    import java.nio.charset.Charset;
    import java.nio.charset.StandardCharsets;
    
    /**
     * @ClassName: MyStringRedisSerializer
     * TODO:设置Redis 序列化方式
     * @Author: Liujinxin
     * @UpdateUser: Liujinxin
     * @Version: 0.0.1
     */
    public class MyStringRedisSerializer implements RedisSerializer<Object> {
        private final Charset charset;
    
        public MyStringRedisSerializer() {
            this(StandardCharsets.UTF_8);
        }
    
        public MyStringRedisSerializer(Charset charset) {
            Assert.notNull(charset, "Charset must not be null!");
            this.charset = charset;
        }
    
        @Override
        public String deserialize(byte[] bytes) {
            return (bytes == null ? null : new String(bytes, charset));
        }
    
        @Override
        public byte[] serialize(Object object) {
            if (object == null) {
                return new byte[0];
            }
            if(object instanceof String){
                return object.toString().getBytes(charset);
            }else {
                String string = JSON.toJSONString(object);
                return string.getBytes(charset);
            }
    
        }
    
    }
    

     

     

    需要将自定义的redis序列化方式 注入到bean中管理:

    创建一个 config 包——>RedisConfig.java 文件

    代码如下:

    import com.jsz.jisuzhan.serializer.MyStringRedisSerializer;
    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;
    
    /**
     * @ClassName: RedisConfig
     * @Author: Liujinxin
     * @UpdateUser: Liujinxin
     * @Version: 0.0.1
     */
    @Configuration
    public class RedisConfig {
    
        @Bean
        public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
            RedisTemplate<String,Object> redisTemplate=new RedisTemplate<>();
            redisTemplate.setConnectionFactory(redisConnectionFactory);
            StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
            MyStringRedisSerializer myStringRedisSerializer=new MyStringRedisSerializer();
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            redisTemplate.setHashValueSerializer(myStringRedisSerializer);
            redisTemplate.setValueSerializer(myStringRedisSerializer);
            return redisTemplate;
        }
    }

     

     

     

     

    展开全文
  • 我们知道在spring默认的是jdk的序列化,在实际开发中能会遇到一些问题,所以我们要自定义自己的序列化模板,用来序列化String、set、key、value、hash。 我们创建一个Bean加入容器,就会触发RedisTemplate上的条件...

    我们知道在spring默认的是jdk的序列化,在实际开发中能会遇到一些问题,所以我们要自定义自己的序列化模板,用来序列化String、set、hash。

    我们创建一个Bean加入容器,就会触发RedisTemplate上的条件注解使默认的RedisTemplate失效。在这里插入图片描述

    @Configuration
    public class RedisConfig {
    
    
    
        // 自己定义了一个 RedisTemplate
        @Bean
        @SuppressWarnings("all")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            // 我们为了自己开发方便,一般直接使用 <String, Object>
            RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
            template.setConnectionFactory(factory);
            // 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序列化方式采用jackson
            template.setValueSerializer(jackson2JsonRedisSerializer);
            // hash的value序列化方式采用jackson
            template.setHashValueSerializer(jackson2JsonRedisSerializer);
            template.afterPropertiesSet();
            return template;
        }
    }
    
    
    
    展开全文
  • 传送门(哈哈.......)
  • -- redis --><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId></dependency> ...
  • springboot整合redis自定义序列化方式 1.添加spring-boot-starter-data-redis依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-...
  • 1.1、使用自定义FastJSON来序列化你的对象 注意如果不配置白名单地址将会出现com.alibaba.fastjson.JSONException: autoType is not support具体可以看看我的转载文章... public class FastJson2Json...
  • redis自定义配置类实现json格式序列化value值 ** 在自己的redis配置类加入下面代码即可: @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { ...
  • redis-cluster结合springboot的使用自定义缓存数据的序列化方式方便通过命令行查看里面的内容,里面包含一整套的代码内容,只需要将缓存地址换成自己的集群地址即可,亲测可用的代码内容.
  • SpringBoot集成Redis,并自定义对象序列化

    万次阅读 多人点赞 2019-03-13 10:21:25
    SpringBoot项目使用redis非常简单,pom里面引入redis的场景启动器,在启动类上加@EnableCaching注解,项目启动会自动匹配上redis,这样项目中就可以愉快地使用了, 使用方法:要么使用@Cacheable一类的注解自动缓存...
  • RestTemplate默认是用的jdk序列化,会导致乱码问题,解决方式,自定义序列化即可 自定义RidesTemplate配置类 编写redistemplate配置类,实现自定义序列化 @Configuration public class RedisConfig { @Bean @...
  • } 配置类: /** * 自定义redis配置 */ @Configuration public class MyRedisConfig extends CachingConfigurerSupport { /** 重写生成key的方法:类名+方法名+参数名 */ @Bean @Override public KeyGenerator ...
  • @Configuration public class RedisConfig { @Bean public RedisSerializer fastJsonJsonRedisSerializer() { return new FastJsonRedisSerializer(Object.class); } ...
  • 使用FastJson序列化 public class FastJsonRedisSerializer<T> implements RedisSerializer<T> { private final Class<T> clazz; public FastJsonRedisSerializer(Class<T> clazz) { ...
  • redis序列化自定义
  • Spring Session + Redis——自定义JSON序列化解决方案 问题分析 RedisHttpSessionConfiguration中,Bean名称必须是springSessionDefaultRedisSerializer才能指定Jackson序列化器。 @Autowired(required = false...
  • 本文主要目的是记录自己所...org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'org.springframework.data.redis.core.RedisTemplate&lt;java.lang.String, java....
  • 首选要说明redis的默认序列化方式是采用的jdk序列化方式。 从这里源码也可以看出 那么jdk序列化方式有什么缺点。 存储在redis中数据乱码,会有转义字符。比如默认jdkSerializeable序列化后cli...自定义序列化redis
  • 1.引言 ...我们在缓存中看到的序列化数据不直观,如果想看到类似json的数据格式,就需要自定义序列化规则。 2.整合redis pom.xml: <!--引入redis--> <dependency> <groupId>
  • 自定义方式解决了取出来的value值都是linkedhashmap问题。 import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.databind.ObjectMapper; import ...
  • // Json序列化配置 Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL,...
  • Redis简介 redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持...
  • 自定义序列化接口 ,实现RedisSerializer接口 import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.serializer.SerializerFeature; import org.springframework.data.redis.serializer....
  • Redis的默认配置在org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration中,Spring启动时会自动加载默认配置。对于RedisTemplate,如果系统中没有指定的Bean,则会加载默认的RedisTemplate,...
  • 所以这边我就自定义了RedisTemplate来修改Redis序列化方式。而且封装了常用的Redis的操作。 一、创建自定义配置类RedisConfig package com.riemann.springbootdemo.config; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,356
精华内容 10,142
关键字:

redis自定义序列化

redis 订阅