SpringBoot（九）——整合Redis并且使用Json进行格式化

我不是女神ヾ 2022-01-12 15:15 509阅读 0赞

> 整合Redis当然你要拥有一个Redis客户端，这个我就直接下载和配置了，没有的可以去下载一波

## 使用RedisTemplate ##

在SpringBoot中整合Redis很简单，只需要下面几个步骤

1.  安装Redis（省略）
2.  引入springdata-redis的依赖

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

1.  配置redis

############################################REDIS的可选配置###################
    #redis配置
    #Redis服务器地址
    spring.redis.host=127.0.0.1
    #Redis服务器连接端口
    spring.redis.port=6379
    #Redis数据库索引（默认为0）
    spring.redis.database=0  
    #连接池最大连接数（使用负值表示没有限制）
    spring.redis.jedis.pool.max-active=50
    #连接池最大阻塞等待时间（使用负值表示没有限制）
    spring.redis.jedis.pool.max-wait=3000
    #连接池中的最大空闲连接
    spring.redis.jedis.pool.max-idle=20
    #连接池中的最小空闲连接
    spring.redis.jedis.pool.min-idle=2
    #连接超时时间（毫秒）
    spring.redis.timeout=5000

1.  注入RedisTemplate进行测试

@RunWith(SpringRunner.class)
    @SpringBootTest
    @Slf4j
    public class ShopApplicationTests {
    
        @Autowired
        StringRedisTemplate stringRedisTemplate;
    
        @Autowired
        RedisTemplate redisTemplate;
    
        @Test
        public void test01() {
            stringRedisTemplate.opsForValue().set("k1", "v1");
        }
        @Test
        public void test02(){
            String k1 = stringRedisTemplate.opsForValue().get("k1");
            log.info("拿到{}",v1);
        }
        
    }

![在这里插入图片描述][20190618000204548.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjA1OTY4_size_16_color_FFFFFF_t_70]

1.  自定义序列化器（如果不想使用JDK自带的序列化器）

> 我认为自定义序列化器有两种方法，第一种使用Spring配置一个特定的序列化器，第二种就是先将这个对象进行转化，然后将这个字符串存入Redis。

这里就以JSON序列为例，并且使用在Spring中配置序列化器

没有进行序列化设置默认采用JDK序列化

@Test
        public void test03(){
            User user = new User();
            user.setId(1);
            user.setName("张三");
            redisTemplate.opsForValue().set("obj",user);
    
        }@Test
        public void test04(){
            User obj = (User) redisTemplate.opsForValue().get("obj");
            System.out.println(obj);
        }

在Redis中显示如下  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjA1OTY4_size_16_color_FFFFFF_t_70 1]  
可以从Java自动反序列化拿到这个序列化的数据  
![在这里插入图片描述][20190618002511938.png]  
虽然这样可以序列化对象，但是可读性太差，并且适用性不广泛，因此就让它转换一种序列化的形式

**Redis序列化的原理**

1.  当我们导入starter时，会默认生成一个RedisCahceManager（不进行配置的话@MissingConfiguration）
2.  然后RedisCacheManager帮我们创建RedisCahce来操作（通过使用RedisTemplate<Object,Object>）
3.  然后RedisTemplate默认采用的是JDK序列化机制

因此我们就有思路怎样去配置Redis的序列化

package com.wrial.shop.config;
    
    import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cache.CacheManager;
    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.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    @Slf4j
    @Configuration
    @EnableCaching//启用缓存，这个注解很重要；
    //继承CachingConfigurerSupport，为了自定义生成KEY的策略。可以不继承。
    public class CacheConfig extends CachingConfigurerSupport {
    
        @Bean(name="redisTemplate")
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(redisConnectionFactory);
    
            FastJsonRedisSerializer<Object> serializer = new FastJsonRedisSerializer<Object>(Object.class);
            // value值的序列化采用fastJsonRedisSerializer
            template.setValueSerializer(serializer);
            template.setHashValueSerializer(serializer);
            // key的序列化采用StringRedisSerializer
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
    
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory factory) {
            // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
            // 设置缓存的默认过期时间，也是使用Duration设置
            config = config.entryTtl(Duration.ofMinutes(1))
                    .disableCachingNullValues();     // 不缓存空值
    
            // 设置一个初始化的缓存空间set集合
            Set<String> cacheNames =  new HashSet<>();
            cacheNames.add("my-redis-cache1");
            cacheNames.add("my-redis-cache2");
    
            // 对每个缓存空间应用不同的配置
            Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
            configMap.put("my-redis-cache1", config);
            configMap.put("my-redis-cache2", config.entryTtl(Duration.ofSeconds(120)));
    
            // 使用自定义的缓存配置初始化一个cacheManager
            RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                    .initialCacheNames(cacheNames)  // 注意这两句的调用顺序，一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                    .withInitialCacheConfigurations(configMap)
                    .build();
            return cacheManager;
        }
    }

使用测试类进行测试

@Test
        public void test05(){
            User user = new User();
            user.setId(5);
            user.setName("王五");
            redisTemplate.opsForValue().set("user1",user);
        }
        @Test
        public void test06(){
            Object user = redisTemplate.opsForValue().get("user");
            User t = (User) JSON.toJavaObject((JSON) user, User.class);
            System.out.println(t);
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjA1OTY4_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][20190618111618111.png]

[20190618000204548.png]: /images/20220112/0ede50df95b340e7a67ee3b4bccd2d59.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjA1OTY4_size_16_color_FFFFFF_t_70]: /images/20220112/f40662aafc9b465c950993807684ec85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjA1OTY4_size_16_color_FFFFFF_t_70 1]: /images/20220112/623d714eb52e4fe8be8182e97d6e6115.png
[20190618002511938.png]: /images/20220112/00b4669f3ca04ad7b533c9c9e880de21.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjA1OTY4_size_16_color_FFFFFF_t_70 2]: /images/20220112/a984cf0e054d44ca9a50f8e10c42767f.png
[20190618111618111.png]: /images/20220112/4bff8f25c8d64c1d82e761aacb6a5262.png