redis-SpringBoot(21)
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命令添加一个元素到列表的头部或尾部。
一个列表最多可以包含以”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种数据结构的操作方法。
-
- 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"));
}
}
运行测试,输岀如下结果:
3
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"));
}
}
运行测试,输出如下结果:
li
(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"));
}
}
运行测试,输出如下结果:
2
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"));
}
}
运行测试,输岀如下结果:
6
(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
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));
}
}
运行测试,输出如下结果:
2
0
(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"));
}
}
运行测试,输出如下结果:
2
2
(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"));
}
}
运行测试,输出如下结果:
2
[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());
}
}
}
运行测试,输岀如下结果:
2
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的序列化策略。