hash
####hash####################################################
import com.csw.demoRedis.entity.User;
import com.google.gson.Gson;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 1)对象存储,HSET KEY_NAME FIELD VALUE或者HMSET KEY_NAME FIELD1 VALUE1 ...FIELDN VALUEN。
* <p>
* 比如购物车的实现
*/
@SpringBootTest
public class HashTest {
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 加入缓存
*/
@Test
public void test1() {
HashMap map = new HashMap();
map.put("aa", "aa");
map.put("user", new User("张三", 1, "好").toString());
map.put("int", "8");
stringRedisTemplate.opsForHash().putAll("AA-hash", map);
}
/**
* 获取一个key 的所有hashkey和value
*/
@Test
public void test2() {
Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("AA-hash");
for (Object o : entries.keySet()) {
System.out.print("键】" + o);
System.out.println("值】" + entries.get(o));
}
}
/**
* 验证指定key下面有没有hash key
*/
@Test
public void test3() {
Boolean aa = stringRedisTemplate.opsForHash().hasKey("AA-hash", "aa");
System.out.println("是否含有】" + aa);
}
/**
* 获取指定key 的value值
*/
@Test
public void test4() {
stringRedisTemplate.opsForHash().put("AA-hash", "userJson", new Gson().toJson(new User("张三", 1, "好")));
Object aa = stringRedisTemplate.opsForHash().get("AA-hash", "userJson");
User user = new Gson().fromJson((String) aa, User.class);
System.out.println("获取到的值为]" + user.getName());
int anInt = Integer.parseInt((String) stringRedisTemplate.opsForHash().get("AA-hash", "int"));
System.out.println("获取到整形的值为]" + anInt);
}
/**
* 删除指定hash 的hashkey并返回删除数量
*/
@Test
public void test5() {
Long delete = stringRedisTemplate.opsForHash().delete("AA-hash", "aa", "int");
System.out.println("删除的个数为]" + delete);
}
/**
* 指定hash 的hashkey做增减操作
* long 和double都可以
*/
@Test
public void test6() {
Double aa = stringRedisTemplate.opsForHash().increment("AA-hash", "aa", 1.0);
System.out.println("增加后的值】" + aa);
}
/**
* 获取key 下面的所有hashkey
*/
@Test
public void test7() {
Set<Object> keys = stringRedisTemplate.opsForHash().keys("AA-hash");
for (Object o : keys) {
System.out.println("hashkey】" + o);
}
List<Object> values = stringRedisTemplate.opsForHash().values("AA-hash");
System.out.println("values】" + values.toString());
}
/**
* 获取key 下面的所有hashkey键值对个数
*/
@Test
public void test8() {
Long size = stringRedisTemplate.opsForHash().size("AA-hash");
System.out.println("hashkey个数大小】" + size);
}
}
list
####list#####################################################
import com.csw.demoRedis.entity.User;
import com.google.gson.Gson;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* 常用的数据结构实现
* 消息流
*/
@SpringBootTest
public class ListTest {
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 测试左右添加
* 左添加
* 左1,左2,右3 结果213
*/
@Test
public void test1() {
List list = new ArrayList();
for (int i = 8; i < 10; i++) {
list.add(new User("名字" + i, i, "状态" + i));
}
stringRedisTemplate.opsForList().rightPush("AA-list", new Gson().toJson(list));
}
/**
* 获取指定位置的值
*/
@Test
public void test2() {
String index = stringRedisTemplate.opsForList().index("AA-list", 1);
System.out.println("值为】" + index);
}
/**
* 获取指定区间的值
*/
@Test
public void test3() {
List<String> range = stringRedisTemplate.opsForList().range("AA-list", 1, 2);
for (String str : range) {
System.out.println("zhi】" + str);
}
}
/**
* 将一个参数值放到另一个的前面
*/
@Test
public void test4() {
List list = new ArrayList();
for (int i = 8; i < 10; i++) {
list.add(new User("名字" + i, i, "状态" + i));
}
stringRedisTemplate.opsForList().leftPush("AA-list", new Gson().toJson(list), "放前面");
}
/**
* 测试左右批量添加
*/
@Test
public void test5() {
stringRedisTemplate.opsForList().leftPushAll("AA-list", "aa", "bb", "cc");
stringRedisTemplate.opsForList().rightPushAll("AA-list", "aa1", "bb1", "cc1");
}
/**
* 测试集合大小
*/
@Test
public void test6() {
Long size = stringRedisTemplate.opsForList().size("AA-list");
System.out.println("大小为】" + size);
}
/**
* 测试左移除,右移除
* 移除左边第一个元素
*/
@Test
public void tes7() {
stringRedisTemplate.opsForList().leftPop("AA-list");
}
/**
* 测试左移除,右移除
* 移除左边第一个元素,如果超过等待时间没有就退出
*/
@Test
public void tes8() {
stringRedisTemplate.opsForList().leftPop("AA-list", 1, TimeUnit.MINUTES);
}
/**
* 保留列表特定区间的元素
*/
@Test
public void tes9() {
stringRedisTemplate.opsForList().trim("AA-list", 2, 7);
}
}
set
####set#####################################################
import com.csw.demoRedis.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.List;
import java.util.Set;
/**
* 1)抽奖
* 2)点赞、收藏、标签
* 3)关注模型
*/
@SpringBootTest
class SetTest {
private static final String AA = "aa_set";
private static final String BB = "bb_set";
private static final String VALUE = "花好月圆的缘故都给我465dffgy";
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 将值放入set中
*/
@Test
public void test1() {
stringRedisTemplate.opsForSet().add(AA, BB);
}
/**
* 获取set中的值
*/
@Test
public void test2() {
stringRedisTemplate.opsForSet().add(AA, BB);
Set<String> members = stringRedisTemplate.opsForSet().members(AA);
for (String str : members) {
System.out.println("set中的值】" + str);
}
}
/**
* 随机获取变量中指定个数的元素
* 获取会出现重复
*/
@Test
public void test3() {
stringRedisTemplate.opsForSet().add(AA + "3", "aa", "bb", "cc", "dd", "ee");
//不会删除
List<String> members = stringRedisTemplate.opsForSet().randomMembers(AA + "3", 4);
//会删除
//stringRedisTemplate.opsForSet().pop("AA" + 3, 2);
for (String str : members) {
System.out.println("set中的值】" + str);
}
}
/**
* 随机获取变量的元素(一个)
*/
@Test
public void test4() {
stringRedisTemplate.opsForSet().add(AA + "3", "aa", "bb", "cc", "dd", "ee");
String member = stringRedisTemplate.opsForSet().randomMember(AA + "3");
System.out.println("set中的值】" + member);
}
/**
* 弹出变量中的元素(弹出之后相当于就删掉了)
*/
@Test
public void test5() {
String pop = stringRedisTemplate.opsForSet().pop(AA + "3");
System.out.println("弹出了】" + pop);
}
/**
* 获取变量中值的长度
*/
@Test
public void test6() {
Long size = stringRedisTemplate.opsForSet().size(AA + "3");
System.out.println("值的长度】" + size);
}
/**
* 判断value在某个key中是否存在
*/
@Test
public void test7() {
User user = new User("张三", 1, "好");
stringRedisTemplate.opsForSet().add(AA + "3", user.toString());
Boolean dd = stringRedisTemplate.opsForSet().isMember(AA + "3", user.toString());
System.out.println("是否存在】" + dd);
}
/**
* 判断是否转移成功
*/
@Test
public void test8() {
User user = new User("张三", 1, "好");
Boolean move = stringRedisTemplate.opsForSet().move(AA + 3, user.toString(), BB + 3);
System.out.println("是否转移成功】" + move);
}
/**
* 批量移除set中的元素
*/
@Test
public void test9() {
Long remove = stringRedisTemplate.opsForSet().remove(AA + 3, "aa", "bb", "cc", "dd", "ee");
System.out.println("成功移除了几个】" + remove);
}
/**
* 通过给定的key求差值
* 差值为】[cc]
* 交集为】[bb, aa]
* 合集为】[cc, bb, User(name=张三, id=1, status=好), aa]
*/
@Test
public void test10() {
User user = new User("张三", 1, "好");
stringRedisTemplate.opsForSet().add(BB + "3", "aa", "bb", user.toString());
stringRedisTemplate.opsForSet().add(AA + "3", "aa", "bb", "cc");
//左边有,右边没有的
Set<String> difference = stringRedisTemplate.opsForSet().difference(AA + 3, BB + 3);
System.out.println("差值为】" + difference.toString());
//求合集
Set<String> intersect = stringRedisTemplate.opsForSet().intersect(AA + 3, BB + 3);
System.out.println("交集为】" + intersect.toString());
//求合集
Set<String> union = stringRedisTemplate.opsForSet().union(AA + 3, BB + 3);
System.out.println("合集为】" + union.toString());
}
}
string
####string###################################################
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* 1)单值存储,相当于java的map;比如需要做密钥的缓存,set指令
* <p>
* 2)计数器,比如统计阅读数,incr指令
* <p>
* 3)分布式锁,分布式系统有一个问题是多机导致的同步锁问题,使用redis统一控制锁就简单多了。比如使用redisson获取写锁,注意过期时间的问题。set指令
* <p>
* 4)分库时批量申请全局序列号,INCRBY KEY_NAME INCR_AMOUNT指令
*/
@SpringBootTest
class StringTest {
private static final String AA = "aa";
private static final String BB = "bb";
private static final String VALUE = "花好月圆的缘故都给我465dffgy";
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* //设置一个key并设置过期时间
*/
@Test
public void test1() {
stringRedisTemplate.opsForValue().set(AA, VALUE, 1, TimeUnit.MINUTES);
}
/**
* //设置一个key(可设置可不设置,建议同时设置),随后设置过期时间
*/
@Test
public void test2() {
stringRedisTemplate.opsForValue().set(BB, VALUE);
stringRedisTemplate.expire(AA, 1, TimeUnit.MINUTES);
}
/**
* //查看一个key剩余过期时间,如果是永不失效就重新设置过期时间
*/
@Test
public void test3() {
Long expireTime = stringRedisTemplate.getExpire(BB, TimeUnit.MINUTES);
System.out.println("剩余过期时间】" + expireTime);
if (expireTime == -1) {
stringRedisTemplate.expire(BB, 1, TimeUnit.MINUTES);
}
}
/**
* //判断一个key是否存在
*/
@Test
public void test4() {
Boolean aBoolean = stringRedisTemplate.hasKey(AA);
System.out.println("key存在吗】" + aBoolean);
}
/**
* //移除指定key的过期时间
*/
@Test
public void test5() {
stringRedisTemplate.opsForValue().set(AA, VALUE, 1, TimeUnit.MINUTES);
stringRedisTemplate.boundValueOps(AA).persist();
}
/**
* 根据key获取值
*/
@Test
public void test6() {
stringRedisTemplate.opsForValue().set(AA, VALUE, 1, TimeUnit.MINUTES);
//不存在aa则为null
String aa = stringRedisTemplate.opsForValue().get(BB);
System.out.println("获取到的值为】" + aa);
}
/**
* 批量添加key
*/
@Test
public void test7() {
Map map = new HashMap();
map.put("aa", "aa1");
map.put("bb", VALUE);
map.put("啊哈", VALUE);
stringRedisTemplate.opsForValue().multiSet(map);
}
/**
* 批量添加key,只有当map中的key都不存在时
*/
@Test
public void test8() {
Map map = new HashMap();
map.put("aa1", "aa1");
map.put("bb1", VALUE);
map.put("啊哈1", VALUE);
stringRedisTemplate.opsForValue().multiSetIfAbsent(map);
}
/**
* 对一个 key-value 的值进行加减操作,
* 如果该 key 不存在 将创建一个key 并赋值该 number
* 如果 key 存在,但 value 不是长整型 ,将报错
*/
@Test
public void test9() {
//每次加1
stringRedisTemplate.opsForValue().increment(BB);
//每次加10
stringRedisTemplate.opsForValue().increment(AA, 10);
stringRedisTemplate.opsForValue().decrement(AA, 1);
}
}
zset
####zset####################################################
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import java.util.Set;
/**
* 1)有序的点赞,时间戳作为分值
* <p>
* 2) 排行榜
*/
@SpringBootTest
public class ZsetTest {
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 添加元素
*/
@Test
public void test1() {
stringRedisTemplate.opsForZSet().add("AA-zset", "aa", 9);
stringRedisTemplate.opsForZSet().add("AA-zset", "bb", 4);
stringRedisTemplate.opsForZSet().add("AA-zset", "cc", -3);
stringRedisTemplate.opsForZSet().add("AA-zset", "dd", 28);
stringRedisTemplate.opsForZSet().add("AA-zset", "ee", 5);
}
/**
* 返回元素的个数
*/
@Test
public void test2() {
Long size = stringRedisTemplate.opsForZSet().size("AA-zset");
System.out.println("元素的个数为】" + size);
}
/**
* 升序,降序返回键值
* 升序】[cc, bb, ee, aa, dd]
* 降序】[dd, aa, ee, bb, cc]
*/
@Test
public void test3() {
Set<String> range = stringRedisTemplate.opsForZSet().range("AA-zset", 0, -1);
System.out.println("升序】" + range.toString());
Set<String> strings = stringRedisTemplate.opsForZSet().reverseRange("AA-zset", 0, -1);
System.out.println("降序】" + strings.toString());
}
/**
* 按照分数查询一个范围内的元素,返回默认升序
* 按照分数范围查询】[bb, ee, aa]
*/
@Test
public void test4() {
Set<String> range = stringRedisTemplate.opsForZSet().rangeByScore("AA-zset", 0, 10);
System.out.println("按照分数范围查询】" + range.toString());
}
/**
* 返回排名
* 排名是】3
* 倒叙排名是】1
*/
@Test
public void test5() {
Long aa = stringRedisTemplate.opsForZSet().rank("AA-zset", "aa");
System.out.println("排名是】" + aa);
Long aa1 = stringRedisTemplate.opsForZSet().reverseRank("AA-zset", "aa");
System.out.println("倒叙排名是】" + aa1);
}
/**
* 显示一个元素的分数
*/
@Test
public void test6() {
Double aa = stringRedisTemplate.opsForZSet().score("AA-zset", "aa");
System.out.println("分数是】" + aa);
}
/**
* 移除某一个元素
*/
@Test
public void test7() {
stringRedisTemplate.opsForZSet().remove("AA-zset", "bb");
}
/**
* 给一个特定的元素加分,不存在就会创建
*/
@Test
public void test8() {
stringRedisTemplate.opsForZSet().incrementScore("AA-zset", "bb", 1);
}
}
redis事务/原子性操作https://www.jianshu.com/p/460d952937c1