SpringBoot2快速入门07--redis-CFANZ编程社区

boot2不仅支持ORM框架，而且还支持redis，我们经常使用redis作缓存，之前java使用jedis连接redis服务，现在使用Lettuce作为连接客户端，它使用Netty的连接实例，可以在多个线程间并发访问。

导入依赖，如下：

    compile('org.springframework.boot:spring-boot-starter')
    compile('org.springframework.boot:spring-boot-starter-web')
    compile('org.springframework.boot:spring-boot-starter-data-redis')
    compile('org.apache.commons:commons-pool2')

commons依赖主要应用于单机版

redis配置，如下：

redis单机版

  redis:
    host: 127.0.0.1
    #password:
    timeout: 1000
    database: 0  #默认有16个db(集群模式用hash槽代替)，这里配置具体使用的db，默认是0
    lettuce:
      pool:
        max-active: 8 #最大连接数（使用负值表示没有限制） 默认 8
        max-wait: -1 #最大阻塞等待时间（使用负值表示没有限制） 默认 -1
        max-idle: 8  #最大空闲连接 默认 8
        min-idle: 0

可以配置需要获取的数据库，账号、密码，连接池等等。

redis集群版

redis:
    timeout: 6000ms
    database: 0
    cluster:
      nodes:
        - 192.168.40.156:7001
        - 192.168.40.156:7002
        - 192.168.40.157:7003
        - 192.168.40.157:7004
        - 192.168.40.158:7005
        - 192.168.40.158:7006
      max-redirects: 3 # 获取失败 最大重定向次数
    lettuce:
      pool:
        max-active: 1000  #连接池最大连接数（使用负值表示没有限制）
        max-idle: 10 # 连接池中的最大空闲连接
        min-idle: 5 # 连接池中的最小空闲连接
        max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制）

添加RedisConfig 添加序列化方式以及缓存配置

@Configuration
@EnableCaching // 开启缓存支持
public class RedisConfig extends CachingConfigurerSupport {

    @Resource
    private LettuceConnectionFactory lettuceConnectionFactory;

    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuffer sb = new StringBuffer();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    // 缓存管理器
    @Bean
    public CacheManager cacheManager() {
        RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager.RedisCacheManagerBuilder
                .fromConnectionFactory(lettuceConnectionFactory);
        @SuppressWarnings("serial")
        Set<String> cacheNames = new HashSet<String>() {
            {
                add("codeNameCache");
            }
        };
        builder.initialCacheNames(cacheNames);
        return builder.build();
    }

    /**
     * RedisTemplate配置
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
         // 设置序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, Visibility.ANY);
        om.enableDefaultTyping(DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringSerializer);// key序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);// value序列化
        redisTemplate.setHashKeySerializer(stringSerializer);// Hash key序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);// Hash value序列化
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

注：序列化带泛型的数据时，会以map的结构进行存储，反序列化是不能将map解析成对象。
解决方案：序列化存储时，转成JSON字符串

自定义Template
默认情况下，RedisTemplate只支持字符串，在开发中常需要存入对象，我们可以自定义一个模板，如下：

@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisCacheAutoConfiguration {
    @Bean
    public RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Serializable> template = new RedisTemplate<>();
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

注：使用GenericJackson2JsonRedisSerializer序列化时，会保存序列化的对象的包名和类名，反序列化时以这个作为标示就可以反序列化成指定的对象。

测试上面的template

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ApplicationTests {
    private static final Logger log = LoggerFactory.getLogger(ApplicationTests.class);
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisTemplate<String, Serializable> redisCacheTemplate;

    @Test
    public void get() {
                //存入字符串
        stringRedisTemplate.opsForValue().set("key1", "value1");
        final String k1 = stringRedisTemplate.opsForValue().get("key1");
        log.info("字符缓存结果 - {}", k1);
        String key = "user:1";
        User user1 = new User();
        user1.setAge(22);
        user1.setName("test");
                //存入对象
        redisCacheTemplate.opsForValue().set(key, user1);
        final User user = (User) redisCacheTemplate.opsForValue().get(key);
        log.info("对象缓存结果 - {}", user);
    }
}

关于redis的操作方式，还有其它几种：

opsForValue：对应 String（字符串）
opsForZSet：对应 ZSet（有序集合）
opsForHash：对应 Hash（哈希）
opsForList：对应 List（列表）
opsForSet：对应 Set（集合）