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注解的使用方法见以下代码：

@Override
@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可能会导致的问题：

- 缓存和数据库双写一致性问题。
- 缓存雪崩问题。
- 缓存击穿问题。
- 缓存的并发竞争问题。

Redis为什么快：

- 纯内存操作。
- 单线程操作，避免了频繁的上下文切换。
- 采用了非阻塞I/O多路复用机制。

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命令添加一个元素到列表的头部或尾部。

一个列表最多可以包含以”2³²-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种数据结构的操作方法。

- opsForValueQ：操作字符串。
- opsForHashO：操作散列。
- opsForList（）：操作列表。
- opsForSet（）：操作集合。
- opsForZSetO：操作有序集合。

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

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的含义如下。

- count=0：删除等于value的所有元素。
- count>0：删除等于从头到尾移动的值的元素：
- counK<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));
        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元素移动，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        String[] strings = new String[]{\"str1\", \"str2\"};
        System.out.println(redisTemplate.opsForSet().add(\"set1\",strings));
        redisTemplate.opsForSet().move(\"set1\",\"str1\",\"set1tostr1\");
        System.out.println(redisTemplate.opsForSet().members(\"set1\"));
        System.out.println(redisTemplate.opsForSet().members(\"set1tostr1\"));
    }
}

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

2
[str2]
[str1]

（5）Long size(K key)

获取无序集合的大小长度，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        String[] strings = new String[]{\"str1\", \"str2\"};
        System.out.println(redisTemplate.opsForSet().add(\"set\",strings));
        System.out.println(redisTemplate.opsForSet().size(\"set\"));
    }
}

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

（6）Set<V> members(K key)

返回集合中的所有成员，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        String[] strings = new String[]{\"str1\", \"str2\"};
        System.out.println(redisTemplate.opsForSet().add(\"set\",strings));
        System.out.println(redisTemplate.opsForSet().members(\"set\"));
    }
}

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

[str1,str2]

（7）Cursor<V> scan(K key, ScanOptions options)

遍历Set,用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        String[] strings = new String[]{\"str1\", \"str2\"};
        System.out.println(redisTemplate.opsForSet().add(\"set\",strings));
        Cursor<Object> cursor = redisTemplate.opsForSet().scan(\"set\", ScanOptions.NONE);
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }
}

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

str2

str1

4.6 操作有序集合

zset (sorted set,有序集合)也是string类型元素的集合，且不允许重复的成员。每个元素都会关联一个double类型的分数。可以通过分数将该集合中的成员从小到大进行排序。

zset的成员是唯一的，但权重参数分数(score)却可以重复。集合中的元素能够按score进行排列。它可以用来做排行榜应用、取TOP N 延时任务、范围查找等。

（1）Long add(K key, Set<TypedTuple<V>>tuples)

新增一个有序集合，用法见以下代码:

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
    }
}

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

1
[zset-1, zset-2]

（2）Boolean add(K key, V value, double score)

新增一个有序集合，如果存在则返回false,如果不存在则返回true，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",\"zset-1\",1.0));
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",\"zset-1\",1.0));
    }
}

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

true
false

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

从有序集合中移除一个或多个元素，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",\"zset-1\",1.0));
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",\"zset-2\",1.0));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
        System.out.println(redisTemplate.opsForZSet().remove(\"zset\",\"zset-2\"));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
    }
}

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

true
true
[zset-1, zset-2]
1
[zset-1]

（4）Long rank(K key, Object o)

返回有序集中指定成员的排名，按分数值递增排列，用法见以下代码:

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",\"zset-1\",1.0));
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",\"zset-2\",1.0));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
        System.out.println(redisTemplate.opsForZSet().remove(\"rank\",\"zset-1\"));
    }
}

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

true
true
[zset-1, zset-2]
0

（5）Set<V> range(K key, long start, long end)

通过索引区间返回有序集合指定区间内的成员，按分数值递增排列，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",8.1);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
    }
}

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

0
[zset-2, zset-1]

（6）Long count(K key, double min, double max)

通过分数返回有序集合指定区间内的成员个数，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",3.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",4.1);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<>(\"zset-3\",5.7);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        System.out.println(redisTemplate.opsForZSet().rangeByScore(\"zset\",0,9));
        System.out.println(redisTemplate.opsForZSet().count(\"zset\",0,5));
    }
}

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

1
[zset-1, zset-2, zset-3]
2

（7）Long size(K key)

获取有序集合的成员数，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",3.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",4.1);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<>(\"zset-3\",5.7);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        System.out.println(redisTemplate.opsForZSet().size(\"zset\"));
    }
}

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

0
3

（8）Double score(K key, Object o)

获取指定成员的score值，用法见以下代码:

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",3.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",4.1);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<>(\"zset-3\",5.7);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        System.out.println(redisTemplate.opsForZSet().score(\"zset\",\"zset-1\"));
    }
}

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

0
3.6

（9）Long removeRange(K key, long start, long end)

移除指定索引位置的成员，有序集成员按分数值递增排列，用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",3.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",4.1);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<>(\"zset-3\",2.7);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
        System.out.println(redisTemplate.opsForZSet().removeRange(\"zset\",1,2));
        System.out.println(redisTemplate.opsForZSet().range(\"zset\",0,-1));
    }
}

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

2
[zset-3, zset-1, zset-2]
2
[zset-3]

（10）Cursor<TypedTuple<V>>scan(K key, ScanOptions options)

遍历zset,用法见以下代码：

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void test() {
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>(\"zset-1\",3.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>(\"zset-2\",5.1);
        ZSetOperations.TypedTuple<Object> objectTypedTuple3 = new DefaultTypedTuple<>(\"zset-3\",2.7);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        tuples.add(objectTypedTuple3);
        System.out.println(redisTemplate.opsForZSet().add(\"zset\",tuples));
        Cursor<ZSetOperations.TypedTuple<Object>> cursor = redisTemplate.opsForZSet().scan(\"zset\",ScanOptions.NONE);
        while (cursor.hasNext()) {
            ZSetOperations.TypedTuple<Object> item = cursor.next();
            System.out.println(item.getValue()+\"：\"+item.getScore());
        }
    }
}

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

2
zset-3：2.7
zset-1：3.6
zset-2：5.1

除使用opsForXXX方法外，还可以使用Execute方法。opsForXXX方法的底层，是通过调用Execute方法来实现的。psForXXX方法实际上是封装了 Execute方法，定义了序列化，以便使用起来更简单便捷。

4.7 比较 RedisTemplate 和 StringRedisTemplate

StringRedisTemplate继承于RedisTemplate,两者的数据是不相通的。

StringRedisTemplate 只能管理 StringRedisTemplate 中的数据。
RedisTemplate 只能管理 RedisTemplate 中的数据。

StnngRedisTemplate默认采用的是string的序列化策略，RedisTemplate默认采用的是 JDK的序列化策略。

来源：https://www.cnblogs.com/liwenruo/p/16575571.html
本站部分图文来源于网络，如有侵权请联系删除。

redis-SpringBoot（21）

1. 认识Spring Cache

1.1 声明式缓存注解

1.@EnableCaching

2.@Cacheable

3. @CachePut

4. @CacheEvict

5. @Caching

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

（1）添加依赖

（2）配置缓存管理器

（3）开启缓存功能

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

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

1.3 整合 Ehcache

1.4 整合 Caffeine

2. 认识Redis

2.1 对比 Redis 与 Memcached

1. Redis

2. Memcached

3. 比较 Redis 与 Memcached

2.2 Redis的适用场景

3. Redis的数据类型

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

4.1 认识opsFor方法

4.2 操作字符串

4.3 操作散列

4.4 操作列表

4.5 操作集合

4.6 操作有序集合

4.7 比较 RedisTemplate 和 StringRedisTemplate

相关推荐

热门文章