准备工作
引入依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>2.6.10</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.6.10</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.58</version>
<scope>compile</scope>
</dependency>
</dependencies>修改序列号方式
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
template.setDefaultSerializer(new FastJsonRedisSerializer<>(Object.class));
return template;
}配置redis
spring:
redis:
host: 192.168.208.139编写主启动类
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}编写测试类
@SpringBootTest
public class TestApplication {
@Autowired
private RedisTemplate redisTemplate;
}数据类型
Redis是一种高性能的键值存储系统，支持多种数据类型。以下是Redis中常见的数据类型及其说明：
1. 字符串（String）：字符串是Redis中最基本的数据类型，可以存储任意类型的数据，如整数、浮点数、二进制数据等。
2. 列表（List）：列表是一个有序的字符串集合，可以在列表的两端进行插入和删除操作。可以用于实现队列、栈等数据结构。
3. 哈希（Hash）：哈希是一个键值对的集合，类似于关联数组。可以用于存储对象的属性和值，支持快速的查找和更新操作。
4. 集合（Set）：集合是一个无序的字符串集合，不允许重复的元素。可以进行交集、并集、差集等集合操作。
5. 有序集合（Sorted Set）：有序集合是一个有序的字符串集合，每个元素都关联着一个分数，可以根据分数进行排序。可以用于实现排行榜、优先级队列等功能。
6. 地理空间索引（Geospatial Index）：地理空间索引是Redis 3.2版本引入的数据类型，用于存储地理位置信息，并支持根据距离进行查询。
这些数据类型在Redis中都有对应的命令和操作，可以根据具体的需求选择合适的数据类型来存储和操作数据。
字符串操作
存值
@Test
void testStrSet(){
ValueOperations operations = redisTemplate.opsForValue();
//value设置为 key。
operations.set("key","正常的value");
//value为 的 key设置 和 过期timeout时间
operations.set("key1","有过期时间的value",10, TimeUnit.SECONDS);
//key用给定value的 覆盖从指定offset开始的部分
operations.set("key2","有offset",3);
//如果存在就修改
operations.setIfPresent("key1","有过期时间的value",10, TimeUnit.SECONDS);
//如果不存在就添加
operations.setIfAbsent("key1","有过期时间的value",10, TimeUnit.SECONDS);
Map map=new HashMap();
map.put("map1","111");
map.put("map2","222");
//一次设置多个
operations.multiSet(map);
Map map1=new HashMap();
map1.put("map3","3333");
map1.put("map4","444");
//如果map中一个元素也不存在就设置
Boolean aBoolean = operations.multiSetIfAbsent(map1);
System.out.println(aBoolean);
//获取老值并设置新值
Object andSet = operations.getAndSet("key", "newvalue");
System.out.println(andSet);
operations.set("append","22");
//给key追加
operations.append("append","333");
operations.set("num",10);
//给key减一 值必须是数字
operations.decrement("num");
//给key减2 值必须是数字
Long num = operations.decrement("num", 2);
System.out.println(num);
//给key加一 值必须是数字
operations.increment("num");
//给key加2 值必须是数字
operations.increment("num",2);
}取值
@Test
void testStrGet(){
ValueOperations operations = redisTemplate.opsForValue();
operations.set("key",123456789);
//获取key
Object key = operations.get("key");
System.out.println(key);
//获取key的值的字符串前五位 如下面获取的值是12345
String key1 = operations.get("key", 0, 4);
System.out.println(key1);
//获取key的值并设置过期时间
Object key2 = operations.getAndExpire("key", 10, TimeUnit.SECONDS);
System.out.println(key2);
//获取key值并删除
Object key3 = operations.getAndDelete("key");
System.out.println(key3);
//获取key的值，并删除它的过期时间
Object key4 = operations.getAndPersist("key");
System.out.println(key4);
operations.set("key2",2131);
//获取多个key的值
List list = operations.multiGet(Arrays.asList("key", "key2"));
System.out.println(list);
}hash操作
存值
@Test
void testHashPut(){
//类似map 一个map中有多个kv键值对
String key="map";
HashOperations operations = redisTemplate.opsForHash();
//添加集合map中添加一个属性和值
operations.put(key,"name","张三");
operations.put(key,"age",22);
Map data=new HashMap();
data.put("gender","man");
data.put("address","南京");
//添加集合map中添加map
operations.putAll(key,data);
//如果不存在就添加
operations.putIfAbsent(key,"age",22);
}取值
@Test
void testHashGet(){
//类似map 一个map中有多个kv键值对
String key="map";
HashOperations operations = redisTemplate.opsForHash();
//查询集合map中一个属性和值
Object name = operations.get(key, "name");
System.out.println(name);
//获取集合map的值
Map entries = operations.entries(key);
System.out.println(entries);
//获取一个集合中的多个属性值
List list = operations.multiGet(key, Arrays.asList("name", "age"));
System.out.println(list);
//获取一个集合的所有的key集合
Set keys = operations.keys(key);
System.out.println(keys);
//获取一个集合的所以值集合
List values = operations.values(key);
System.out.println(values);
//查询key中的所有kv
Cursor scan = operations.scan(key, ScanOptions.NONE);
while (scan.hasNext()){
Object next = scan.next();
System.out.println(next);
}
String pattern="*a*";//*是通配符
Long count=2L; //每次查返回的数目，不是分页，而是每次查多少条数据，查完为止，例如匹配有十条数据，这边写2，就需要消耗五次io，但结果返回是十条数据
//查询key包含a的kv
ScanOptions build = ScanOptions.scanOptions().match("*a*").count(2).build();
Cursor scan1 = operations.scan(key, build);
while (scan1.hasNext()){
Object next = scan1.next();
System.out.println(next);
}
//给集合key中的num加一（没有这个属性就创建 初始值是0 然后加一）
operations.increment(key,"num",1);
//是否包含牧歌属性
Boolean num = operations.hasKey(key, "num");
System.out.println(num);
//查看属性的长度
Long length = operations.lengthOfValue(key, "num");
System.out.println(length);
// 随机获取集合中的两个kv
Map map = operations.randomEntries(key, 2);
System.out.println(map);
//随机获取集合中的一个kv
Map.Entry entry = operations.randomEntry(key);
System.out.println(entry);
//随机获取集合中的一个key
Object o = operations.randomKey(key);
System.out.println(o);
//随机获取集合中两个key
List list1 = operations.randomKeys(key, 2);
System.out.println(list1);
//删除集合中多个key
operations.delete(key,"num","age");
}list操作
存值
@Test
void testListPush() {
String key = "list";
ListOperations operations = redisTemplate.opsForList();
//向集合左边加入值，如果集合不存在就创建集合
operations.leftPush(key, 11);
operations.leftPush(key, 22);
//向集合又边加入值
operations.rightPush(key, 33);
//查询索引是0-2的值，如果end为-1就是查询全部
List range = operations.range(key, 0, 2);
System.out.println(range);
//向集合左边加入集合
operations.leftPushAll(key, Arrays.asList(4, 5, 6));
//向集合又边加入集合
operations.rightPushAll(key, Arrays.asList(4, 5, 6));
//如果存在就向左边添加
operations.leftPushIfPresent(key, 22);
//更新list中索引是0的值为1 (找不到对应的索引会报错)
operations.set(key, 0, "1");
String key1 = "list1";
String key2 = "list2";
operations.leftPushAll(key1, Arrays.asList(1, 2, 3));
operations.leftPushAll(key2, Arrays.asList(4, 5, 6));
//将key中头部第一个移到key1中的头部
operations.move(ListOperations.MoveFrom.fromHead(key1), ListOperations.MoveTo.toHead(key2));
//list1=> 3 2 1 => 2 1 list2 => 6 5 4 => 3 6 5 4
String key3 = "list3";
operations.leftPushAll(key3, Arrays.asList("ss", "hhh", "dsfs", "hhh", "23", "hhh"));
//从左边开始删除前两个hhh
operations.remove(key3, 2, "hhh");
String key4 = "list4";
operations.leftPushAll(key4, Arrays.asList("11", "22", "33", "44"));
//截取list4,只取索引1-3的数据
operations.trim(key4, 1, 3);
List range1 = operations.range(key4, 0, -1);
System.out.println(range1);//[ 33,22,11]
String key5 = "list5";
operations.leftPushAll(key5, Arrays.asList("11", "22", "33", "44"));
//更新
operations.set(key5, 2, "222");
List range2 = operations.range(key5, 0, -1);
System.out.println(range2);//[44, 33, 222, 11]
}
取值
@Test
void testListPop() {
String key6 = "list6";
ListOperations operations = redisTemplate.opsForList();
operations.leftPushAll(key6, Arrays.asList(1, 2, 3, 4, 5));
//获取指定索引的数据
Object value = operations.index(key6, 2);
System.out.println(value);
//获取指定索引范围的数据 end为-1时是查询start后面的所有数据
List range = operations.range(key6, 0, 3);
System.out.println(range);
//获取指定值的索引
Long index = operations.indexOf(key6, 3);
System.out.println(index);
//获取指定值在集合中的最后一个索引位置
Long lastIndex = operations.lastIndexOf(key6, 3);
System.out.println(lastIndex);
//从左边取集合移除并返回第一个元素
Object o = operations.leftPop(key6);
//从集合左边移除并返回3个元素
List list = operations.leftPop(key6, 3);
//去集合中取元素，最多等待十秒钟，如果取不到就返回
Object o1 = operations.leftPop(key6, 10, TimeUnit.SECONDS);
System.out.println(o1);
String key7 = "list7";
//从list6中移除右边第一个元素到list7中的左边第一个位置，最多等待十秒钟
operations.rightPopAndLeftPush(key6, key7, 10, TimeUnit.SECONDS);
}
set操作
@Test
void testSet() {
SetOperations operations = redisTemplate.opsForSet();
String key = "set";
//向集合set中添加元素
operations.add(key,11,22,33);
String key1 = "set1";
//向集合set中添加元素
operations.add(key1,44,33,55);
//取第一个元素
Object pop = operations.pop(key);
System.out.println(pop);
//去前两个元素
List pop1 = operations.pop(key, 2);
//取两个集合的并集
Set union = operations.union(Arrays.asList(key,key1));
System.out.println(union);
String key2="set2";
//将两个集合的并集存储到另一个集合中
operations.unionAndStore(Arrays.asList(key,key1),key2);
//取所有集合的并集
Set union1 = operations.union(key, Arrays.asList(key1, key2));
//取集合的交集
Set intersect = operations.intersect(Arrays.asList(key, key1, key2));
String key3="set3";
//将集合的交集存到另一个集合中
operations.intersectAndStore(key,Arrays.asList(key1,key2),key3);
//获取集合的差集
Set difference = operations.difference(Arrays.asList(key, key1, key2));
//将集合的差集存放到另一个集合中
operations.differenceAndStore(key, Arrays.asList(key1, key2), key3);
//判断1是不是key中的元素
Boolean member = operations.isMember(key, 1);
//判断元素是不是集合中的
Map member1 = operations.isMember(key, 1, 2, 3);
//从集合中随机获取不同的几个元素
Set set = operations.distinctRandomMembers(key, 3);
//从集合中随机获取可重复的元素
List list = operations.randomMembers(key, 2);
//将3从集合key中移到key1中
operations.move(key, 3, key1);
//查询值包含a的集合，每次查询两个 *是通配符
Cursor scan = operations.scan(key, ScanOptions.scanOptions().match("*a*").count(2).build());
while (scan.hasNext()){
Object next = scan.next();
System.out.println(next);
}
}zset操作
@Test
void testZSet(){
ZSetOperations operations = redisTemplate.opsForZSet();
String key="zSet";
// //查询新元素，分数是1，排序是按照分数排序的
operations.add(key,"value",1);
Set<ZSetOperations.TypedTuple> set = new HashSet<>();
set.add(new DefaultTypedTuple("value1",Double.valueOf(2)));
set.add(new DefaultTypedTuple("value2",Double.valueOf(3)));
set.add(new DefaultTypedTuple("value3",Double.valueOf(2)));
// //插入多个元素
operations.add(key,set);
//不存在就插入
operations.addIfAbsent(key,"aa",1);
//查询集合中索引0-2数据，如果end为-1就是查询start后面所有元素
Set range = operations.range(key, 0, 2);
//查询分数是0-100直接数据，如果max为-1就是查询所有数据
Set set = operations.rangeByScore(key, 0, 100);
//取分数位于0-100之间的从0个开始的100个数据
Set set1 = operations.rangeByScore(key, 0, 100, 0, 10);
//随机取10数据
List list = operations.randomMembers(key, 10);
//取分数位于0-100之间的从0个开始的100个数据
Set<ZSetOperations.TypedTuple> set2 = operations.rangeByScoreWithScores(key, 0, 100, 0, 10);
//查询分数是10-100之间数据
Set set3 = operations.rangeByLex(key, RedisZSetCommands.Range.range().gt(10).lt(100));
//给元素加分
operations.incrementScore(key,"value",1);
//根据值删除元素
operations.remove(key,1,2,3);
//删除数据
Long aLong = operations.removeRange(key, 0, 1);
// 交并差参考zet
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
