Springboot2 整合 Redis 配置

前提是曾经装置好了 redis 并启动，这儿仅是 springboot 我的项目的整合

一、导入依赖

<!-- 数据库连接池，redis-starter 其实曾经蕴含了 pool1 版本，这儿应用 2 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

二、yml 文件中配置 redis

spring:
  redis:
    host: *******
    port: ****
    password: *******
    lettuce:  #配置连接池属性
      pool:
        max-active: 500 #连接池最大连接数
        max-wait: -1 #最大阻塞等待时间，正数示意没有限度
        max-idle: 10 #最大闲暇连贯
        min-idle: 0 #最小闲暇连贯
        timeout: 30000 #超时工夫，单位 ms
  cache:  #配置缓存的名称
    cache-names: redisCache
    type: redis

三、配置 redis 序列化

redis-starter 提供了 StringRedisTemplate 以及 RedisTemplate 两种模板，看源码能够发现 StringRedisTemplate 是继承自 RedisTemplate

public class StringRedisTemplate extends RedisTemplate<String, String> {public StringRedisTemplate() {this.setKeySerializer(RedisSerializer.string());
        this.setValueSerializer(RedisSerializer.string());
        this.setHashKeySerializer(RedisSerializer.string());
        this.setHashValueSerializer(RedisSerializer.string());
    }

    public StringRedisTemplate(RedisConnectionFactory connectionFactory) {this();
        this.setConnectionFactory(connectionFactory);
        this.afterPropertiesSet();}

    protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {return new DefaultStringRedisConnection(connection);
    }
}

如果操作对象仅仅是简略的 string 类型，倡议间接应用 StringRedisTemplate 即可，因为它应用了 StringRedis 序列化，不必本人重写序列化形式。如果要应用存取对象的性能，则须要应用 RedisTemplate，并重写它的序列化形式，看配置源码可晓得 @ConditionalOnMissingBean 在给定的在 bean 不存在时, 则实例化以后 Bean，所以咱们本人配置同样的办法并注册，即可实现自定义序列化形式。

@Bean
@ConditionalOnMissingBean(name = {"redisTemplate"}
)
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<Object, Object> template = new RedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

另外如果须要往 redis 中存取数据以及开启缓存，咱们也须要写一个 cacheManager 办法，整合到一个 RedisConfig 配置类中，代码如下：

@Configuration // 标记此类为配置类
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {// 这儿重写了 RedisTemplate 序列化形式(redis 默认的是 JDK 序列化，须要让每个对象类实现序列化接口能力进行存取，且可视化不敌对)，并应用 Bean 注解将之注入到容器中进行治理
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownException {
        // 咱们个别应用 string，object 类型
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 序列化配置，应用 Jackson 形式
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key 采纳 string 序列化形式
        template.setKeySerializer(stringRedisSerializer);
        // hash 的 key 同样
        template.setHashKeySerializer(stringRedisSerializer);
        // value 采纳 jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash 的 value 同样
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }
    
    // 这儿是对缓存进行配置，同样采纳 Jackson 序列化形式
    @Bean
    RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {StringRedisSerializer strSerializer = new StringRedisSerializer();

        Jackson2JsonRedisSerializer<Object> jacksonSerial = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jacksonSerial.setObjectMapper(om);

        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                                        // 无效工夫设置为 1 天
                                        .entryTtl(Duration.ofDays(1))

                                        .serializeKeysWith(RedisSerializationContext.SerializationPair

                                        .fromSerializer(strSerializer))

                                        .serializeValuesWith(RedisSerializationContext.SerializationPair

                                        .fromSerializer(jacksonSerial))

                                        .disableCachingNullValues();

        return RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(config).build();}

}

四、RedisUtils

在理论的工作中，并不需要咱们应用原生的形式去应用 Redis，相似于这样：stringRedis.opsForValue()。个别会编写一个 Redis 工具类来封装这些用法，网上轻易能够找到，我本人也是网上轻易下载的一个，在我的 gitee 里有源码。

五、测试

到这儿就能够实现根本的存取数据、缓存操作了，轻易写两个 Demo 测试一下。
首先测试 RedisTemplate，存入简略的 key-value：

    // 放订单两倍的人进入音讯队列进行领先付款
    redisUtils.set("Goods" + goods.getId(), goods.getNumber() * 2);

后果如下

而后测试缓存，老样子写一个简略的最简略的 @Cacheable 注解：

/**
 * 商品信息退出缓存中
 * @return 返回商品信息
 */
@Cacheable(value = "redisCache", key = "'Goods'")
public Goods findGoods(Integer id){return cacheMapper.findGoods(id);
}

而后本人轻易写一个测试方法调用此办法，再看 redis 可视化软件，后果图片如下：

能够看到 json 对象缓存胜利，到此结束 redis 的根本配置。