一.在SpringBoot中配置和使用Redis
1.在SpringBoot中配置Redis
创基金一个maven项目，在配置文件中加入redis配置，
redis:
#database:9
host: 127.0.0.1
port: 6379
password:
database: 0
pool:
max-idle: 8
min-idle: 0
max-active: 8
max-wait: -1
2.在pom文件中引入redis依赖
以下是核心代码
二.操作Redis数据类型
常用的redis数据类型（字符串，散列，列表，集合，有序集合），主要从RedisTemplate的角度，因为在大部分的场景下，并不需要很复杂的操作redis，仅仅是很简单的使用而已，也就是只要操作一次redis.
/**
* 操作redis字符串和散列数据类型
* @return
*/
@RequestMapping("/stringAndHash")
@ResponseBody
public List testStringAndHash(){
redisTemplate.opsForValue().set("key1", "value1");
//这里使用了redis的反序列化器，所以redis保存时不时整数，不能运算
redisTemplate.opsForValue().set("int_key", "1");
stringRedisTemplate.opsForValue().set("int", "1");
//使用运算
stringRedisTemplate.opsForValue().increment("int", 5);
System.out.println(stringRedisTemplate.opsForValue().get("int"));
//获取底层Jredis链接
Jedis jedis = (Jedis) stringRedisTemplate.getConnectionFactory().getConnection().getNativeConnection();
//减一操作，这个命令redisTemplate不支持，所以我先获取底层链接再操作
jedis.decr("int");
System.out.println(stringRedisTemplate.opsForValue().get("int"));
Map<String,String> hash = new HashMap<String,String>();
hash.put("field1", "value1");
hash.put("field2", "value2");
//存入一个散列数据类型
stringRedisTemplate.opsForHash().putAll("hash", hash);
//新增一个字段
stringRedisTemplate.opsForHash().put("hash", "field3", "value3" );
//绑定散列操作key,这样可以连续对同一个散列数据类型进行操作
BoundHashOperations hashOps = stringRedisTemplate.boundHashOps("hash");
//删除俩个字段
hashOps.delete("field1","field2");
hashOps.put("field4", "value4");
List<String> list = jedis.hmget("hash", "field1","field2","field3","field4","field5");
//https://www.cnblogs.com/lltse/p/5113886.htmlv
System.out.println(list);
return list;
}
要注意的是“int_key”存入到redis服务器中，因为采用了JDK序列化器，所以在redis服务器中它不是整数，而是一个被JDK序列化器序列化后的二进制字符串，是没有办法是用redis命令进行运算的，如果非要进行加减运算操作，这里我们使用了Jedis对象，用他来做减一运算。
/**
* 使用spring操作列表（链表）
* @return
*/
@RequestMapping("/list")
@ResponseBody
public Map<String,Object> testList(){
//插入一个列表
stringRedisTemplate.opsForList().leftPushAll("list", "v1","v2","v3","v4","v5");
//绑定list链表操作
BoundListOperations listOps = stringRedisTemplate.boundListOps("list");
//从右边弹出一个成员
Object result1 = listOps.rightPop();
Object result2 = listOps.index(1);
//从左边插入链表
listOps.leftPush("v0");
//求链表长度
Long size = listOps.size();
//求链表下标区间成员
List elements = listOps.range(0, size-1);
Map<String,Object> map = new HashMap<String,Object>();
map.put("success", true);
return map;
}
上诉操作都是基于stringRedisTemplate的，所以保存到redis服务器的都是字符串类型，需要注意的问题是顺序问题，在redis中下标是从0开始的。
/**
* 使用spring操作集合
* @return
*/
@RequestMapping("/set")
@ResponseBody
public Map<String,Object> testSet(){
stringRedisTemplate.opsForSet().add("set1", "v1","v1","v2","v3","v4","v5");
stringRedisTemplate.opsForSet().add("set2", "v2","v4","v6","v8");
//绑定set1集合操作
BoundSetOperations setOps = stringRedisTemplate.boundSetOps("set1");
//添加俩个元素
setOps.add("v6","v7");
//删除俩个元素
setOps.remove("v1","v7");
//返回所有元素
Set set1 = setOps.members();
//求成员数
Long size = setOps.size();
//求交集
Set inter = setOps.intersect("set2");
//求交集，并使用新集合inter保存
setOps.intersectAndStore("set2", "inter");
//求差集
Set diff = setOps.diff("set2");
//求差集，并使用新集合diff保存
setOps.diffAndStore("set2", "diff");
//求并集
Set union = setOps.union("set2");
//求并集，并使用新集合union保存
setOps.unionAndStore("set2", "union");
Map<String,Object> map = new HashMap<String,Object>();
map.put("success", true);
return map;
}
这里添加set1时，存在俩个v1一样的元素，因为集合不允许重复，所以实际上集合只算是一个元素，然后可以对集合进行操作，交，差，并集。
/**
* 操作redis有序集合
* @return
*/
@RequestMapping("/zset")
@ResponseBody
public Map<String,Object> testZset(){
Set<TypedTuple<String>> typedTupleSet = new HashSet();
for (int i = 1; i <=9; i++) {
//分数
double score = i*0.1;
//创建一个TypedTuple对象，存入值和分数
TypedTuple<String> typedTuple = new DefaultTypedTuple<String>("value" + i, score);
typedTupleSet.add(typedTuple);
}
//往有序集合里面插入元素
stringRedisTemplate.opsForZSet().add("value", typedTupleSet);
//绑定zset有序集合操作
BoundZSetOperations<String,String> zsetOps = stringRedisTemplate.boundZSetOps("zset1");
//增加一个元素
zsetOps.add("value10", 0.26);
Set<String> setRange = zsetOps.range(1, 6);
//按分数排序，获取有序集合
Set<String> setScore = zsetOps.rangeByScore(0.2, 0.6);
//定义值范围
Range range = new Range();
range.gt("value3");//大于value3
//range.gte("value3");//大于等于value3
//range.lt("value8");//小于value3
range.lte("value8");//小于等于value3
//按值排序，根据字符串排序
Set<String> setLex = zsetOps.rangeByLex(range);
//删除元素
zsetOps.remove("value9","value2");
//求分数
Double score = zsetOps.score("value8");
//在下标区间下，按分数排序，同时返回value和score
Set<TypedTuple<String>> rangeSet = zsetOps.rangeWithScores(1, 6);
//在分数区间下，按分数排序，同时返回value和score
Set<TypedTuple<String>> csoreSet = zsetOps.rangeByScoreWithScores(1, 6);
//按从大到小排序
Set<String> reverseSet = zsetOps.reverseRange(2, 8);
Map<String,Object> map = new HashMap<String,Object>();
map.put("success", true);
return map;
}
代码中使用了TypedTuple保存有续集合元素，在默认情况下，有序集合是从小到大的顺序的，按下标，分数，和值进行排序获取有序集合元素，或者连同分数一起返回，有时候还可以进行从大到小的排序，只是在使用值排序时，我们可以用Spring为我们创建的Range类，定义范围。