Springboot如何使用Redis

     现在公司项目使用的是SpringBoot框架，因为最近需要使用redis缓存，所以就需要写一个公共的redis工具类，发现其实SpringBoot对redis已经进行了封装，只需要加入redis的相关依赖就可以了。首先在pom.xml加入依赖：

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

     然后写redis配置类RedisConfiguration，需要注意的是在配置中一般需要配置redisTemplate的序列化方式,因为Spring redis的默认序列化方式是JDK序列化，所以缓存对象一般都要实现java.io.Serializable接口，不然在使用时会报错，而且在redis中读取内容时，除了属性信息外还会有很多其他信息，可读性较差。我这里使用的是GenericJackson2JsonRedisSerializer接口，相比Jackson2JsonRedisSerializer接口多了@class属性，类的全路径包名，方便反系列化。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
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.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
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.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

/**
 * redis配置
 *
 * @create 2018-04-24 下午9:38
 **/
@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport {
    @Value("${redis.host}")
    private String host;
    @Value("${redis.port}")
    private Integer port;
    @Value("${redis.timeout}")
    private Integer timeout;
    @Value("${redis.maxTotal}")
    private Integer maxTotal;
    @Value("${redis.maxIdle}")
    private Integer maxIdle;
    @Value("${redis.maxWaitMillis}")
    private Long maxWaitMillis;
    @Value("${redis.testOnBorrow}")
    private Boolean testOnBorrow;
    @Value("${redis.database}")
    private Integer database;


    /**
     * 缓存管理器.
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
        CacheManager cacheManager = new RedisCacheManager(redisTemplate);
        return cacheManager;
    }


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

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        JedisPoolConfig jedisPoolConfig = getJedisPoolConfig();
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(host);
        jedisConnectionFactory.setPort(port);
        jedisConnectionFactory.setDatabase(database);
        jedisConnectionFactory.setUsePool(true);
        jedisConnectionFactory.setPoolConfig(jedisPoolConfig);
        return jedisConnectionFactory;
    }

    private JedisPoolConfig getJedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
        //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
        jedisPoolConfig.setMaxTotal(maxTotal);
        //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
        jedisPoolConfig.setMaxIdle(maxIdle);
        //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
        jedisPoolConfig.setTestOnBorrow(testOnBorrow);
        return jedisPoolConfig;
    }

    /**
     * 设置数据存入 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 GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
    }


}

      其中redisTemplate是Spring对Redis的相关操作的封装类，支持Redis的原生api，一般在定义RedisTemplate<K,V>，K的类型一般使用String，V的类型根据自己的业务需求进行定义，一般定义类型为Object，避免定义为RedisTemplate<Object,Object>。在RedisTemplate已经定义了对五种数据类型的操作：

redisTemplate.opsForValue();//字符串操作
redisTemplate.opsForHash();//hash操作
redisTemplate.opsForList();//list操作
redisTemplate.opsForSet();//set操作
redisTemplate.opsForZSet();//有序set操作

        每种操作都应对了的操作类，一般是Default开头，具体的源码还没有进行研究，本篇文章主要讲如何进行配置，更深的研究后续有时间会和小伙伴们进行分享。

        Redis的相关配置后，就可以编写Redis的相关的工具类，一般命名RedisUtils或者RedisDao，下面是代码：

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
import java.util.Date;
import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis工具类
 *
 * @create 2018-04-24 下午9:41
 **/
@Repository("redisDao")
public class RedisDaoImpl implements RedisDao{
    @Resource
    protected RedisTemplate<String,Object> redisTemplate;

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

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


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

    /**
     *字符串添加信息
     * @param key
     * @param obj 可以是单个的值，也可以是任意类型的对象
     * @param expire 设置失效时间
     * */
    @Override
    public void set(String key,Object obj,long expire){
        redisTemplate.opsForValue().set(key,obj,expire,TimeUnit.SECONDS);
    }

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

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

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


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

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

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

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

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

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

    @Override
    public Boolean expire(String key, long sec) {
        return redisTemplate.expire(key,sec,TimeUnit.SECONDS);
    }

    @Override
    public Boolean expireAt(String key, Date date) {
        return redisTemplate.expireAt(key,date);
    }
}

     以上只是写了redis的一些基本操作，如果需要操作List，或者Set的话，还需要在添加一些方法。在需要使用redis存储或者数据时，只需要注入RedisDao就可以了。通过以上的操作，就已经完成了Redis的基本配置，在一些配置上还可以进行优化，因为Spring对Redis进行了良好的封装，在一般场景下使用都可以满足我们的需求。