Spring Data Redis 入门（三）----ListOperations

最新推荐文章于 2024-08-05 08:45:00 发布
最新推荐文章于 2024-08-05 08:45:00 发布
阅读量1.4w 收藏 12
点赞数 3
分类专栏： Redis 文章标签： ListOperations Redis Spring Data Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010974033/article/details/80645603
版权

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

一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

其中ListOperations的方法简单示例为：

package com.ly;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.ly.entity.Book;
import com.ly.entity.User;
/**
 * 
 * @author LY
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:applicationContext.xml" })
public class ListOperationsTest {
	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
	
	private ListOperations<String, Object> opsForList;
	
	@Before
	public void setUp() throws Exception {
		opsForList=redisTemplate.opsForList();
		
	}
	
	public User userConfig() {
		Random rand = new Random();
		 UUID uuid = UUID.randomUUID(); 
		User user=new User();
		user.setId(rand.nextLong()+1);
		user.setName(uuid.toString());
		user.setTime(new Date());
		List<Book>books=new ArrayList<Book>();
		Book book=new Book();
		book.setBookName(uuid.toString());
		book.setId(rand.nextLong()+1);
		books.add(book);
		user.setBooks(books);
		return user;
	}
	
	/**
	 * List<V> range(K key, long start, long end);
	 *  返回列表中指定区间内的元素，区间以偏移量 START 和 END 指定。 其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。
	 *   你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。 
	 */
	@Test
	public void testRange() {
		opsForList.range("opsForList:leftPush", 0,-1);
	}
	
	
	/**
	 * void trim(K key, long start, long end);
	 * 让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
	 * 下标 0 表示列表的第一个元素，以 1 表示列表的第二个元素，以此类推。 
	 * 你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 */
	@Test
	public void testTrim() {
		//opsForList.leftPushAll("opsForList:trim","1","2",new Object[] {"3","4"});
		opsForList.trim("opsForList:trim", 0, -3);
	}
	
	/**
	 * Long size(K key); 
	 * 获得制定Key的长度。
	 */
	@Test
	public void testSize() {
		System.out.println(opsForList.size("opsForList:leftPushAllForList"));
	}
	
	/**
	 * Long leftPush(K key, V value); //left 是左面进入 也就是靠前 先进后出
	 * List<V> range(K key, long start, long end); //取得list值。
	 */
	@Test
	public void leftPush() {
		System.out.println(opsForList.leftPush("opsForList:leftPush",userConfig()));//8
		System.out.println(opsForList.leftPush("opsForList:leftPush",userConfig()));//9
		System.out.println(opsForList.leftPush("opsForList:leftPush",userConfig()));//10
		System.out.println(opsForList.range("opsForList:leftPush", 0, -1).size());//10 
		//如果便利list 得到的一定是 10 9 8 的顺序
	}
	/**
	 * Long leftPushAll(K key, V... values); //多个值同 leftPush
	 */
	@Test
	public void leftPushAll() {
		System.out.println(opsForList.leftPushAll("opsForList:leftPushAll",userConfig(),userConfig()));
	}
	/**
	 * Long leftPushAll(K key, Collection<V> values); 存放list
	 */
	@Test
	public void leftPushAllForList() {
		/*List<User> users=new ArrayList<User>();
		for (int i = 0; i < 10; i++) {
			users.add(userConfig());
		}*/
		
		List<Object> objects=new ArrayList<Object>();
		for (int i = 0; i < 10; i++) {
			objects.add(i);
		}
		//opsForList.leftPushAll("opsForList:leftPushAllForList",users);
		opsForList.leftPushAll("opsForList:leftPushAllForList",objects);
		
	}
	
	/**
	 * Long leftPushIfPresent(K key, V value);
	 * 把值加入列表的头部 必须有一个值。没有值无效
	 */
	@Test
	public void testLeftPushIfPresent() {
		System.out.println(opsForList.leftPush("opsForList:leftPushIfPresent", 0));//1
		System.out.println(opsForList.leftPushIfPresent("opsForList:leftPushIfPresent",1));//2
		System.out.println(opsForList.leftPushIfPresent("opsForList:leftPushIfPresent",2));
	}
	/**
	 * Long leftPush(K key, V pivot, V value);
	 * 把值插入到制定元素的前面 
	 * 输入 0 1 50 然后把 2插入到0前面 就是 50 1 2 0
	 */
	@Test
	public void testLeftPush1() {
		/*System.out.println(opsForList.leftPush("opsForList:leftPush1", 0));
		System.out.println(opsForList.leftPush("opsForList:leftPush1", 1));
		System.out.println(opsForList.leftPush("opsForList:leftPush1", 50));
		System.out.println(opsForList.leftPush("opsForList:leftPush1", 0,2));*/
		for (Object object:opsForList.range("opsForList:leftPush1", 0, -1)) {
			System.out.println(object);
		}
		//输出结果 50 1 2 0
	}
	
	/*********************************************************************************************************/
	/**
	 * Long rightPush(K key, V value);
	 * 顺序执行，先进先出
	 */
	@Test
	public void testRightPush() {
		opsForList.rightPush("opsForList:rightPush", 1);
		opsForList.rightPush("opsForList:rightPush", 2);
	}
	/**
	 * Long rightPushAll(K key, V... values);
	 */
	@Test
	public void testRightPushAll() {
		System.out.println(opsForList.rightPushAll("opsForList:testRightPushAll", 1,2,3));//3
		for(Object object:opsForList.range("opsForList:testRightPushAll", 0, -1)) {
			System.out.println(object);
		}
		//输出 123
	}
	/**
	 * ong rightPushAll(K key, Collection<V> values);
	 */
	@Test
	public void testRightPushAllForConlection() {
		List<Object> objects=new ArrayList<Object>();
		for (int i = 0; i < 10; i++) {
			objects.add(i);
		}
		System.out.println(opsForList.rightPushAll("opsForList:rightPushAllForConlection", objects));//10
		for(Object object:opsForList.range("opsForList:rightPushAllForConlection", 0, -1)) {
			System.out.println(object);
		}
		//输出结果 0 1 2 3 4 5 6 7 8 9
	}
	/**
	 * Long rightPushIfPresent(K key, V value);
	 * 必须有一个key 否则无效 然后存在之后继续向后插值
	 */
	@Test
	public void testRightPushIfPresent() {
		System.out.println(opsForList.rightPushIfPresent("opsForList:rightPushIfPresent", 0));//0
		System.out.println(opsForList.rightPush("opsForList:rightPushIfPresent", 0));//1
		System.out.println(opsForList.rightPushIfPresent("opsForList:rightPushIfPresent", 1));//2
		for(Object object:opsForList.range("opsForList:rightPushIfPresent", 0, -1)) {
			System.out.println(object);
		}
		//输出结果 0 1
	}
	/**
	 * Long rightPush(K key, V pivot, V value);
	 * 指定Value后面插入值
	 */
	@Test
	public void testRightPush1() {
		System.out.println(opsForList.rightPush("opsForList:testRightPush1", 0));//1
		System.out.println(opsForList.rightPush("opsForList:testRightPush1", 1));//2
		System.out.println(opsForList.rightPush("opsForList:testRightPush1", 2));//3
		System.out.println(opsForList.rightPush("opsForList:testRightPush1", 0,3));//4
		for(Object object:opsForList.range("opsForList:testRightPush1", 0, -1)) {
			System.out.println(object);
		}
		//输出结果 0 3 1 2
	}
	
	/******************************************************************************************/
	/**
	 * void set(K key, long index, V value);
	 * 当索引参数超出范围，或对一个空列表进行 LSET 时，返回一个错误。
	 */
	@Test
	public void testSetErrorForNoSuchKey () {
		try {
			opsForList.set("opsForList:set", 2, 1);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		//输出结果 ERR no such key
	}
	
	@Test
	public void testSetErrorForIndexOutTofrange () {
		try {
			opsForList.leftPush("opsForList:set", 1);
			opsForList.set("opsForList:set", 2, 1);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		//输出结果 ERR index out of range
	}
	
	/**
	 * 正确的set实例
	 * 通过索引来设置元素的值
	 * void set(K key, long index, V value);
	 */
	@Test
	public void testSerForTrue() {
		redisTemplate.delete("opsForList:set");
		try {
			opsForList.leftPush("opsForList:set", 1);
			opsForList.leftPush("opsForList:set", 2);
			opsForList.leftPush("opsForList:set", 3);
			opsForList.set("opsForList:set", 1, 333);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		for(Object object:opsForList.range("opsForList:set", 0, -1)) {
			System.out.println(object);
		}
		//输出结果3 333 1
	}
	/**
	 * Long remove(K key, long count, Object value);
	 *count > 0 : 从表头开始向表尾搜索，移除与 VALUE 相等的元素，数量为 COUNT 。
	 *count < 0 : 从表尾开始向表头搜索，移除与 VALUE 相等的元素，数量为 COUNT 的绝对值。
	 *count = 0 : 移除表中所有与 VALUE 相等的值。
	 */
	@Test
	public void testRemove() {
		opsForList.rightPush("opsForList:remove", 1);
		opsForList.rightPush("opsForList:remove", 1);
		opsForList.rightPush("opsForList:remove", 2);
		opsForList.rightPush("opsForList:remove", 3);
		opsForList.rightPush("opsForList:remove", 4);
		opsForList.rightPush("opsForList:remove", 4);
		opsForList.rightPush("opsForList:remove", 4);
		opsForList.rightPush("opsForList:remove", 5);
		opsForList.rightPush("opsForList:remove", 5);
		opsForList.rightPush("opsForList:remove", 5);
		opsForList.rightPush("opsForList:remove", 5);
		System.out.println(opsForList.remove("opsForList:remove", 2, 1));//234445555
		System.out.println(opsForList.remove("opsForList:remove", -3, 5));//234445
		System.out.println(opsForList.remove("opsForList:remove", 0, 4));//235
	}
	/**
	 * Redis Lindex 命令用于通过索引获取列表中的元素。你也可以使用负数下标，
	 * 以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。
	 * 从0起。。 
	 */
	@Test
	public void testIndex() {
		opsForList.rightPush("opsForList:index", 1);
		opsForList.rightPush("opsForList:index", 1);
		opsForList.rightPush("opsForList:index", 2);
		opsForList.rightPush("opsForList:index", 3);
		opsForList.rightPush("opsForList:index", 14);
		opsForList.rightPush("opsForList:index", 12);
		opsForList.rightPush("opsForList:index", 4);
		System.out.println(opsForList.index("opsForList:index", -1)); //4
		System.out.println(opsForList.index("opsForList:index", 3)); //3
		System.out.println(opsForList.index("opsForList:index", 5)); //12
	}
	/**
	 * V leftPop(K key);
	 * 命令用于移除并返回列表的第一个元素
	 */
	@Test
	public void testLeftPop() {
		System.out.println(opsForList.leftPop("opsForList:leftPop"));//没找到就会出现Null
		System.out.println(opsForList.rightPush("opsForList:leftPop", "123"));//1
		System.out.println(opsForList.rightPush("opsForList:leftPop","1234"));//2
		System.out.println(opsForList.leftPop("opsForList:leftPop"));//123
		System.out.println(opsForList.range("opsForList:leftPop", 0, -1).get(0));//1234
	}
	/**
	 * V rightPop(K key, long timeout, TimeUnit unit);
	 * @throws InterruptedException 
	 * Redis Blpop 命令移出并获取列表的第一个元素，
	 *  如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 
	 */
	@Test
	public void testLeftPopForTimeOut() throws InterruptedException {
		System.out.println(opsForList.rightPush("opsForList:leftPopForTimeOut", "123"));//1
		System.out.println(opsForList.rightPush("opsForList:leftPopForTimeOut","1234"));//2
		System.out.println(opsForList.leftPop("opsForList:leftPopForTimeOut",1,TimeUnit.SECONDS));
		Thread.sleep(5000);
		System.out.println(opsForList.size("opsForList:leftPopForTimeOut"));
		Thread.sleep(5000);
		System.out.println(opsForList.size("opsForList:leftPopForTimeOut"));
	}
	/**
	 * V rightPop(K key);
	 * 移除最后一个 并返回结果
	 */
	@Test
	public void testRightPop() {
		System.out.println(opsForList.rightPop("opsForList:rightPop"));//没找到就会出现Null
		System.out.println(opsForList.rightPush("opsForList:rightPop", "123"));//1
		System.out.println(opsForList.rightPush("opsForList:rightPop","1234"));//2
		System.out.println(opsForList.rightPop("opsForList:rightPop"));//1234
		System.out.println(opsForList.range("opsForList:rightPop", 0, -1).get(0));//123
	}
	/**
	 * V rightPop(K key, long timeout, TimeUnit unit);
	 * Redis Blpop 命令移出并获取列表的第一个元素，
	 *  如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 
	 */
	@Test
	public void testRightPopForTimeOut() {
		System.out.println(opsForList.rightPop("opsForList:rightPopForTimeOut"));//没找到就会出现Null
		System.out.println(opsForList.rightPush("opsForList:rightPopForTimeOut", "123"));//1
		System.out.println(opsForList.rightPush("opsForList:rightPopForTimeOut","1234"));//2
		System.out.println(opsForList.rightPop("opsForList:rightPopForTimeOut",1,TimeUnit.SECONDS));//1234
		System.out.println(opsForList.range("opsForList:rightPopForTimeOut", 0, -1).get(0));//123
	}
	/**
	 * V rightPopAndLeftPush(K sourceKey, K destinationKey);
	 * 列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
	 */
	@Test
	public void testRightPopAndLeftPush() {
		System.out.println(opsForList.rightPush("opsForList:rightPopAndLeftPush:right", "right1"));//1
		System.out.println(opsForList.rightPush("opsForList:rightPopAndLeftPush:right", "right2"));//2
		System.out.println(opsForList.rightPush("opsForList:rightPopAndLeftPush:right", "right3"));//3
		System.out.println(opsForList.rightPush("opsForList:rightPopAndLeftPush:left","left1"));//1
		System.out.println(opsForList.rightPush("opsForList:rightPopAndLeftPush:left","left2"));//2
		System.out.println(opsForList.rightPush("opsForList:rightPopAndLeftPush:left","left3"));//3
		System.out.println(opsForList.rightPopAndLeftPush("opsForList:rightPopAndLeftPush:left", "opsForList:rightPopAndLeftPush:right"));
		//俩个key中的值 分别为 left :left1 left2 right:right1 right2 right3 left 3
	}
	/**
	 * V rightPopAndLeftPush(K sourceKey, K destinationKey, long timeout, TimeUnit unit);
	 * @throws InterruptedException  
	 * 设置一个过期时间。在这时间中将被阻塞，如果超时未找到。就返回Null.
	 */
	@Test
	public void testRightPopAndLeftPushForTimeOut() throws InterruptedException {
		System.out.println(opsForList.rightPopAndLeftPush("opsForList:rightPopAndLeftPushTime:left", "opsForList:rightPopAndLeftPushTime:right",5,TimeUnit.SECONDS));
		System.out.println("5秒后 opsForList:rightPopAndLeftPushTime:right "+opsForList.size("opsForList:rightPopAndLeftPushTime:right"));
		
		Runnable runnable1 = new Runnable() {
		  public void run() {
              for(int i = 0;i<10;i++){
                  try {
                      Thread.sleep(1000);
                      if(i==7) {
                    	  opsForList.rightPush("opsForList:rightPopAndLeftPushTime:left", "left1");
                    	  return;
                      }else {
                    	  System.out.println("Runnable"+i);
                      }
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }

              }
          }
      };
      Thread thread1 = new Thread(runnable1);
      thread1.start();
      System.out.println(opsForList.rightPopAndLeftPush("opsForList:rightPopAndLeftPushTime:left", "opsForList:rightPopAndLeftPushTime:right",10,TimeUnit.SECONDS));
	}
}


Magic_洋
关注
专栏目录
Redis数据类型&RedisTemplate用法详解
weixin_44253327的博客
11-18 1312
目录 Redis 数据类型 一、Redis 字符串(String) -- ValueOperations 二、Redis 哈希(Hash) --HashOperations 三、Redis 列表(List) --ListOperations 四、Redis 集合(Set) -- SetOperations 五、Redis 有序集合(sorted set) -- ZSetOperations Redis 数据类型 Redis支持五种数据类型：string（字符串），hash...
HB-list-operations
03-19
HB-list-operations
redis的opsforlist保存
weixin_28862557的博客
07-06 46
使用OpsForList保存数据的Redis操作详解 在Redis中，我们可以使用OpsForList来保存数据，这是一种非常常见且实用的操作方式。OpsForList提供了一系列操作方法，可以方便地对列表数据进行操作，例如插入、删除、更新等。本文将介绍OpsForList的使用方法，并通过代码示例来演示其具体操作过程。 ...
List operations
07-13 171
The + operator concatenates lists: Similarly, the * operator repeats a list a given number of items: List slices The slice operator also works on lists: If you ...
ListOperations
weixin_30797199的博客
04-07 894
RedisOperations<K,V> getOperations() V index(Kkey, longindex) V leftPop(Kkey) V leftPop(Kkey, longtimeout, java.util.concurrent.TimeUnitunit) java.la...
在Spring Boot微服务使用ListOperations操作Redis List列表
zhangbeizhen18的博客
04-12 2468
记录：402 场景：在Spring Boot微服务使用RedisTemplate的ListOperations操作Redis List列表。
SpringBoot 2.X使用Redis(Lettuce)对list（ListOperations）的操作
lx1309244704的博客
10-08 5980
 ListOperations主要对redis 的list(链表)操作，下面我主要是讲一个具体的例子，将一个list集合如何多个值批量存储到缓存： 我们先看ListOperations的 leftPushAll这个方法的源码：它是用的 “V... values”；说明它是支持1-N个参数 /** * Prepend {@code values} to {@code key}. ...
Redis的Java客户端:SpringDataRedis
qq_52077925的博客
08-06 270
Redis学习笔记。
Spring Data Redis 1.8.18.RELEASE 官方文档翻译
AnY11的专栏
02-14 1703
Preface Spring Data Redis项目通过使用键值样式的数据存储将核心Spring概念应用于解决方案的开发。我们提供了一个“模板”作为发送和接收消息的高级抽象。您可能会注意到Spring框架中JDBC支持的相似之处。 1. New Features 本节简要介绍最新版本中值得注意的新项目。 1.1. New in Spring Data Redis 1.8 升级到Je...
Redis --- 基础篇
shuai_h的博客
12-18 610
Redis基础
Spring-Data-Redis入门学习
BlueBerryboys的博客
12-28 185
Spring-Data-Redis入门学习 Redis，Spring提供了Spring Data Redis用来实现通过配置文件的方式访问redis服务。 Jedis Jedis是Redis官方推出的一款面向Java的客户端，提供了很多借口供Java语言调用。 Spring Data Redis针对Jedis提供了如下功能： 连接池自动管理，提供了一个高度封住的RedisTemplate类。...
SpringDataRedis客户端
最新发布
xycxycooo的博客
08-05 574
SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis。SpringDataRedis提供了对不同Redis客户端的整合（如Lettuce和Jedis），提供了RedisTemplate统一API来操作Redis，支持Redis的发布订阅模型、哨兵和集群模式，支持基于Lettuce的响应式编程，支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化，以及基于Redis的JDK Collection实现。
在Spring Boot微服务使用ListOperations操作Redis集群List列表
zhangbeizhen18的博客
06-08 1828
记录：444 场景：在Spring Boot微服务使用RedisTemplate的ListOperations操作Redis集群的List列表数据类型。
spring-data-redis ListOperations
永不止步
12-26 7415
ListOperations
列表List实战之借助队列特性实现多线程发送邮件
weixin_37841366的博客
10-18 387
可以充当 消息队列-消息通知的角色! 内容二:自我实现邮件发送的功能，而且还是多线程批量发送! 发送邮件服务 MailDto.java //邮箱Dto @Data public class MailDto implements Serializable { private String subject;//主题 private String content;//内容 private String[] tos;//接收人，可以有多个接受人 } Thread..
redisTemplate 操作 ListOperations
aayygg1234的专栏
01-30 1053
/** * 获取指定key的范围内的value值的 list列表。 （0 -1）反回所有值列表 * * @param key 不能为null * @param start 起始位置 * @param end 结束位置 * @return V的列表 */ List<V> range(K key, long start, long end); /** * 保留key指定范围内的列表值。其它的都删.
无法将类型为system_comobject_Spring Data Redis 如何将 RedisTemplate 注入为 ListOperations 类型...
weixin_34366539的博客
01-13 100
在 Spring Data Redis 官方文档中，可以看到这样一个常规用法： xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.o...
列表List实战之简介与常用命令介绍
weixin_37841366的博客
10-17 732
正如JavaSE集合体系中的List一样，元素有序存储排着序! get SpringBoot:Redis:String:Key:V2 LPUSH myList a b c d e f LRANGE myList 0 6：取出指定范围的元素 LINDEX myList 0 LINDEX myList 1 BRPOP myList 1 LLEN myList LPOP myList:从左边弹出元素 LREM myList:从左边移除元素 @Test public void..
Redis基础
zhoumouJava的博客
05-31 267
一.前言 1.什么是Redis Redis是一个基于内存的Key-value结构数据库。是互联网技术领域使用最为广泛的存储中间件 2.使用Redis的好处 1.基于内存存储，读写性能高 2.适合存储热点数据 3.企业应用广泛 3.使用Redis能做什么 数据缓存 消息队列 注册中心 发布订阅 二. Redis入门 Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库，官方提供的数据是可以达到100000+的QPS（每秒内查询次数
spring-boot-starter-data-redis与spring-boot-starter-redis区别
10-13
spring-boot-starter-data-redis和spring-boot-starter-redis都是Spring Boot框架中与Redis集成的starter依赖，但它们的作用略有不同。 spring-boot-starter-data-redis是Spring Data Redis的starter依赖，它提供了对Redis的支持，包括使用RedisTemplate和Spring Data Redis Repository访问Redis数据库等功能。 而spring-boot-starter-redis则是Lettuce和Jedis的starter依赖，它提供了对Redis客户端的支持，包括使用Lettuce或Jedis连接Redis服务器等功能。 因此，如果你需要在Spring Boot应用中使用Spring Data Redis提供的高级功能，比如Repository访问等，则应该选择spring-boot-starter-data-redis；如果你只需要使用Redis客户端连接Redis服务器，则可以选择spring-boot-starter-redis。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值