宜宾网站建设公司

springboot中RedisTemplate如何使用

这篇文章主要介绍了springboot中redisTemplate如何使用的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇springboot中RedisTemplate如何使用文章都会有所收获，下面我们一起来看看吧。

十多年的鄂尔多斯网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。全网整合营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整鄂尔多斯建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联公司从事“鄂尔多斯网站设计”,“鄂尔多斯网站推广”以来，每个客户项目都认真落实执行。

问题

Q:springboot中RedisTemplate的使用?

Q:RedisTemplate的是一定要配置么？不配置也能使用，配置RedisTemplate是为了我们能自定义其序列化方式么？不配置的话表示默认采用其默认的配置序列化方式？

Q:布隆过滤器是什么？有什么用？怎么使用？

大白话布隆过滤器

Q:我们在编写RedisConfig配置类时是否继承于CachingConfigurerSupport类有什么区别？为什么有的继承了有的不选择继承，是继承了的话可以结合Springboot的@EnableCaching的注解开启缓存么？以便使用如下注解自动开启缓存么？那在项目中是使用好还是不使用好？

开启缓存后注解使用参考：

注解缓存的使用
@Cacheable：在方法执行前Spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；没有则调用方法并将方法返回值放进缓存。
@CachePut：将方法的返回值放到缓存中。
@CacheEvict：删除缓存中的数据。

Q:Spring Boot中混合使用StringRedisTemplate和RedisTemplate的坑——存储到Redis的数据取不到值。

A:因为他同时使用了StringRedisTemplate和RedisTemplate在Redis中存储和读取数据。它们最重要的一个区别就是默认采用的序列化方式不同。StringRedisTemplate采用的是RedisSerializer.string()来序列化Redis中存储数据的Key ；RedisTemplate使用的序列化类为defaultSerializer，默认情况下为JdkSerializationRedisSerializer。如果未指定Key的序列化类，keySerializer与defaultSerializer采用相同的序列化类。

解决方法：需要指定统一的Key的序列化处理类，比如在RedisTemplate序列化时指定与StringRedisTemplate相同的类。

Q:Redis的brpop命令对应RedisTemplate中的什么方法？

Q:双向链表数据结构的了解？

Q:单元测试时@RunWith(SpringJUnit4ClassRunner.class)@SpringBootTest(classes = MyBootApplication.class)两个注解的作用？

A:如下。

1)@RunWith：用于指定junit运行环境，是junit提供给其他框架测试环境接口扩展，为了便于使用spring的依赖注入，spring提供了org.springframework.test.context.junit4.SpringJUnit4ClassRunner作为Junit测试环境。

2)@ContextConfiguration({"classes=Congfig.clsss",classpath:applicationContext.xml"}) 这里可以用classes来直接导入同包下写的配置类。或者导入配置文件。

3)@SpringBootTest替代了spring-test中的@ContextConfiguration注解，目的是加载ApplicationContext，启动spring容器。

springboot使用单元测试步骤：

1、引入依赖



    org.springframework.boot
    spring-boot-starter-test
    2.1.6.RELEASE
    test

2、编写测试类，注意加注解@RunWith(SpringJUnit4ClassRunner.class)@SpringBootTest(classes = MyBootApplication.class)，模板如下：

//用于指定junit运行环境，是junit提供给其他框架测试环境接口扩展，为了便于使用spring的依赖注入
@RunWith(SpringJUnit4ClassRunner.class)
//用于加载ApplicationContext，启动spring容器
@SpringBootTest(classes = MyBootApplication.class)
public class RedisTemplateTest {
    @Autowired
    private RedisTemplate redisTemplate;
	//因为spring自动注入管理了bean容器，直接用@Autowired取即可
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void testString(){
        //设置值
        stringRedisTemplate.opsForValue().set("String","Mao");
    }
}

Q:缓存并发问题，这里的并发指的是多个 Redis 的客户端同时 set 值引起的并发问题。比较有效的解决方案就是把 set 操作放在队列中使其串行化，必须得一个一个执行。我的疑问是，redis本身就是单线程串行执行的，怎么会有并发问题呢？

A:我们说的缓存并发指的是多个Redis客户端同时SET Key时会引起并发问题。我们知道，Redis是单线程的，在多个Client并发操作时，秉承“先发起先执行”的原则，其它的处于阻塞状态。

常见缓存并发有两种场景：

  • 缓存过期后会从后端数据库查询数据然后存入Redis缓存，但在高并发情况下可能在还没来得及将库中查出来的数据存入Redis时，其它Client又从数据库里查询数据再存入Redis了。这样一来会造成多个请求并发的从数据库获取数据，对后端数据库会造成压力。

  • 在高并发场景下，某个Key正在更新时，可能有很多Client在获取此Key的数据，这样会导致“脏数据”。

如何解决缓存并发问题呢？

1、加锁。我们常借助“锁”来实现，具体实现逻辑为：

在更新缓存或者读取过期缓存的情况下，我们先获取“锁”，当完成了缓存数据的更新后再释放锁，这样一来，其它的请求需要在释放锁之后执行，会牺牲一点时间。

2、异步队列串行执行。把 set 操作放在队列中使其串行化，必须得一个一个执行。如通过消息中间件异步执行。

3、使用类似SQL的乐观锁机制  。解决途径是在并发写入Redis缓存时，用要写入数据的版本号和时间戳 与 Redis中的数据进行对比，如果写入的数据时间戳或者版本号 比Redis 高，则写入Redis中；否则就不写入。

Redis 简介

Redis 是一个开源（BSD 许可）、内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合等数据类型。内置复制、Lua 脚本、LRU 收回、事务以及不同级别磁盘持久化功能，同时通过 Redis Sentinel 提供高可用，通过 Redis Cluster 提供自动分区。

Redis 使用场景

微服务以及分布式被广泛使用后，Redis 的使用场景就越来越多了，这里我罗列了主要的几种场景。

  1. 分布式缓存：在分布式的系统架构中，将缓存存储在内存中显然不当，因为缓存需要与其他机器共享，这时 Redis 便挺身而出了，缓存也是 Redis 使用最多的场景。

  2. 分布式锁：在高并发的情况下，我们需要一个锁来防止并发带来的脏数据，Java 自带的锁机制显然对进程间的并发并不好使，此时可以利用 Redis 单线程的特性来实现我们的分布式锁，如何实现，可以参考这篇文章。

  3. Session 存储/共享：Redis 可以将 Session 持久化到存储中，这样可以避免由于机器宕机而丢失用户会话信息。（个人认为更重要的是因为服务集群的出现，需要一个分布式Session来作为统一的会话）

  4. 发布/订阅：Redis 还有一个发布/订阅的功能，您可以设定对某一个 key 值进行消息发布及消息订阅，当一个 key 值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统。

  5. 任务队列：Redis 的 lpush+brpop 命令组合即可实现阻塞队列，生产者客户端使用 lrpush 从列表左侧插入元素，多个消费者客户端使用 brpop 命令阻塞式的”抢”列表尾部的元素，多个客户端保证了消费的负载均衡和高可用性。

  6. 限速，接口访问频率限制：比如发送短信验证码的接口，通常为了防止别人恶意频刷，会限制用户每分钟获取验证码的频率，例如一分钟不能超过 5 次。

当然 Redis 的使用场景并不仅仅只有这么多，还有很多未列出的场景，如计数、排行榜等。

Redis 数据类型

前面也提到过，Redis 支持字符串、哈希表、列表、集合、有序集合五种数据类型的存储。

字符串（string）

  • string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。

  • string类型是Redis最基本的数据类型，一个键最大能存储512MB。

string 这种数据结构应该是我们最为常用的。在 Redis 中 string 表示的是一个可变的字节数组，我们初始化字符串的内容、可以拿到字符串的长度，可以获取 string 的子串，可以覆盖 string 的子串内容，可以追加子串。

图 1. Redis 的 string 类型数据结构

如上图所示，在 Redis 中我们初始化一个字符串时，会采用预分配冗余空间的方式来减少内存的频繁分配，如图 1 所示，实际分配的空间 capacity 一般要高于实际字符串长度 len。如果您看过 Java 的 ArrayList 的源码相信会对此种模式很熟悉。

列表（list）

  • redis列表是简单的字符串列表，排序为插入的顺序。列表的最大长度为2^32-1。

  • redis的列表是使用链表实现的，这意味着，即使列表中有上百万个元素，增加一个元素到列表的头部或尾部的操作都是在常量的时间完成。

  • 可以用列表获取最新的内容（像帖子，微博等），用ltrim很容易就会获取最新的内容，并移除旧的内容。

  • 用列表可以实现生产者消费者模式，生产者调用lpush添加项到列表中，消费者调用rpop从列表中提取，如果没有元素，则轮询去获取，或者使用brpop等待生产者添加项到列表中。

在 Redis 中列表 list 采用的存储结构是双向链表，由此可见其随机定位性能较差，比较适合首位插入删除。像 Java 中的数组一样，Redis 中的列表支持通过下标访问，不同的是 Redis 还为列表提供了一种负下标，-1 表示倒数一个元素，-2 表示倒数第二个数，依此类推。综合列表首尾增删性能优异的特点，通常我们使用 rpush/rpop/lpush/lpop 四条指令将列表作为队列来使用。

图 2. List 类型数据结构

如上图所示，在列表元素较少的情况下会使用一块连续的内存存储，这个结构是 ziplist，也即是压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。当数据量比较多的时候才会改成 quicklist。因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是 int 类型的数据，结构上还需要两个额外的指针 prev 和 next。所以 Redis 将链表和 ziplist 结合起来组成了 quicklist。也就是将多个 ziplist 使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余。

哈希表（hash）

  • redis的哈希值是字符串字段和字符串之间的映射，是表示对象的完美数据类型。

  • 哈希中的字段数量没有限制，所以可以在你的应用程序以不同的方式来使用哈希。

hash 与 Java 中的 HashMap 差不多，实现上采用二维结构，第一维是数组，第二维是链表。hash 的 key 与 value 都存储在链表中，而数组中存储的则是各个链表的表头。在检索时，首先计算 key 的 hashcode，然后通过 hashcode 定位到链表的表头，再遍历链表得到 value 值。可能您比较好奇为啥要用链表来存储 key 和 value，直接用 key 和 value 一对一存储不就可以了吗？其实是因为有些时候我们无法保证 hashcode 值的唯一，若两个不同的 key 产生了相同的 hashcode，我们需要一个链表在存储两对键值对，这就是所谓的 hash 碰撞。

集合（set）

  • redis集合是无序的字符串集合，集合中的值是唯一的，无序的。可以对集合执行很多操作，例如，测试元素是否存在，对多个集合执行交集、并集和差集等等。

  • 我们通常可以用集合存储一些无关顺序的，表达对象间关系的数据，例如用户的角色，可以用sismember很容易就判断用户是否拥有某个角色。

  • 在一些用到随机值的场合是非常适合的，可以用 srandmember/spop 获取/弹出一个随机元素。
    同时，使用@EnableCaching开启声明式缓存支持，这样就可以使用基于注解的缓存技术。注解缓存是一个对缓存使用的抽象，通过在代码中添加下面的一些注解，达到缓存的效果。

    • @Cacheable：在方法执行前Spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；没有则调用方法并将方法返回值放进缓存。

    • @CachePut：将方法的返回值放到缓存中。

    • @CacheEvict：删除缓存中的数据。

熟悉 Java 的同学应该知道 HashSet 的内部实现使用的是 HashMap，只不过所有的 value 都指向同一个对象。Redis 的 Set 结构也是一样，它的内部也使用 Hash 结构，所有的 value 都指向同一个内部值。

有序集合（sorted set）

  • 有序集合由唯一的，不重复的字符串元素组成。有序集合中的每个元素都关联了一个浮点值，称为分数。可以把有序看成hash和集合的混合体，分数即为hash的key。

  • 有序集合中的元素是按序存储的，不是请求时才排序的。

有时也被称作 ZSet，是 Redis 中一个比较特别的数据结构，在有序集合中我们会给每个元素赋予一个权重，其内部元素会按照权重进行排序，我们可以通过命令查询某个范围权重内的元素，这个特性在我们做一个排行榜的功能时可以说非常实用了。其底层的实现使用了两个数据结构， hash 和跳跃列表，hash 的作用就是关联元素 value 和权重 score，保障元素 value 的唯一性，可以通过元素 value 找到相应的 score 值。跳跃列表的目的在于给元素 value 排序，根据 score 的范围获取元素列表。

在 Spring Boot 项目中使用 Redis

spring-data-redis针对jedis提供了如下功能：

1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类

2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

ValueOperations：简单K-V操作
SetOperations：set类型数据操作
ZSetOperations：zset类型数据操作
HashOperations：针对map类型的数据操作
ListOperations：针对list类型的数据操作

3. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：

BoundValueOperations
BoundSetOperations
BoundListOperations
BoundSetOperations
BoundHashOperations

4. 将事务操作封装，有容器控制。

5. 针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)

JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前最常用的序列化策略。

StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。

JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】

OxmSerializer：提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml工具。不过使用此策略，编程将会有些难度，而且效率最低；不建议使用。【需要spring-oxm模块的支持】

如果你的数据需要被第三方工具解析，那么数据应该使用StringRedisSerializer而不是JdkSerializationRedisSerializer。

如果使用的是默认的JdkSerializationRedisSerializer，注意一定要让缓存的对象实现序列化接口用于序列化 。

关于key的设计

key的存活时间：

无论什么时候，只要有可能就利用key超时的优势。

关系型数据库的redis

1: 把表名转换为key前缀 如, tag:

2: 第2段放置用于区分区key的字段–对应MySQL中的主键的列名,如userid

3: 第3段放置主键值,如2,3,4…., a , b ,c

4: 第4段,写要存储的列名

例：user:userid:9:username

使用前配置

添加 Redis 依赖



    org.springframework.boot
    spring-boot-starter-data-redis




    org.springframework.boot
    spring-boot-starter-test
    2.1.6.RELEASE
    test

Spring Boot 中配置 Redis： application.properties

spring.redis.host=127.0.0.1
spring.redis.port=6379
# Redis 数据库索引（默认为 0）
spring.redis.database=0 
# Redis 服务器连接端口
# Redis 服务器连接密码（默认为空）
spring.redis.password=123456
#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒） 如果连接超时时间不设置，这要注释掉配置而不能=0，否则会报连接超时错误：Command timed out after no timeout,，有超时时间最后设置为200以上
spring.redis.timeout=300

RedisTemplate 的配置

@Configuration
public class RedisConfig {

    /**
     * 默认是JDK的序列化策略，这里配置redisTemplate采用的是Jackson2JsonRedisSerializer的序列化策略
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会抛出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        RedisTemplate redisTemplate = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        //redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        // 值采用json序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /***
     * stringRedisTemplate默认采用的是String的序列化策略
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory){
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(redisConnectionFactory);
        return stringRedisTemplate;
    }
}
RedisTemplate
Spring Boot 的 spring-boot-starter-data-redis 为 Redis 的相关操作提供了一个高度封装的 RedisTemplate 类，而且对每种类型的数据结构都进行了归类，将同一类型操作封装为 operation 接口。RedisTemplate 对五种数据结构分别定义了操作，如下所示：
  • 操作字符串：redisTemplate.opsForValue()
  • 操作 Hash：redisTemplate.opsForHash()
  • 操作 List：redisTemplate.opsForList()
  • 操作 Set：redisTemplate.opsForSet()
  • 操作 ZSet：redisTemplate.opsForZSet()
但是对于 string 类型的数据，Spring Boot 还专门提供了 StringRedisTemplate 类，而且官方也建议使用该类来操作 String 类型的数据。那么它和 RedisTemplate 又有啥区别呢？
  1. RedisTemplate 是一个泛型类，而 StringRedisTemplate 不是，后者只能对键和值都为 String 类型的数据进行操作，而前者则可以操作任何类型。
  2. 两者的数据是不共通的，StringRedisTemplate 只能管理 StringRedisTemplate 里面的数据，RedisTemplate 只能管理 RedisTemplate 中 的数据。
实践
//用于指定junit运行环境，是junit提供给其他框架测试环境接口扩展，为了便于使用spring的依赖注入
@RunWith(SpringJUnit4ClassRunner.class)
//用于加载ApplicationContext，启动spring容器
@SpringBootTest(classes = MyBootApplication.class)
public class RedisTemplateTest {

    @Autowired
    private RedisTemplate redisTemplate;
    //因为spring自动注入管理了bean容器，直接用@Autowired取即可
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 操作字符串
     */
    @Test
    public void testString() {
        //设置值
        stringRedisTemplate.opsForValue().set("String", "Mao");
        //获取值
        String string = stringRedisTemplate.opsForValue().get("String");

        //设置值且设置超时时间
        stringRedisTemplate.opsForValue().set("Middle", "Yu", 3, TimeUnit.MINUTES);
        String middle = stringRedisTemplate.opsForValue().get("Middle");
        System.out.println(middle);

        //删除数据
        Boolean isDelete = stringRedisTemplate.delete("String");
        System.out.println(isDelete ? "Yes" : "No");
    }

    /**
     * 操作列表
     */
    @Test
    public void testList() {
        ListOperations listOp = redisTemplate.opsForList();
        //往 List 左侧插入一个元素
        listOp.leftPush("namelist", "mike");
        listOp.leftPush("namelist", "kim");
        //往 List 右侧插入一个元素
        listOp.rightPush("namelist", "jimmy");
        listOp.rightPush("namelist", "chuck");
        //List 大小
        Long size = listOp.size("namelist");
        //遍历整个List
        List namelist1 = listOp.range("namelist", 0, size);
        //遍历整个List，-1表示倒数第一个即最后一个
        List namelist = listOp.range("namelist", 0, -1);
        System.out.println(JSON.toJSONString(namelist));
        //从 List 左侧取出第一个元素，并移除
        Object name1 = listOp.leftPop("namelist", 200, TimeUnit.MILLISECONDS);
        System.out.println("is kim:" + name1.equals("kim"));
        //从 List 右侧取出第一个元素，并移除
        Object name2 = listOp.rightPop("namelist");
        System.out.println("is chuck:" + name2.equals("chuck"));
    }

    /**
     * 操作 Hash
     */
    @Test
    public void testHash() {
        //添加泛型方便操作和返回想要的具体类型
        HashOperations hashOp = redisTemplate.opsForHash();
        //Hash 中新增元素。
        hashOp.put("score", "Mike", 10);
        hashOp.put("score", "Jimmy", 9);
        hashOp.put("score", "Kim", 8);
        //判断指定 key 对应的 Hash 中是否存在指定的 map 键
        Assert.assertTrue(hashOp.hasKey("score", "Kim"));
        //获取指定 key 对应的 Hash 中指定键的值
        Integer kim = hashOp.get("score", "Kim");
        System.out.println("kim score:" + kim);
        //获取hash表所有的key集合
        Set name = hashOp.keys("score");
        System.out.println(JSON.toJSONString(name));
        //获取hash表所有的values集合
        List score = hashOp.values("score");
        System.out.println(JSON.toJSONString(score));
        //获取"score"对应的hash表Map
        Map map = hashOp.entries("score");
        System.out.println(JSON.toJSONString(map));
        //删除指定 key 对应 Hash 中指定键的键值对
        hashOp.delete("score", "Mike");
        //如果要删除整个hash表，要用redisTemplate.delete("score")方法,否则报错：Fields must not be empty
        //hashOp.delete("score");
        //删除整个hash表
        redisTemplate.delete("score");
        Map map1 = hashOp.entries("score");
        System.out.println(JSON.toJSONString(map1));
    }

    /**
     * 操作集合
     */
    @Test
    public void testSet() {
        SetOperations setOp = redisTemplate.opsForSet();
        //向集合中添加元素,set元素具有唯一性
        setOp.add("city", "quanzhou", "newyork", "paris", "hongkong", "hongkong");
        Long size = setOp.size("city");
        System.out.println("city size:" + size);
        //获取集合中的元素
        Set city = setOp.members("city");
        System.out.println(JSON.toJSONString(city));
        //移除集合中的元素,可以一个或多个
        setOp.remove("city", "paris");
        //判断是否是集合中的元素
        Boolean isMember = setOp.isMember("city", "paris");
        System.out.println("paris is in city:" + isMember);
        //移除并返回集合中的一个随机元素
        String city1 = setOp.pop("city");
        System.out.println(city1);
    }

    /**
     * 操作有序集合
     */
    @Test
    public void testZSet() {
        ZSetOperations zSetOp = redisTemplate.opsForZSet();
        zSetOp.add("zcity", "beijing", 100);
        zSetOp.add("zcity", "shanghai", 95);
        zSetOp.add("zcity", "guangzhou", 75);
        zSetOp.add("zcity", "shenzhen", 85);
        //获取变量指定区间的元素。0, -1表示全部
        Set zcity = zSetOp.range("zcity", 0, -1);
        System.out.println(JSON.toJSONString(zcity));
        //通过分数返回有序集合指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
        Set byScore = zSetOp.rangeByScore("zcity", 85, 100);
        System.out.println(JSON.toJSONString(byScore));
        //获取有序集合的成员数
        Long aLong = zSetOp.zCard("zcity");
        System.out.println("zcity size: " + aLong);

        ZSetOperations zSetOp1 = redisTemplate.opsForZSet();
        zSetOp1.add("board", 1, 100);
        zSetOp1.add("board", 2, 100);
        zSetOp1.add("board", 3, 100);
        zSetOp1.add("board", 4, 100);
        Set board = zSetOp1.range("board", 0, -1);
        System.out.println(JSON.toJSONString(board));
        RedisZSetCommands.Range range = new RedisZSetCommands.Range();
        //less than
        range.lt("3");
        RedisZSetCommands.Limit limit = new RedisZSetCommands.Limit();
        limit.count(1);
        limit.offset(1);
        //用于获取满足非 score 的排序取值。这个排序只有在有相同分数的情况下才能使用，如果有不同的分数则返回值不确定。
        //rangeByLex应用在数值上比较
        Set set = zSetOp1.rangeByLex("board", range);
        System.out.println(JSON.toJSONString(set));
        //用于获取满足非 score 的设置下标开始的长度排序取值。
        Set setlmt = zSetOp1.rangeByLex("board", range, limit);
        System.out.println(JSON.toJSONString(setlmt));
    }

    /**
     * 分布式锁
     */
    @Test
    public void testLock() {
        String value = UUID.randomUUID().toString();
        Boolean lock = lock("buy", value,120L, TimeUnit.SECONDS);
        if (!lock) {
            System.out.println("can't lock buy");
        }
        try {
            Thread.sleep(6);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Boolean unLock = unLock("buy",value);
        if (!unLock) {
            System.out.println("can't unlock buy");
        }
    }

    public Boolean lock(String key,String value, Long timeout, TimeUnit timeUnit) {
        Boolean lockStat = stringRedisTemplate.execute((RedisCallback) connection ->
                connection.set(key.getBytes(Charset.forName("UTF-8")), value.getBytes(Charset.forName("UTF-8")),
                        Expiration.from(timeout, timeUnit), RedisStringCommands.SetOption.SET_IF_ABSENT));
        return lockStat;
    }

    public Boolean unLock(String key,String value) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        boolean unLockStat = stringRedisTemplate.execute((RedisCallback) connection ->
                connection.eval(script.getBytes(), ReturnType.BOOLEAN, 1,
                        key.getBytes(Charset.forName("UTF-8")), value.getBytes(Charset.forName("UTF-8"))));
        return unLockStat;
    }
    
    @Test
    public void boundTest(){
        BoundListOperations bound = redisTemplate.boundListOps("bound");
        bound.leftPush("haha");
        bound.rightPush("hehe");
        List list = bound.range(0, -1);
        System.out.println(JSON.toJSONString(list));
    }
}
报错1：
Caused by: io.lettuce.core.RedisCommandExecutionException: ERR Client sent AUTH, but no password is set
	at io.lettuce.core.ExceptionFactory.createExecutionException(ExceptionFactory.java:135)
	
A:这是因为服务器没有设置密码，客户端设置了密码去连接，导致连接失败。我们在启动服务器时通过命令(config set requirepass "123456")手动设置了密码,一旦Redis服务器关闭后，重新启动加载了Redis启动的配置，因为启动配置菜单（redis-server.exe redis.windows.conf）中没有配置密码，所以重新启动的redis是没有设置密码的，这样就会报错。
解决方法：如果要设置密码则要在Redis启动的配置文件中修改添加；或者如果不设置密码则客户端连接时application.properties不要设置密码连接
# Redis 服务器连接密码（默认为空）
#spring.redis.password=123456
报错2：
org.springframework.dao.QueryTimeoutException: Redis command timed out; nested exception is io.lettuce.core.RedisCommandTimeoutException: Command timed out after no timeout at org.springframework.data.redis.connection.lettuce.LettuceExceptionConverter.convert(LettuceExceptionConverter.java:70)
A:这是因为客户端连接时application.properties中设置了连接超时时间为0导致的.
解决方法：
# 连接超时时间（毫秒） 如果连接超时时间不设置，这要注释掉配置而不能=0，否则会报连接超时错误：Command timed out after no timeout，有超时时间最后设置为200以上
spring.redis.timeout=300



org.springframework.data.redis.RedisSystemException: Unknown redis exception; nested exception is java.lang.IllegalArgumentException: Fields must not be empty at org.springframework.data.redis.FallbackExceptionTranslationStrategy.getFallback(FallbackExceptionTranslationStrategy.java:53)

A:如果要删除整个hash表，要用redisTemplate.delete("score")方法,否则报错：Fields must not be empty
解决方法：使用redisTemplate方法，HashOperations的delete是用于删除hash表字段用
		HashOperations hashOp = redisTemplate.opsForHash();
        //hashOp.delete("score");
        redisTemplate.delete("score");
关于 Redis 的几个经典问题
缓存与数据库一致性问题
对于既有数据库操作又有缓存操作的接口，一般分为两种执行顺序。
  1. 先操作数据库，再操作缓存。这种情况下如果数据库操作成功，缓存操作失败就会导致缓存和数据库不一致。
  2. 第二种情况就是先操作缓存再操作数据库，这种情况下如果缓存操作成功，数据库操作失败也会导致数据库和缓存不一致。
大部分情况下，我们的缓存理论上都是需要可以从数据库恢复出来的，所以基本上采取第一种顺序都是不会有问题的。针对那些必须保证数据库和缓存一致的情况，通常是不建议使用缓存的。
缓存击穿问题
缓存击穿表示恶意用户频繁的模拟请求缓存中不存在的数据，以致这些请求短时间内直接落在了数据库上，导致数据库性能急剧下降，最终影响服务整体的性能。这个在实际项目很容易遇到，如抢购活动、秒杀活动的接口 API 被大量的恶意用户刷，导致短时间内数据库宕机。对于缓存击穿的问题，有以下几种解决方案，这里只做简要说明。
  1. 使用互斥锁排队。当从缓存中获取数据失败时，给当前接口加上锁，从数据库中加载完数据并写入后再释放锁。若其它线程获取锁失败，则等待一段时间后重试。(数据库取数据时加锁)
  2. 使用布隆过滤器。将所有可能存在的数据缓存放到布隆过滤器中，当黑客访问不存在的缓存时迅速返回避免缓存及 DB 挂掉。
缓存雪崩问题
在短时间内有大量缓存失效，如果这期间有大量的请求发生同样也有可能导致数据库发生宕机。在 Redis 机群的数据分布算法上如果使用的是传统的 hash 取模算法，在增加或者移除 Redis 节点的时候就会出现大量的缓存临时失效的情形。
  1. 像解决缓存穿透一样加锁排队。
  2. 建立备份缓存，缓存 A 和缓存 B，A 设置超时时间，B 不设值超时时间，先从 A 读缓存，A 没有读 B，并且更新 A 缓存和 B 缓存。
  3. 计算数据缓存节点的时候采用一致性 hash 算法，这样在节点数量发生改变时不会存在大量的缓存数据需要迁移的情况发生。
缓存并发问题
这里的并发指的是多个 Redis 的客户端同时 set 值引起的并发问题。比较有效的解决方案就是把 set 操作放在队列中使其串行化，必须得一个一个执行。
描述
brpop : block right pop 
BRPOP key1 [key2 ] timeout 
移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
关于“springboot中RedisTemplate如何使用”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“springboot中RedisTemplate如何使用”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注创新互联行业资讯频道。
            
            
                            

                网页题目：springboot中RedisTemplate如何使用                

                路径分享：http://ybzwz.com/article/gsdpdg.html
            
        
        

            
其他资讯