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的根本配置。