Spring Boot集成Redis

去年第一次真正接触Redis的时候是做短信的验证码功能，这里主要是用到其时间的有效性，其结构有三个字段：key,value,expire。以expire中设置的时间来使存储的验证码失效。当时也有集成一般数据的新增、删除和查询功能，这时key为String（符合redis中虽有key的标准），value为Object，所以理论上来说可以满足我所有需要处理的数据通过字符串的key-value存储方式存到redis中，取出的时候根据相应类型做一个强制转换即可。很天真的以为这样就不需要Hash,list,set等的单独集成，因为我都可以用这种方式将其存储。直到后来看到通过一些指令可以查看其在redis中的存储结构才发现，以前所有的存储都是string类型，具体指令操作可以参考我另外一篇文章Redis存储结构。

其他不多说了，讲正题，Spring boot来集成Redis。

项目依赖包：

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

spring boot在1.5+的时候就不做对spring-boot-starter-redis做支持了，所以这里选用的spring-boot-starter-data-redis。

配置文件：

#redis
spring.redis.host=host
#spring.redis.password= # redis password
spring.redis.port=6379
spring.redis.pool.max-idle=8  
spring.redis.pool.min-idle=0  
spring.redis.pool.max-active=8  
spring.redis.pool.max-wait=-1  
spring.redis.timeout=60000 

host写自己的主机IP，如果安装的redis没有设置密码，这里直接把密码项给空掉就好。

缓存设置：

package com.test.redis.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Created by pkk on 2017/6/1.
 */
@Configuration
public class RedisCache extends CachingConfigurerSupport{


    /**
     * 注入 RedisConnectionFactory
     */
    @Autowired
    RedisConnectionFactory redisConnectionFactory;


    /**
     * 配置redisTemplate
     *
     * 通过redisConnectionFactory引入redis在配置文件中的连接配置
     * */
    @Bean
    public RedisTemplate<String,Object> redisTemplate(){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }

    /**
     * 设置数据存入 redis 的序列化方式
     *
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
//        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
    }


    /**
     * 实例化 HashOperations 对象,可以使用 Hash 类型操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 实例化 ValueOperations 对象,可以使用 String 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }
}

这里备注起来的是几种key的序列化方式，具体介绍可以参考我另外一篇文章Redis Hash序列化存储问题及解决，文章中没有我现在用的GenericJackson2JsonRedisSerializer()方式，这种方式相比Jackson2JsonRedisSerializer(Object.class)可以不指定序列化的类型，其他一些方面各位可以亲自操作下在redis-cli中查看下存储格式对比下就清楚了。

指令接口：

package com.test.redis.utils;

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Set;

/**
 * Created by pkk on 2017/6/1.
 */
@Component
@RestController
public class RedisUtils {

    @Resource
    protected HashOperations<String,String,Object> hashOperations;

    @Resource
    protected RedisTemplate<String,Object> redisTemplate;

    @Resource
    protected ValueOperations<String, Object> valueOperations;


    /**
     * 查询key,支持模糊查询
     *
     * @param key 传过来时key的前后端已经加入了*，或者根据具体处理
     * */
    public Set<String> keys(String key){
        return redisTemplate.keys(key);
    }


//    static <K> void rename(final K key, final K newKey, RedisOperations<K, ?> operations) {
//        operations.execute(new SessionCallback<Object>() {
//            @SuppressWarnings("unchecked")
//
//            public Object execute(RedisOperations operations) throws DataAccessException {
//                do {
//                    operations.watch(key);
//
//                    if (operations.hasKey(key)) {
//                        operations.multi();
//                        operations.rename(key, newKey);
//
//                    }
//                    else {
//                        operations.multi();
//                    }
//                } while (operations.exec() == null);
//                return null;
//            }
//        });
//    }


    /**
     * 重命名key
     * */
    public void renameKey(String key,String newKey){
        redisTemplate.rename(key,newKey);
    }


    /**
     *字符串添加信息
     * @param key
     * @param obj 可以是单个的值，也可以是任意类型的对象
     * */
    public void set(String key,Object obj){
        valueOperations.set(key,obj);
    }

    /**
     * 字符串获取值
     * @param key
     * */
    public Object get(String key){
       return valueOperations.get(key);
    }

    /**
     * 删出key
     * 这里跟下边deleteKey（）最底层实现都是一样的，应该可以通用
     * @param key
     * */
    public void delete(String key){
        valueOperations.getOperations().delete(key);
    }

    /**
     * 添加单个
     *
     * @param key    key
     * @param filed  filed
     * @param domain 对象
     */
    public void hset(String key,String filed,Object domain){
        hashOperations.put(key, filed, domain);
    }


    /**
     * 添加HashMap
     *
     * @param key    key
     * @param hm    要存入的hash表
     */
    public void hset(String key, HashMap<String,Object> hm){
        hashOperations.putAll(key,hm);
    }

    /**
     * 查询key和field所确定的值
     *
     * @param key 查询的key
     * @param field 查询的field
     * @return HV
     */
    public Object hget(String key,String field) {
        return hashOperations.get(key, field);
    }

    /**
     * 查询该key下所有值
     *
     * @param key 查询的key
     * @return Map<HK, HV>
     */
    public Object hget(String key) {
        return hashOperations.entries(key);
    }

    /**
     * 删除key下所有值
     *
     * @param key 查询的key
     */
    public void deleteKey(String key) {
        hashOperations.getOperations().delete(key);
    }

    /**
     * 判断key和field下是否有值
     *
     * @param key 判断的key
     * @param field 判断的field
     */
    public Boolean hasKey(String key,String field) {
        return hashOperations.hasKey(key,field);
    }

    /**
     * 判断key下是否有值
     *
     * @param key 判断的key
     */
    public Boolean hasKey(String key) {
        return hashOperations.getOperations().hasKey(key);
    }
}

因为我这次项目做的是用的hash结构，所以我第一次集成的是hash的相关操作，使用的是HashOperations下的方法。valueOperations是简单的string存储，所以一起实例化了。

如果想实现其他的类型，可以看下org.springframework.data.redis.core.后边相应的包，实例化相应的类型即可，记得同时对相应的类型做序列化。

因为我这里是用的redis的持久化存储，所以缓存那块自动生成key的策略给去掉了，如果需要用到，可以重写CachingConfigurerSupport下的 KeyGenerator keyGenerator() 方法。

    public Set<String> keys(String key){
        return redisTemplate.keys(key);
    }

keys这个方法比较特殊，这是用redisTemplate来调用的。这个东西是专门用来查询key的，可以说是key的模糊查询，我这里查询的时候是在传入key的时候先加上，如要查询的key中包含ell，我传入的key是：*ell，前后各加一个*，这种用法跟like查询一样，具体的可以查看keys指令。

这里注释掉的一块，本意是想另类实现redis的事务的。先说下我的需求，更新接口中，我需要把新的key-value存储，删掉旧的key-value，这里涉及到key的转变，所以我想要修改这块，必须对redis数据库同时进行这两种操作，还必须同时成功。但是，redis不支持rollback，所以只能另想办法。其中redis指令中有个multi和exec指令组合可以实现这种需求，但是spring或者项目中没能实现这种功能，因为他们不能保证multi执行的时候的session和exec执行时的session一致（中间的一些操作也必须使用同一个session）。在网上找了下说是上面备注起来的方法可以保证session的一致性，但是他不能做增删类的操作，具体的各位可以上网搜下。所以，上面被备注起来的也是不适合的方法。

因为我的项目没有涉及到时效，所以集成的时候没有做时效的方法，如果各位需要，在IDE里点击各种set方法就可以看出怎么实现，就是多加了个时间参数。

如果各位遇到问题，可以给我留言，如果能解决的话一定给回复。