redis（redis面试题）

　　本篇文章为你整理了redis（redis面试题）的详细内容，包含有redis 缓存穿透,击穿,雪崩 redis面试题 redis是干嘛的 redis持久化方式有几种 redis，希望能帮助你了解 redis。

　　 Redis是大规模互联网应用常用的内存高速缓存数据库，它的读写速度非常快，据官方 Bench-mark的数据，它读的速度能到11万次/秒，写的速度是8.1万次/秒。

　　1. 认识Spring Cache

　　在很多应用场景中通常是获取前后相同或更新不频繁的数据，比如访问产品信息数据、网页数据。如果没有使用缓存，则访问每次需要重复请求数据库，这会导致大部分时间都耗费在数据库查询和方法调用上，因为数据库进行I/O操作非常耗费时间，这时就可以利用Spring Cache来解决。

　　 Spring Cache是Spring提供的一整套缓存解决方案。它本身并不提供缓存实现，而是提供统一的接口和代码规范、配置、注解等，以便整合各种Cache方案，使用户不用关心Cache的细节。

　　 Spring支持“透明”地向应用程序添加缓存，将缓存应用于方法，在方法执行前检查缓存中是否有可用的数据。这样可以减少方法执行的次数，同时提高响应的速度。缓存的应用方式“透明”，不会对调用者造成任何干扰。只要通过注解@EnableCaching启用了缓存支持，Spring Boot就会自动处理好缓存的基础配置。

　　 Spring Cache作用在方法上。当调用一个缓存方法时，会把该方法参数和返回结果作为一个 “键值对”(key/value )存放在缓存中，下次用同样的参数来调用该方法时将不再执行该方法，而是直接从缓存中获取结果进行返回。所以在使用Spring Cache 时,要保证在缓存的方法和方法参数相同时返回相同的结果。

　　 1.1 声明式缓存注解

　　 Spring Boot提供的声明式缓存(cache)注解，见表11-1。

　　图 11-1

　　 1.@EnableCaching

　　标注在入口类上，用于开启缓存。

　　 2.@Cacheable

　　可以作用在类和方法上，以键值对的方式缓存类或方法的返回值。键可以有默认策略和自定义策略。

　　 @Cacheable注解会先查询是否己经有缓存，如果己有则会使用缓存，如果没有则会执行方法并进行缓存。

　　 @Cacheabfe 可以指定 3 个属性----- value、key 和 condition。

　　
value :缓存的名称，在Spring配置文件中定义，必须指定至少一个。如， @Cacheable(value= "cache1" )、@Cacheable(value={ "cache1" , "cache2n }。

　　key：缓存的key可以为空，如果自定义key,则要按照SpEL表达式编写。可以自动按照方法的参数组合。如，@Cacheable(value= "cache1"，key= "#id” )

　　condition：缓存的条件可以为空，如果自定义condition，则使用SpEL表达式辐写，以返回true或false值，只有返回true才进行缓存。如，@Cacheable(value= “cache1" ,condition= "#id.length() 2" )。

　　
@Cacheable(value = "emp",key = "targetClass + methodName + #p0")

　　public List Card getCardList() {

　　 return cardRepository.findAll();

　　}

　　代码解释如下。

　　value是必需的，它指定了缓存存放的位置。

　　key使用的是SpEL表达式。

　　User实体类一定要实现序列化，否则会报“java.io.NotSerializableException”异常。序列化可以继承 Serializable,如 public class User implements Serializable。

　　 3.@CachePut

　　 @CachePut标注的方法在执行前不检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。和@Cacheable不同的是， @CachePut每次都会触发真实方法的调用，比如用户更新缓存数据。

　　需要注意的是，该注解的value和key必须与要更新的缓存相同，即与@Cacheable 相同。具体见下面两段代码：

@Override

　　@CachePut(value = "usr",key = "targetClass + #p0")

　　public Book update(Book book) {

　　 return null;

　　@Override

　　@Cacheable(value = "usr",key = "targetClass + #p0")

　　public Book save(Book book) {

　　 return null;

　　}

　　 4.@CacheEvict

　　 @CacheEvict用来标注需要清除缓存元素的方法或类。该注解用于触发缓存的清除操作。其属性有value、key、condition、allEntries 和 beforeInvocation。可以用这些属性来指定清除的条件。使用方法如下：

@Override

　　@Cacheable(value = "usr",key = "#p0.id")

　　public Book save(Book book) {

　　 return null;

　　@Override

　　@CacheEvict(value = "usr",key = "#id")

　　public void delete(int id) {

　　@Override

　　@CacheEvict(value = "accountCache",allEntries = true)

　　public void deleteAll() {

　　@Override

　　@CacheEvict(value = "accountCache",beforeInvocation = true)

　　public void deleteAll() {

　　}

　　 5. @Caching

　　注解@Caching用来组合多个注解标签，有3个属性：cacheable、put 和 evict,用于指定 @Cacheable、@CachePut 和 @CacheEvict。使用方法如下：

@Override

　　@Caching(cacheable = {@Cacheable(value = "usr",key = "#p0"),},

　　 put = {@CachePut(value = "usr",key = "#p0"),},

　　 evict = {@CacheEvict(value = "usr",key = "#p0"),})

　　public Book save(Book book) {

　　 return null;

　　}

　　 1.2 实例：用Spring Cache进行缓存管理

　　本实例展示Spring Cache是如何使用简单缓存(SIMPLE方式)进行缓存管理的。

　　（1）添加依赖

 dependency

　　 groupId org.springframework.boot /groupId

　　 artifactId spring-boot-starter-cache /artifactId

　　 version 2.7.2 /version

　　 /dependency

　　（2）配置缓存管理器

　　在application.yml文件中配置目标缓存管理器，支持Ehcache、Generic、Redis、 Jcache 等。这里使用 SIMPLE 方式 "spring: cache: type: SIMPLE”。

　　（3）开启缓存功能

　　在入口类添加注解@EnableCaching,开启缓存功能。

　　（4）在服务实现里编写缓存业务逻辑：

@Service

　　public class BookServiceImpl implements BookService{

　　 @Autowired

　　 private BookDao bookDao;

　　 @Override

　　 public Book getById(Integer id) {

　　 return bookDao.getById(id);

　　 @Override

　　 public void insert(Book book) {

　　 bookDao.insert(book);

　　 @Override

　　 @CachePut(value = "usr",key = "targetClass + #p0")

　　 public Book update(Book book) {

　　 return null;

　　 @Override

　　 @Caching(cacheable = {@Cacheable(value = "usr",key = "#p0"),},

　　 put = {@CachePut(value = "usr",key = "#p0"),},

　　 evict = {@CacheEvict(value = "usr",key = "#p0"),})

　　 public Book save(Book book) {

　　 return null;

　　 @Override

　　 @CacheEvict(value = "usr",key = "#id")

　　 public void delete(int id) {

　　 @Override

　　 @CacheEvict(value = "accountCache",allEntries = true)

　　 public void deleteAll() {

　　}

　　上述代码可以看出，查找用户的方法使用了注解@Cacheable来开启缓存。修改和添加方法使用了注解@CachePut。它是先处理方法，然后把结果进行缓存的。要想删除数据，则需要使用注解@CacheEvict来清空缓存。

　　（5）控制器里调用缓存服务

@EnableCaching

　　@Controller

　　public class BookController {

　　 @Autowired

　　 private BookService bookService;

　　 int id = 0;

　　 @RequestMapping("/book")

　　 public String insert(){

　　 Book book = new Book();

　　 book.setUsername("拉行啊");

　　 book.setPassword("123");

　　 String jsonObject = JSON.toJSONString(book);

　　 System.out.println(jsonObject);

　　 book.setJson(jsonObject);

　　 bookService.insert(book);

　　 id = book.getId();

　　 return book.toString();

　　 @RequestMapping(value = "/get",method = RequestMethod.GET,produces = "application/json")

　　 public Book get(){

　　 Book book = new Book();

　　 book.setUsername("拉行啊");

　　 book.setPassword("123");

　　 return book;

　　 @RequestMapping(value = "/put")

　　 public String put(@RequestParam("upload")MultipartFile file, RedirectAttributes redirectAttributes){

　　 Date date = new Date();

　　 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");

　　 String nyr = dateFormat.format(date);

　　 if (file.getOriginalFilename().endsWith(".jpg")file.getOriginalFilename().endsWith(".png")

　　 file.getOriginalFilename().endsWith(".git")){

　　 try {

　　 byte[] bytes = file.getBytes();

　　 String s = nyr+Math.random()+file.getOriginalFilename();

　　 Path path = Paths.get("./"+s);

　　 Files.write(path, bytes);

　　 return "success";

　　 } catch (Throwable e) {

　　 e.printStackTrace();

　　 }else {

　　 return "格式不支持";

　　 return "error";

　　 @RequestMapping(value = "/test")

　　 public String test(Model model) throws Exception{

　　 Book book = new Book();

　　 book.setPassword("123");

　　 model.addAttribute("book",book);

　　 return "test";

　　}

　　 1.3整合 Ehcache

　　 Spring Boot支持多种不同的缓存产品。在默认情况下使用的是简单缓存，不建议在正式环境中使用。我们可以配置一些更加强大的缓存，比如Ehcache。Ehcache是一种广泛使用的开源Java分布式缓存，它具有内存和磁盘存储、缓存加载器、缓存扩展、缓存异常处理、GZIP缓存、Servlet过滤器，以及支持REST和SOAP API等特点。

@Service

　　@CacheConfig(cacheNames = {"userCache"})

　　public class BookServiceImpl implements BookService{

　　 @Autowired

　　 private BookDao bookDao;

　　 @Override

　　 @Cacheable(value = "usr",key = "targetClass + #p0")

　　 public Page Book findAll() {

　　 return bookDao.findAll();

　　}

　　 1.4整合 Caffeine

　　 Caffeine是使用Java 8对Guava缓存的重写版本。它基于LRU算法实现，支持多种缓存过期策略。要使用它，需要在pom.xml文件中增加Caffeine依赖，这样Spring Boot就会自动用 Caffeine替换默认的简单缓存。

　　增加Caffeine依赖的代码如下：

 dependency

　　 groupId com.github.ben-manes.caffeine /groupId

　　 artifactId caffeine /artifactId

　　 /dependency

　　然后配置参数，见以下代码：

spring:

　　 cache:

　　 type: caffeine

　　 cache-names: myCaffeine

　　 caffeine:

　　 spec: maximumSize=1,expireAfterAccess=5s

　　代码解释如下。

　　cache.type:指定使用哪个缓存供应商。

　　cache.cache-names：在启动时创建缓存名称（即前面的cacheNames ）。如果有多个名称，则用逗号进行分隔。

　　cache.caffeine.spec：这是 Caffeine 缓存的专用配置。

　　maximumSize=1：最大缓存数量。如果超出最大缓存数量，则保留后进（最新）的，最开始的缓存会被清除。

　　expireAfterAccess=5s：缓存5s，即缓存在5 s之内没有被使用，就会被清除，在默认情况下，缓存的数据会一直保存在内存中。有些数据可能用一次后很长时间都不会再月，这样会有大量无用的数据长时间占用内存，我们可以通过配置及时清除不需要的缓存。

　　2. 认识Redis

　　 2.1 对比 Redis 与 Memcached

　　 Cache可以和Redis一起用，Spring Boot支持把Cache存到Redis里。如果是单服务器，则用Cache、Ehcache或Caffeine，性能更高也能满足需求。如果拥有服务器集群，则可以使用 Redis,这样性能更高。

　　 1. Redis

　　 Redis是目前使用最广泛的内存数据存储系统之一。它支持更丰富的数据结构，支持数据持久化、事务、HA （高可用High Available）双机集群系统、主从库。

　　 Redis是key-value存储系统。它支持的value类型包括String、List、Set、Zset （有序集合）和Hash。这些数据类型都支持push/pop、add/remove，以及取交集、并集、差集或更丰富的操作，而且这些操作都是原子性的。在此基础上，Redis支持各种不同方式的排序和算法。

　　 Redis会周期性地把更新后的数据写入磁盘，或把修改操作写入追加的记录文件中（RDB和 AOF两种方式），并且在此基础上实现了 master-slave （主从）同步。机器重启后，能通过持久化数据自动重建内存。如果使用Redis作为Cache，则机器宕机后热点数据不会丢失。

　　丰富的数据结构加上Redis兼具缓存系统和数据库等特性，使得Redis拥有更加丰富的应用场景。

　　 Redis可能会导致的问题：

　　
2.Memcached

　　 Memcached的协议简单，它基于Libevent的事件处理，内置内存存储方式。Memcached 的分布式不互相通信，即各个Memcached不会互相通信以共享信息，分布策略由客户端实现。它不会对数据进行持久化，重启Memcached、重启操作系统都会导致全部数据消失。

　　 Memcached常见的应用场景一存储一些读取频繁但更新较少的数据，如静态网页、系统配置及规则数据、活跃用户的基本数据和个性化定制数据、实时统计信息等。

　　 3. 比较 Redis 与 Memcached

　　（1）关注度。

　　近年来，Redis越来越火热，人们对Redis的关注度越来越高；对 Memcached关注度比较平稳，且有下降的趋势。

　　（2）性能。

　　两者的性能都比较高。

　　（3）数据类型。

　　 Memcached的数据结构单一。

　　 Redis非常丰富。

　　（4）内存大小。

　　 Redis在2.0版本后增加了自己的VM特性，突破物理内存的限制。

　　 Memcached可以修改最大可用内存的大小来管理内存，采用LRU算法.

　　（5）可用性。

　　 Redis依赖客户端来实现分布式读写，在主从复制时，每次从节点重新连接主节点都要依赖整个快照，无增量复制。Redis不支持自动分片(sharding)。如果要实现分片功能，则需要依赖程序设定一致的散列(hash)机制。

　　 Memcached采用成熟的hash或环状的算法，来解决单点故障引起的抖动问题，其本身没有数据冗余机制。

　　（6）持久化。

　　 Redis依赖快照、AOF进行持久化。但AOF在增强可靠性的同时，对性能也有所影响。

　　 Memcached不支持持久化，通常用来做缓存，以提升性能。

　　（7）value数据大小。

　　 Redis的value的最大限制是1GB。

　　 Memcached只能保存1MB以内的数据。

　　（8）数据一致性(事务支持)。

　　 Memcached在并发场景下用CAS保证一致性。

　　 Redis对事务支持比较弱，只能保证事务中的每个操作连续执行。

　　（9）应用场景。

　　 Redis：适合数据量较少、性能操作和运算要求高的场景。

　　 Memcached：适合提升性能的场景。适合读多与少，如果数据量比较大，则可以采用分片的方式来解决。

　　 2.2 Redis的适用场景

　　高并发的读写

　　 Redis特别适合将方法的运行结果放入缓存，以便后续在请求方法时直接去缓存中读取。对执行耗时，且结果不频繁变动的SQL查询的支持极好。

　　在高并发的情况下，应尽暈避免请求直接访问数据库，这时可以使用Redis进行缓冲操作，让请求先访问Redis。

　　电商网站（APP）商品的浏览量、视频网站（APP）视频的播放数等数据都会被统计，以便用于运营或产品分析。为了保证数据实时生效，每次浏览都得+1,这会导致非常高的并发量。这时可以用Redis提供的incr命令来实现计数器功能，这一切在内存中操作，所以性能非常好，非常适用于这些计数场景。

　　可以利用Redis提供的有序集合数据类，实现各种复杂的排行榜应用。如京东、淘宝的销量榜单，商品按时间、销量排行等。

　　分布式会话

　　在集群模式下，一般都会搭建以Redis等内存数据库为中心的Session （会活）服务，它不再由容器管理，而是由Session服务及内存数据库管理。

　　使用Redis提供的散列、集合等数据结构，可以很方便地实现网站（APP）中的点赞、踩、关注共同好友等社交场景的基本功能。

　　 Redis可以通过LPUSH在列表头部插入一个内容ID作为关键字，LTRIM可用来限制列表的数量，这样列表永远为N个ID,无须查询最新的列表，直接根据ID查找対应的内容即可。

　　3. Redis的数据类型

　　 Redis有5种数据类型，见表11-2。

　　表 11-2

　　字符串（string）

　　 Redis字符串可以包含任意类型的数据、字符、整数、浮点数等。

　　一个字符串类型的值的容量有512MB,代表能存储最大512MB的内容。

　　可以使用INCR （DECR、INCRBY）命令来把字符串当作原子计敬器使用。

　　使用APPEND命令在字符串后添加内容。

　　应用场景：计数器。

　　列表（list）

　　 Redis列表是简单的字符串列表，按照插入顺序排序。可以通过LPUSH、RPUSH命令添加一个元素到列表的头部或尾部。

　　一个列表最多可以包含以”232-1“（4294967295）个元素。

　　应用场景：取最新N个数据的操作、消息队列、删除与过滤、实时分析正在发生的情况，数据统计与防止垃圾邮件（结合Set ）。

　　集合（set）

　　 Redis集合是一个无序的、不允许相同成员存在的字符串合集。

　　支持一些服务器端的命令从现有的集合出发去进行集合运算，如合并（并集：union）、求交（交集intersection）、差集，找出不同元素的操作（共同好友、二度好友）。

　　应用场景：Unique操作，可以获取某段时间内所有数据“排重值”，比如用于共同好友、二度好友、统计独立IP、好友推荐等。

　　散列（hash ）

　　 Redis hash是字符串字段和字符串值之间的映射，主要用来表示对象，也能够存储许多元素。

　　应用场景：存储、读取、修改用户属性。

　　有序集合（sorted set、zset）

　　 Redis有序集合和Redis集合类似，是不包含相同字符串的合集。每个有序集合的成员都关联着一个评分，这个评分用于把有序集合中的成员按最低分到最高分排列（排行榜应用，取TOP N 操作）。

　　使用有序集合，可以非常快捷地完成添加、删除和更新元素的操作。元素是在插入时就排好序的，所以很快地通过评分（score ）或位次（position ）获得一个范围的元素。

　　应用场景：排行榜应用、取TOP N、需要精准设定过期时间的应用（时间戳作为Score）、带有权重的元素（游戏用户得分排行榜）、过期项目处理、按照时间排序等。

　　4. 用RedisTemplate操作Redis的五种数据类型

　　 4.1 认识opsFor方法

　　Spring封装了 RedisTemplate来操作Redis,它支持所有的Redis原生的API，在 RedisTemplate中定义了对5种数据结构的操作方法。

　　
下面通过实例来理解和应用这些方法。这里需要特别注意的是，运行上述方法后要对数据进行清空操作，否则多次运行会导致数据重复操作。

　　4.2 操作字符串

　　字符串（string ）是Redis最基本的类型。string的一个“key”对应一个"value”，即key-value 键值对。string是二进制安全的，可以存储任何数据（比如图片或序列化的对象）。值最大能存储512MB的数据。一般用于一些复杂的计数功能的缓存。RedisTemplate提供以下操作string的方法。

　　（1）set void set(K key, V value)；get V get(Object key)

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void contextLoads() {

　　 redisTemplate.opsForValue().set("hello", "world");

　　 redisTemplate.opsForValue().set("staing","somewhere");

　　 Object s = redisTemplate.opsForValue().get("hello");

　　 Object s2 = redisTemplate.opsForValue().get("staing");

　　 System.out.println(s);

　　 System.out.println(s2);

　　}

　　（2）set void set(K key, V value, long timeout, TimeUnit unit)

　　以下代码设置3 s失效。3 s之内查询有结果，3 s之后查询则返回为null。具体用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void String(){

　　 redisTemplate.opsForValue().set("hello", "world",3, TimeUnit.SECONDS);

　　 try {

　　 Object s = redisTemplate.opsForValue().get("hello");

　　 System.out.println(s);

　　 Thread.currentThread().sleep(2000);

　　 s = redisTemplate.opsForValue().get("hello");

　　 System.out.println(s);

　　 Thread.currentThread().sleep(2000);

　　 s = redisTemplate.opsForValue().get("hello");

　　 System.out.println(s);

　　 Thread.currentThread().sleep(2000);

　　 } catch (InterruptedException e) {

　　 e.printStackTrace();

　　}

　　TimeUnit是java.util.concurrent包下面的一个类，表示给定单元粒度的时间段，常用的颗粒度有：

　　小时(TimeUnit.HOURS )

　　分钟(TimeUnit.MINUTES )

　　秒(TimeUnit.SECONDS )

　　毫秒(TimeUnit.MILLISECONDS )

　　（3）set void set(K key, V value, long offset)

　　给定key所存储的字符串值，从偏移量 offset开始。具体用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForValue().set("key", "hello world",6);

　　 System.out.println(redisTemplate.opsForValue().get("key"));

　　}

　　运行测试，输出如下结果：

　　 hello

　　（4）getAndSet V getAndSet(K key, V value)

　　设置键的字符串值，并返回其旧值。具体用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForValue().set("hello", "world");

　　 System.out.println(redisTemplate.opsForValue().getAndSet("hello", "hey"));

　　 System.out.println(redisTemplate.opsForValue().get("hello"));

　　}

　　运行测试，输出如下结果：

　　 world

　　 hey

　　（5）append Integer append(K key, String value)

　　如果key已经存在，并且是一个字符串，则该命令将该值追加到字符串的末尾。如果key不存在，则它将被创建并设置为空字符串，因此append在这种特殊情况下类似于set。用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate String,String redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForValue().append("hello", "hello");

　　 System.out.println(redisTemplate.opsForValue().get("hello"));

　　 redisTemplate.opsForValue().append("hello", "world");

　　 System.out.println(redisTemplate.opsForValue().get("hello"));

　　}

　　运行测试，输出如下结果：

　　 hello

　　 helloworld

　　这里一定要注意反序列化配置，否则会报借。

　　（6）size Long size(K key)

　　返回key所对应的value值的长度，见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForValue().set("key", "1");

　　 System.out.println(redisTemplate.opsForValue().size("key"));

　　}

　　运行测试，输岀如下结果：

　　 4.3操作散列

　　 Redis hash (散列)是一个string类型的field和value的映射表，hash特别适合用于存储对象。value中存放的是结构化的对象.利用这种数据结构，可以方便地操作其中的某个字段。比如在“单点登录”时，可以用这种数据结构存储用户信息。以Cookield作为key,设置30分钟为缓存过期时间，能很好地模拟出类似Session的效果。

　　（1）void putAII(H key, Map ? extends HK, ? extends HV m)

　　用m中提供的多个散列字段设置到key对应的散列表中，用法见以下代码:

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 Map String, Object map = new HashMap String, Object

　　 map.put("key1", "value1");

　　 map.put("key2", "value2");

　　 redisTemplate.opsForHash().putAll("HASH",map);

　　 System.out.println(redisTemplate.opsForHash().entries("HASH"));

　　}

　　运行测试，输出如下结果：

　　 {key1=value1, key2=value2}

　　（2）void put(H key, HK hashKey, HV value)

　　设置hashKey的值，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().entries("redis"));

　　}

　　运行测试，输出如下结果：

　　 {name=li, sex=male}

　　（3）List HV values(H key)

　　根据密钥获取整个散列存储的值，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().values("redis"));

　　}

　　运行测试，输出如下结果：

　　 [li, male]

　　（4）Map HK, HV entries(H key)

　　根据密钥获取整个散列存储，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().entries("redis"));

　　}

　　运行测试，输出如下结果：

　　 {name=li, sex=male}

　　（5）Long delete(H key, Object... hashKeys)

　　删除给定的hashKeys,用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().delete("redis","name"));

　　 System.out.println(redisTemplate.opsForHash().entries("redis"));

　　}

　　运行测试，输出如下结果：

　　 1
{sex=male}

　　（6）Boolean hasKey(H key, Object hashKey)

　　确定hashKey是否存在，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().hasKey("redis","name"));

　　 System.out.println(redisTemplate.opsForHash().hasKey("redis","sex"));

　　}

　　运行测试，输出如下结果：

　　 true
true

　　（7）HV get(H key, Object hashKey)

　　从键中的散列获取给定hashKey的值，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().get("redis","name"));

　　}

　　运行测试，输出如下结果：

　　（8）Set HK keys(H key)

　　获取key所对应的key的值，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().keys("redis"));

　　}

　　运行测试，输出如下结果：

　　 [sex, name]

　　（9）Long size(H key)

　　获取key所对应的散列表的大小个数，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForHash().put("redis","name","li");

　　 redisTemplate.opsForHash().put("redis","sex","male");

　　 System.out.println(redisTemplate.opsForHash().size("redis"));

　　}

　　运行测试，输出如下结果：

　　 4.4操作列表

　　 Redis列表是简单的字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部(左边) 或尾部(右边)。

　　使用list数据结构，可以做简单的消息队列的功能。还可以利用Irange命令，做基于Redis的分页功能，性能极佳。而使用SQL语句做分页功能往往效果扱差。

　　（1）Long leftPushAII(K key, V... values)

　　 leftPushAII表示把一个数组插入列表中，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[] {"1","2","3"};

　　 redisTemplate.opsForList().leftPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　}

　　运行测试，输岀如下结果：

　　 [3,2,1]

　　（2）Long size(K key)

　　返回存储在键中的列表的长度。如果键不存在，则将其解释为空列表，并返回0。如果key存储的值不是列表，则返回错误。用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[] {"1","2","3"};

　　 redisTemplate.opsForList().leftPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　}

　　运行测试，输岀如下结果：

　　（3）Long leftPush(K key, V value)

　　将所有指定的值插入在键的列表的头部，如果键不存在，则在执行推送操作之前将其创建为空列表(从左边插入)。用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForList().leftPush("list","1");

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　 redisTemplate.opsForList().leftPush("list","2");

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　 redisTemplate.opsForList().leftPush("list","3");

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　}

　　（4）Long rightPush(K key, V value)

　　将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表(从右边插入)。用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 redisTemplate.opsForList().rightPush("list","1");

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　 redisTemplate.opsForList().rightPush("list","2");

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　 redisTemplate.opsForList().rightPush("list","3");

　　 System.out.println(redisTemplate.opsForList().size("list"));

　　}

　　（5）Long rightPushAII(K key, V... values)

　　通过rightPushAII方法向最右边批量添加元素,用法见以下代码:

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"1", "2", "3"};

　　 redisTemplate.opsForList().rightPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　}

　　（6）void set(K key, long index, V value)

　　在列表中index的位置设置value,用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"1", "2", "3"};

　　 redisTemplate.opsForList().rightPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　 redisTemplate.opsForList().set("list",1,"值");

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　}

　　运行测试，输出如下结果：

　　 [1, 2, 3]
[1, 值, 3]

　　（7）Long remove(K key, long count, Object value)

　　从存储在键中的列表，删除给定“count”值的元素的第1个计数事件。其中，参数count的含义如下。

　　
String[] strings = new String[]{"1", "2", "3"};

　　 redisTemplate.opsForList().rightPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　 redisTemplate.opsForList().remove("list",1,"2");

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　}

　　运行测试，输出如下结果：

　　 [1, 2, 3]
[1, 3]

　　（8）V index(K key, long index)

　　根据下标获取列表中的值(下标从0幵始)，用法见以下代码:

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"1", "2", "3"};

　　 redisTemplate.opsForList().rightPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　 System.out.println(redisTemplate.opsForList().index("list",2));

　　}

　　运行测试，输出如下结果：

　　 [1, 2, 3]
3

　　（9）V leftPop(K key)

　　弹出最左边的元素，弹出之后该值在列表中将不复存在，用法见以下代码:

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"1", "2", "3"};

　　 redisTemplate.opsForList().rightPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　 System.out.println(redisTemplate.opsForList().leftPop("list"));

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　}

　　运行测试，输出如下结果：

　　 [1, 2, 3]
1
[2, 3]

　　（10）V rightPop(K key)

　　弹出最右边的元素，弹出之后该值任列表中将不复存在，用法见以下代码:

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"1", "2", "3"};

　　 redisTemplate.opsForList().rightPushAll("list",strings);

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　 System.out.println(redisTemplate.opsForList().rightPop("list"));

　　 System.out.println(redisTemplate.opsForList().range("list",0,-1));

　　}

　　运行测试，输出如下结果：

　　 [1, 2, 3]
3
[1, 2]

　　 4.5操作集合

　　 set是存放不重复值的集合。利用set可以做全局去重的功能。还可以进行交集、并集、差集等操作，也可用来实现计算共同喜好、全部的喜好、自己独有的喜好等功能。

　　 Redis的set是string类型的无序集合，通过散列表实现。

　　（1）Long add(K key, .. values)

　　在无序集合中添加元素，返回添加个数，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"str1", "str2"};

　　 System.out.println(redisTemplate.opsForSet().add("set1",strings));

　　 System.out.println(redisTemplate.opsForSet().add("set1","1","2","3"));

　　}

　　运行测试，输出如下结果：

　　（2）Long remove(K key, Object... values)

　　移除集合中一个或多个成员，用法见以下代码:

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"str1", "str2"};

　　 System.out.println(redisTemplate.opsForSet().add("set1",strings));

　　 System.out.println(redisTemplate.opsForSet().remove("set1",strings));

　　}

　　运行测试，输出如下结果：

　　（3）V pop(K key)

　　移除并返回集合中的一个随机元素，用法见以下代码：

@SpringBootTest

　　class RedisApplicationTests {

　　 @Autowired

　　 private RedisTemplate redisTemplate;

　　 @Test

　　 void test() {

　　 String[] strings = new String[]{"str1", "str2"};

　　 System.out.println(redisTemplate.opsForSet().add("set1",strings));

　　 System.out.println(redisTemplate.opsForSet().pop("set1"));

　　 System.out.println(redisTemplate.opsForSet().members("set1"));

　　}

　　运行测试，输出如下结果：

　　 2
str2
[str1]

　　（4）Boolean move(K key, V value, K destKey)

　　将member元素移。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读