SpringBoot整合Redis

SpringBoot整合Redis

Maven依赖

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

这里用的是2.2.0版本

Redis的一些配置参数

spring:
  #redis配置信息
  redis:
    #redis 服务器地址
    host: 127.0.0.1
    #redis端口
    port: 6379
    #redis 密码（没有设置可以不配）
    password: 
    #客户端超时时间单位是毫秒 默认是2000
    timeout: 2000
    #最大空闲数
    maxIdle: 20
    #连接池的最大数据库连接数
    maxActive: -1
    #控制一个pool可分配多少个jedis实例,用来替换上面的maxActive
    maxTotal: 100
    #最大建立连接等待时间。如果超过此时间将接到异常
    maxWaitMillis: 100
    #连接的最小空闲时间
    minEvictableIdleTimeMillis: 864000000
    #每次释放连接的最大数目
    numTestsPerEvictionRun: 10
    #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程
    timeBetweenEvictionRunsMillis: 300000
    #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
    testOnBorrow: true
    #在空闲时检查有效性
    testWhileIdle: false
    #初始选择哪个数据库
    database: 0

这里用的是YAML格式的

源码分析

使用之前让我们对redis的源码有个认识，以便后面内容理解

打开Redis源码中的RedisAutoConfiguration类

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

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

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

在这里面有两个RedisTemplate对象（后面我们可以通过注入的方式去使用）

1. 它们两个有什么区别嘞？

   RedisTemplate<Object, Object>是默认使用的，它主要操作的是存储对象类型，和其他操作

   StringRedisTemplate主要用来操作String类型的

   本质上没有太大的区别

2. 我们发现在RedisTemplate模板类上面有着这个注解

   @ConditionalOnMissingBean(
       name = {"redisTemplate"}
   )
   

   这说明我们可以自定义RedisTemplate模板，我们后面会说

在RedisAutoConfiguration这个装配类上面我们还要关注一个东西

@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})

这里默认Redis导入了两种获取连接的配置

但是官方推荐默认让我们使用第一种也就是LettuceConnectionConfiguration

• 为什么?
  我们点进两种连接配置类的源码里面，发现JedisConnectionConfiguration中的许多类并不存在

  我们回过头看redis的依赖，发现只给我们导入了lettuce的依赖

  <dependency>
        <groupId>io.lettuce</groupId>
        <artifactId>lettuce-core</artifactId>
        <version>5.2.0.RELEASE</version>
        <scope>compile</scope>
      </dependency>
  

• 它们有什么区别?
  Lettuce：它采用Netty方式，一个实例可以在多个线程中共享，不存在线程不安全的情况，好比NIO模式

  Jedis ：它采用直连方式，多个线程操作的情况下是不安全的，不过可以使用Jedis Pool连接池技术解决，好比BIO模式

测试使用

Redis数据库的操作测试

@SpringBootTest
class SpringbootReidsApplicationTests {
 	@Autowired
    private RedisTemplate redisTemplate;
    /**
    *也可以使用这个
	@Autowired
    private StringRedisTemplate stringRedisTemplate;
    */
    
    @Test
    void redisTemplateTest(){
        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        connection.flushDb();//清空当前数据库中的数据
        connection.flushAll();//清空所有数据库中的数据
        connection.dbSize();//获取当前数据库存入数据的多少
        connection.select(0);//选择数据库
        connection.close();//关闭连接
    }
}

如何操作我们的Redis数据类型

		redisTemplate.opsForValue()[String（字符串）]
	 	redisTemplate.opsForList()[List（列表）]
	 	redisTemplate.opsForSet()[Set（集合）]
		redisTemplate.opsForHash()[Hash（散列）]
	 	redisTemplate.opsForZSet()[ZSet（有序集合）]
	 	redisTemplate.opsForHyperLogLog();[Geospatial（位置存储）]
        redisTemplate.opsForGeo();[HyperLogLog（基数统计）]

演示存储字符串

@Test
void TestString(){
    //存入
    redisTemplate.opsForValue().set("name","zhangsan");
    //读取
    System.out.println(redisTemplate.opsForValue().get("name"));
}

我们看控制台

我们再看redis的客户端

问题：

• 存入的key为什么没有取到

• 客户端获取的key为什么不是name

这是因为在RedisTemplate中存储key-value默认的是JdkSerializationRedisSerializer进行的序列化操作，而我们所需要的应该是JsonRedisSerializer序列化对象

---

所以我们需要自定义RedisTemplate

编写配置类

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory 
                           redisConnectionFactory) throws UnknownHostException {
        
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);

        //自定义序列化操作-Json的序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new 
            				Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper=new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, 
                                   	JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, 
                                           ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        //自定义序列化操作-String的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        //设置序列化方式
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;
    }
}

这时我们再测试


[搞定收工]

演示存储对象

我们先创建实体类

public class User {
    private String name;
    private Integer age;
    private String sex;
    
	/**
	*此处方法省略
	*/
}

测试

@Test
void TestObject(){
     //存入对象
     redisTemplate.opsForValue().set("user",new User("zhangsan",20,"男"));
     //获取存入的key
     Set keys = redisTemplate.keys("*");
     System.out.println(keys);
     //取值
     System.out.println(redisTemplate.opsForValue().get("user"));

 }

如果我们没有刚才自定义的RedisTemplate我们运行发现

这是因为我们的实体类没有进行序列化，实体类需要实现 Serializable

---

如果我们用了刚才自定义的配置（一切正常）

其他的基本操作就和Redis命令一样，这些都是一通百通的，这里就不进行测试了

分享一下操作Redis的工具类

下面是根据源码封装的一些常用方法，便于使用

public class RedisUtils {
    /**
     * 日志对象
     */
    private static Logger logger = LoggerFactory.getLogger(RedisUtils.class);

    /**
     * 注入RedisTemplate 对象
     */
    @autowired
    private static RedisTemplate redisTemplate;
    
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public static boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils expire(String key,long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public static long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public static boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            logger.error("RedisUtils hasKey(String key) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public static void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public static Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public static boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils set(String key,Object value) failure."+e.getMessage());
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public static boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils set(String key,Object value,long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param  delta
     * @return
     */
    public static long incr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减少几(小于0)
     * @return
     */
    public static long decr(String key, long delta){
        if(delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public static Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public static Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public static boolean hmset(String key, Map<String,Object> map){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils hmset(String key, Map<String,Object> map) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public static boolean hmset(String key, Map<String,Object> map, long time){
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils hmset(String key, Map<String,Object> map, long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public static boolean hset(String key,String item,Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils hset(String key,String item,Object value) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public static boolean hset(String key,String item,Object value,long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils hset(String key,String item,Object value,long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public static void hdel(String key, Object... item){
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public static boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public static double hincr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public static double hdecr(String key, String item,double by){
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public static Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            logger.error("RedisUtils sGet(String key) failure."+e.getMessage());
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public static boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            logger.error("RedisUtils sHasKey(String key,Object value) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            logger.error("RedisUtils sSet(String key, Object...values) failure."+e.getMessage());
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public static  long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) {
                expire(key, time);
            }
            return count;
        } catch (Exception e) {
            logger.error("RedisUtils sSetAndTime(String key,long time,Object...values) failure."+e.getMessage());
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public static  long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            logger.error("RedisUtils sGetSetSize(String key) failure."+e.getMessage());
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public static  long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            logger.error("RedisUtils setRemove(String key, Object ...values) failure."+e.getMessage());
            return 0;
        }
    }

    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    public static  List<Object> lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            logger.error("RedisUtils lGet(String key, long start, long end) failure."+e.getMessage());
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public static  long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            logger.error("RedisUtils lGetListSize(String key) failure."+e.getMessage());
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public static  Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            logger.error("RedisUtils lGetIndex(String key,long index) failure."+e.getMessage());
            return null;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public static  boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils lSet(String key, Object value) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public static  boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils lSet(String key, Object value, long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public static  boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils lSet(String key, List<Object> value) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public static  boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils lSet(String key, List<Object> value, long time) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public static  boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            logger.error("RedisUtils lUpdateIndex(String key, long index,Object value) failure."+e.getMessage());
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public static long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            logger.error("RedisUtils lRemove(String key,long count,Object value) failure."+e.getMessage());
            return 0;
        }
    }



}

[注]：这是基本的操作，还有一些不常用的api方法大家可以尝试着自行封装使用

---

工具分享

最后给大家分享一个Redis的GUI客户端工具（redis-desktop-manager）。官网下载话的可能比较慢

链接：https://pan.baidu.com/s/1r-en0XcvpuE5XNyTfprm6g
提取码：zwpn