redis使用实例分析

魁首哥

作者

redis使用实例分析

这篇文章主要介绍“redis使用实例分析”，在日常操作中，相信很多人在redis使用实例分析问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”redis使用实例分析”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

第一part：原生jedis连接redis

首先我们为要先了解，我们在原先使用mysql的时候，用jdbc连接数据库。同理这里我们连接redis，就要使用jedis。

第一步：新建java项目，导包

新建java项目，导包

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.3.0</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.73</version></dependency>

第二步：打开redis服务，写方法

打开redis服务

新建一个测试类，写一个方法

publicclassPing{publicstaticvoidmain(String[]args){Jedisjedis=newJedis("127.0.0.1",6379);System.out.println("连接成功");//查看服务是否运行System.out.println("服务正在运行:"+jedis.ping());}}

证明连同了

第三步：简单操作

这里写一些简单的jedis对各种类型的操作

基本操作api

publicclassTestPassword{publicstaticvoidmain(String[]args){Jedisjedis=newJedis("127.0.0.1",6379);//验证密码，如果没有设置密码这段代码省略//jedis.auth("password");jedis.connect();//连接jedis.disconnect();//断开连接jedis.flushAll();//清空所有的key}}

对于key操作的命令

publicclassTestKey{publicstaticvoidmain(String[]args){Jedisjedis=newJedis("127.0.0.1",6379);System.out.println("清空数据："+jedis.flushDB());System.out.println("判断某个键是否在："+jedis.exists("username"));System.out.println("新增<'username','kuangshen'>的键值对："+jedis.set("username","kuangshen"));System.out.println("新增<'password','password'>的键值对："+jedis.set("password","password"));System.out.print("系统中所有的键如下：");Set<String>keys=jedis.keys("*");System.out.println(keys);System.out.println("删除键password:"+jedis.del("password"));System.out.println("判断键password是否存在："+jedis.exists("password"));System.out.println("查看键username所存储的值的类型："+jedis.type("username"));System.out.println("随机返回key空间的一个："+jedis.randomKey());System.out.println("重命名key："+jedis.rename("username","name"));System.out.println("取出改后的name："+jedis.get("name"));System.out.println("按索引查询："+jedis.select(0));System.out.println("删除当前选择数据库中的所key："+jedis.flushDB());System.out.println("返回当前数据库中key的数目："+jedis.dbSize());System.out.println("删除所有数据库中的所有key："+jedis.flushAll());}}

对String操作的命令

publicclassTestString{publicstaticvoidmain(String[]args){Jedisjedis=newJedis("127.0.0.1",6379);jedis.flushDB();System.out.println("===========增加数据===========");System.out.println(jedis.set("key1","value1"));System.out.println(jedis.set("key2","value2"));System.out.println(jedis.set("key3","value3"));System.out.println("删除键key2:"+jedis.del("key2"));System.out.println("获取键key2:"+jedis.get("key2"));System.out.println("修改key1:"+jedis.set("key1","value1Changed"));System.out.println("获取key1的值："+jedis.get("key1"));System.out.println("在key3后面加入值："+jedis.append("key3","End"));System.out.println("key3的值："+jedis.get("key3"));System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));System.out.println("删除多个键值对："+jedis.del("key01","key02"));System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));jedis.flushDB();System.out.println("===========新增键值对防止覆盖原先值==============");System.out.println(jedis.setnx("key1","value1"));System.out.println(jedis.setnx("key2","value2"));System.out.println(jedis.setnx("key2","value2-new"));System.out.println(jedis.get("key1"));System.out.println(jedis.get("key2"));System.out.println("===========新增键值对并设置有效时间=============");System.out.println(jedis.setex("key3",2,"value3"));System.out.println(jedis.get("key3"));try{TimeUnit.SECONDS.sleep(3);}catch(InterruptedExceptione){e.printStackTrace();}System.out.println(jedis.get("key3"));System.out.println("===========获取原值，更新为新值==========");System.out.println(jedis.getSet("key2","key2GetSet"));System.out.println(jedis.get("key2"));System.out.println("获得key2的值的字串："+jedis.getrange("key2",2,4));}}

事务操作

publicclassTestMulti{publicstaticvoidmain(String[]args){//创建客户端连接服务端，redis服务端需要被开启Jedisjedis=newJedis("127.0.0.1",6379);jedis.flushDB();JSONObjectjsonObject=newJSONObject();jsonObject.put("hello","world");jsonObject.put("name","java");//开启事务Transactionmulti=jedis.multi();Stringresult=jsonObject.toJSONString();try{//向redis存入一条数据multi.set("json",result);//再存入一条数据multi.set("json2",result);//这里引发了异常，用0作为被除数inti=100/0;//如果没有引发异常，执行进入队列的命令multi.exec();}catch(Exceptione){e.printStackTrace();//如果出现异常，回滚multi.discard();}finally{System.out.println(jedis.get("json"));System.out.println(jedis.get("json2"));//最终关闭客户端jedis.close();}}}

第二part：springboot整合redis

在SpringBoot中一般使用RedisTemplate提供的方法来操作Redis。
源码分析

@Bean@ConditionalOnMissingBean(name={"redisTemplate"})//我们可以自己定一个redisTemplate来替换这个默认的！publicRedisTemplate<Object,Object>redisTemplate(RedisConnectionFactoryredisConnectionFactory)throwsUnknownHostException{//默认的RedisTemplate没有过多的设置，redis对象都是需要序列化的//两个泛型都是Object，Object类型的，我们后续使用需要强制转换成<String,Object>RedisTemplate<Object,Object>template=newRedisTemplate();template.setConnectionFactory(redisConnectionFactory);returntemplate;}@Bean@ConditionalOnMissingBeanpublicStringRedisTemplatestringRedisTemplate(RedisConnectionFactoryredisConnectionFactory)throwsUnknownHostException{StringRedisTemplatetemplate=newStringRedisTemplate();template.setConnectionFactory(redisConnectionFactory);returntemplate;}

第一步：导入依赖

导入依赖

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>

第二步：yml文件配置

yml文件配置

spring.redis.host=127.0.0.1spring.redis.port=6379

第三步：测试

测试

@SpringBootTestclassRedis02SpringbootApplicationTests{@AutowiredprivateRedisTemplateredisTemplate;@TestvoidcontextLoads(){redisTemplate.opsForValue().set("mykey","我是大帅哥");System.out.println(redisTemplate.opsForValue().get("mykey"));}}

第四步：自定义RedisTemplate

通过开头的源码可以看出，SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是，这个RedisTemplate的泛型是<Object,Object>，写代码不方便，需要写好多类型转换的代码；我们需要一个泛型为<String,Object>形式RedisTemplate。并且，这个RedisTemplate没有设置数据存在Redis时，key及value的序列化方式。看到这个@ConditionalOnMissingBean注解后，就知道如果Spring容器中有了RedisTemplate对象了，这个自动配置的RedisTemplate不会实例化。因此我们可以直接自己写个配置类，配置RedisTemplate。
自定义RedisTemplate

@ConfigurationpublicclassRedisConfig{@BeanpublicRedisTemplate<String,Object>redisTemplate(RedisConnectionFactoryredisConnectionFactory)throwsUnknownHostException{RedisTemplate<String,Object>template=newRedisTemplate();template.setConnectionFactory(redisConnectionFactory);//序列化配置Jackson2JsonRedisSerializer<Object>objectJackson2JsonRedisSerializer=newJackson2JsonRedisSerializer(Object.class);ObjectMapperom=newObjectMapper();om.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);om.enableDefaultTyping();objectJackson2JsonRedisSerializer.setObjectMapper(om);StringRedisSerializerstringRedisSerializer=newStringRedisSerializer();template.setKeySerializer(stringRedisSerializer);template.setHashKeySerializer(stringRedisSerializer);template.setValueSerializer(objectJackson2JsonRedisSerializer);template.setHashValueSerializer(objectJackson2JsonRedisSerializer);template.afterPropertiesSet();returntemplate;}}

第五步：写一个工具类，便于操作

写一个Redis工具类（直接用RedisTemplate操作Redis，需要很多行代码，因此直接封装好一个RedisUtils，这样写代码更方便点。这个RedisUtils交给Spring容器实例化，使用时直接注解注入。）
这里是别人写的工具类，很全！！！

importorg.springframework.data.redis.connection.DataType;importorg.springframework.data.redis.core.Cursor;importorg.springframework.data.redis.core.ScanOptions;importorg.springframework.data.redis.core.StringRedisTemplate;importorg.springframework.data.redis.core.ZSetOperations.TypedTuple;importjava.util.Collection;importjava.util.Date;importjava.util.List;importjava.util.Map;importjava.util.Map.Entry;importjava.util.Set;importjava.util.concurrent.TimeUnit;/***Redis工具类*/publicclassRedisUtil{privateStringRedisTemplateredisTemplate;publicvoidsetRedisTemplate(StringRedisTemplateredisTemplate){this.redisTemplate=redisTemplate;}publicStringRedisTemplategetRedisTemplate(){returnthis.redisTemplate;}/**-------------------key相关操作---------------------*//***删除key**@paramkey*/publicvoiddelete(Stringkey){redisTemplate.delete(key);}/***批量删除key**@paramkeys*/publicvoiddelete(Collection<String>keys){redisTemplate.delete(keys);}/***序列化key**@paramkey*@return*/publicbyte[]dump(Stringkey){returnredisTemplate.dump(key);}/***是否存在key**@paramkey*@return*/publicBooleanhasKey(Stringkey){returnredisTemplate.hasKey(key);}/***设置过期时间**@paramkey*@paramtimeout*@paramunit*@return*/publicBooleanexpire(Stringkey,longtimeout,TimeUnitunit){returnredisTemplate.expire(key,timeout,unit);}/***设置过期时间**@paramkey*@paramdate*@return*/publicBooleanexpireAt(Stringkey,Datedate){returnredisTemplate.expireAt(key,date);}/***查找匹配的key**@parampattern*@return*/publicSet<String>keys(Stringpattern){returnredisTemplate.keys(pattern);}/***将当前数据库的key移动到给定的数据库db当中**@paramkey*@paramdbIndex*@return*/publicBooleanmove(Stringkey,intdbIndex){returnredisTemplate.move(key,dbIndex);}/***移除key的过期时间，key将持久保持**@paramkey*@return*/publicBooleanpersist(Stringkey){returnredisTemplate.persist(key);}/***返回key的剩余的过期时间**@paramkey*@paramunit*@return*/publicLonggetExpire(Stringkey,TimeUnitunit){returnredisTemplate.getExpire(key,unit);}/***返回key的剩余的过期时间**@paramkey*@return*/publicLonggetExpire(Stringkey){returnredisTemplate.getExpire(key);}/***从当前数据库中随机返回一个key**@return*/publicStringrandomKey(){returnredisTemplate.randomKey();}/***修改key的名称**@paramoldKey*@paramnewKey*/publicvoidrename(StringoldKey,StringnewKey){redisTemplate.rename(oldKey,newKey);}/***仅当newkey不存在时，将oldKey改名为newkey**@paramoldKey*@paramnewKey*@return*/publicBooleanrenameIfAbsent(StringoldKey,StringnewKey){returnredisTemplate.renameIfAbsent(oldKey,newKey);}/***返回key所储存的值的类型**@paramkey*@return*/publicDataTypetype(Stringkey){returnredisTemplate.type(key);}/**-------------------string相关操作---------------------*//***设置指定key的值*@paramkey*@paramvalue*/publicvoidset(Stringkey,Stringvalue){redisTemplate.opsForValue().set(key,value);}/***获取指定key的值*@paramkey*@return*/publicStringget(Stringkey){returnredisTemplate.opsForValue().get(key);}/***返回key中字符串值的子字符*@paramkey*@paramstart*@paramend*@return*/publicStringgetRange(Stringkey,longstart,longend){returnredisTemplate.opsForValue().get(key,start,end);}/***将给定key的值设为value，并返回key的旧值(oldvalue)**@paramkey*@paramvalue*@return*/publicStringgetAndSet(Stringkey,Stringvalue){returnredisTemplate.opsForValue().getAndSet(key,value);}/***对key所储存的字符串值，获取指定偏移量上的位(bit)**@paramkey*@paramoffset*@return*/publicBooleangetBit(Stringkey,longoffset){returnredisTemplate.opsForValue().getBit(key,offset);}/***批量获取**@paramkeys*@return*/publicList<String>multiGet(Collection<String>keys){returnredisTemplate.opsForValue().multiGet(keys);}/***设置ASCII码,字符串'a'的ASCII码是97,转为二进制是'01100001',此方法是将二进制第offset位值变为value**@paramkey位置*@paramvalue*值,true为1,false为0*@return*/publicbooleansetBit(Stringkey,longoffset,booleanvalue){returnredisTemplate.opsForValue().setBit(key,offset,value);}/***将值value关联到key，并将key的过期时间设为timeout**@paramkey*@paramvalue*@paramtimeout*过期时间*@paramunit*时间单位,天:TimeUnit.DAYS小时:TimeUnit.HOURS分钟:TimeUnit.MINUTES*秒:TimeUnit.SECONDS毫秒:TimeUnit.MILLISECONDS*/publicvoidsetEx(Stringkey,Stringvalue,longtimeout,TimeUnitunit){redisTemplate.opsForValue().set(key,value,timeout,unit);}/***只有在key不存在时设置key的值**@paramkey*@paramvalue*@return之前已经存在返回false,不存在返回true*/publicbooleansetIfAbsent(Stringkey,Stringvalue){returnredisTemplate.opsForValue().setIfAbsent(key,value);}/***用value参数覆写给定key所储存的字符串值，从偏移量offset开始**@paramkey*@paramvalue*@paramoffset*从指定位置开始覆写*/publicvoidsetRange(Stringkey,Stringvalue,longoffset){redisTemplate.opsForValue().set(key,value,offset);}/***获取字符串的长度**@paramkey*@return*/publicLongsize(Stringkey){returnredisTemplate.opsForValue().size(key);}/***批量添加**@parammaps*/publicvoidmultiSet(Map<String,String>maps){redisTemplate.opsForValue().multiSet(maps);}/***同时设置一个或多个key-value对，当且仅当所有给定key都不存在**@parammaps*@return之前已经存在返回false,不存在返回true*/publicbooleanmultiSetIfAbsent(Map<String,String>maps){returnredisTemplate.opsForValue().multiSetIfAbsent(maps);}/***增加(自增长),负数则为自减**@paramkey*@return*/publicLongincrBy(Stringkey,longincrement){returnredisTemplate.opsForValue().increment(key,increment);}/****@paramkey*@return*/publicDoubleincrByFloat(Stringkey,doubleincrement){returnredisTemplate.opsForValue().increment(key,increment);}/***追加到末尾**@paramkey*@paramvalue*@return*/publicIntegerappend(Stringkey,Stringvalue){returnredisTemplate.opsForValue().append(key,value);}/**-------------------hash相关操作-------------------------*//***获取存储在哈希表中指定字段的值**@paramkey*@paramfield*@return*/publicObjecthGet(Stringkey,Stringfield){returnredisTemplate.opsForHash().get(key,field);}/***获取所有给定字段的值**@paramkey*@return*/publicMap<Object,Object>hGetAll(Stringkey){returnredisTemplate.opsForHash().entries(key);}/***获取所有给定字段的值**@paramkey*@paramfields*@return*/publicList<Object>hMultiGet(Stringkey,Collection<Object>fields){returnredisTemplate.opsForHash().multiGet(key,fields);}publicvoidhPut(Stringkey,StringhashKey,Stringvalue){redisTemplate.opsForHash().put(key,hashKey,value);}publicvoidhPutAll(Stringkey,Map<String,String>maps){redisTemplate.opsForHash().putAll(key,maps);}/***仅当hashKey不存在时才设置**@paramkey*@paramhashKey*@paramvalue*@return*/publicBooleanhPutIfAbsent(Stringkey,StringhashKey,Stringvalue){returnredisTemplate.opsForHash().putIfAbsent(key,hashKey,value);}/***删除一个或多个哈希表字段**@paramkey*@paramfields*@return*/publicLonghDelete(Stringkey,Object...fields){returnredisTemplate.opsForHash().delete(key,fields);}/***查看哈希表key中，指定的字段是否存在**@paramkey*@paramfield*@return*/publicbooleanhExists(Stringkey,Stringfield){returnredisTemplate.opsForHash().hasKey(key,field);}/***为哈希表key中的指定字段的整数值加上增量increment**@paramkey*@paramfield*@paramincrement*@return*/publicLonghIncrBy(Stringkey,Objectfield,longincrement){returnredisTemplate.opsForHash().increment(key,field,increment);}/***为哈希表key中的指定字段的整数值加上增量increment**@paramkey*@paramfield*@paramdelta*@return*/publicDoublehIncrByFloat(Stringkey,Objectfield,doubledelta){returnredisTemplate.opsForHash().increment(key,field,delta);}/***获取所有哈希表中的字段**@paramkey*@return*/publicSet<Object>hKeys(Stringkey){returnredisTemplate.opsForHash().keys(key);}/***获取哈希表中字段的数量**@paramkey*@return*/publicLonghSize(Stringkey){returnredisTemplate.opsForHash().size(key);}/***获取哈希表中所有值**@paramkey*@return*/publicList<Object>hValues(Stringkey){returnredisTemplate.opsForHash().values(key);}/***迭代哈希表中的键值对**@paramkey*@paramoptions*@return*/publicCursor<Entry<Object,Object>>hScan(Stringkey,ScanOptionsoptions){returnredisTemplate.opsForHash().scan(key,options);}/**------------------------list相关操作----------------------------*//***通过索引获取列表中的元素**@paramkey*@paramindex*@return*/publicStringlIndex(Stringkey,longindex){returnredisTemplate.opsForList().index(key,index);}/***获取列表指定范围内的元素**@paramkey*@paramstart*开始位置,0是开始位置*@paramend*结束位置,-1返回所有*@return*/publicList<String>lRange(Stringkey,longstart,longend){returnredisTemplate.opsForList().range(key,start,end);}/***存储在list头部**@paramkey*@paramvalue*@return*/publicLonglLeftPush(Stringkey,Stringvalue){returnredisTemplate.opsForList().leftPush(key,value);}/****@paramkey*@paramvalue*@return*/publicLonglLeftPushAll(Stringkey,String...value){returnredisTemplate.opsForList().leftPushAll(key,value);}/****@paramkey*@paramvalue*@return*/publicLonglLeftPushAll(Stringkey,Collection<String>value){returnredisTemplate.opsForList().leftPushAll(key,value);}/***当list存在的时候才加入**@paramkey*@paramvalue*@return*/publicLonglLeftPushIfPresent(Stringkey,Stringvalue){returnredisTemplate.opsForList().leftPushIfPresent(key,value);}/***如果pivot存在,再pivot前面添加**@paramkey*@parampivot*@paramvalue*@return*/publicLonglLeftPush(Stringkey,Stringpivot,Stringvalue){returnredisTemplate.opsForList().leftPush(key,pivot,value);}/****@paramkey*@paramvalue*@return*/publicLonglRightPush(Stringkey,Stringvalue){returnredisTemplate.opsForList().rightPush(key,value);}/****@paramkey*@paramvalue*@return*/publicLonglRightPushAll(Stringkey,String...value){returnredisTemplate.opsForList().rightPushAll(key,value);}/****@paramkey*@paramvalue*@return*/publicLonglRightPushAll(Stringkey,Collection<String>value){returnredisTemplate.opsForList().rightPushAll(key,value);}/***为已存在的列表添加值**@paramkey*@paramvalue*@return*/publicLonglRightPushIfPresent(Stringkey,Stringvalue){returnredisTemplate.opsForList().rightPushIfPresent(key,value);}/***在pivot元素的右边添加值**@paramkey*@parampivot*@paramvalue*@return*/publicLonglRightPush(Stringkey,Stringpivot,Stringvalue){returnredisTemplate.opsForList().rightPush(key,pivot,value);}/***通过索引设置列表元素的值**@paramkey*@paramindex*位置*@paramvalue*/publicvoidlSet(Stringkey,longindex,Stringvalue){redisTemplate.opsForList().set(key,index,value);}/***移出并获取列表的第一个元素**@paramkey*@return删除的元素*/publicStringlLeftPop(Stringkey){returnredisTemplate.opsForList().leftPop(key);}/***移出并获取列表的第一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止**@paramkey*@paramtimeout*等待时间*@paramunit*时间单位*@return*/publicStringlBLeftPop(Stringkey,longtimeout,TimeUnitunit){returnredisTemplate.opsForList().leftPop(key,timeout,unit);}/***移除并获取列表最后一个元素**@paramkey*@return删除的元素*/publicStringlRightPop(Stringkey){returnredisTemplate.opsForList().rightPop(key);}/***移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止**@paramkey*@paramtimeout*等待时间*@paramunit*时间单位*@return*/publicStringlBRightPop(Stringkey,longtimeout,TimeUnitunit){returnredisTemplate.opsForList().rightPop(key,timeout,unit);}/***移除列表的最后一个元素，并将该元素添加到另一个列表并返回**@paramsourceKey*@paramdestinationKey*@return*/publicStringlRightPopAndLeftPush(StringsourceKey,StringdestinationKey){returnredisTemplate.opsForList().rightPopAndLeftPush(sourceKey,destinationKey);}/***从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它；如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止**@paramsourceKey*@paramdestinationKey*@paramtimeout*@paramunit*@return*/publicStringlBRightPopAndLeftPush(StringsourceKey,StringdestinationKey,longtimeout,TimeUnitunit){returnredisTemplate.opsForList().rightPopAndLeftPush(sourceKey,destinationKey,timeout,unit);}/***删除集合中值等于value得元素**@paramkey*@paramindex*index=0,删除所有值等于value的元素;index>0,从头部开始删除第一个值等于value的元素;*index<0,从尾部开始删除第一个值等于value的元素;*@paramvalue*@return*/publicLonglRemove(Stringkey,longindex,Stringvalue){returnredisTemplate.opsForList().remove(key,index,value);}/***裁剪list**@paramkey*@paramstart*@paramend*/publicvoidlTrim(Stringkey,longstart,longend){redisTemplate.opsForList().trim(key,start,end);}/***获取列表长度**@paramkey*@return*/publicLonglLen(Stringkey){returnredisTemplate.opsForList().size(key);}/**--------------------set相关操作--------------------------*//***set添加元素**@paramkey*@paramvalues*@return*/publicLongsAdd(Stringkey,String...values){returnredisTemplate.opsForSet().add(key,values);}/***set移除元素**@paramkey*@paramvalues*@return*/publicLongsRemove(Stringkey,Object...values){returnredisTemplate.opsForSet().remove(key,values);}/***移除并返回集合的一个随机元素**@paramkey*@return*/publicStringsPop(Stringkey){returnredisTemplate.opsForSet().pop(key);}/***将元素value从一个集合移到另一个集合**@paramkey*@paramvalue*@paramdestKey*@return*/publicBooleansMove(Stringkey,Stringvalue,StringdestKey){returnredisTemplate.opsForSet().move(key,value,destKey);}/***获取集合的大小**@paramkey*@return*/publicLongsSize(Stringkey){returnredisTemplate.opsForSet().size(key);}/***判断集合是否包含value**@paramkey*@paramvalue*@return*/publicBooleansIsMember(Stringkey,Objectvalue){returnredisTemplate.opsForSet().isMember(key,value);}/***获取两个集合的交集**@paramkey*@paramotherKey*@return*/publicSet<String>sIntersect(Stringkey,StringotherKey){returnredisTemplate.opsForSet().intersect(key,otherKey);}/***获取key集合与多个集合的交集**@paramkey*@paramotherKeys*@return*/publicSet<String>sIntersect(Stringkey,Collection<String>otherKeys){returnredisTemplate.opsForSet().intersect(key,otherKeys);}/***key集合与otherKey集合的交集存储到destKey集合中**@paramkey*@paramotherKey*@paramdestKey*@return*/publicLongsIntersectAndStore(Stringkey,StringotherKey,StringdestKey){returnredisTemplate.opsForSet().intersectAndStore(key,otherKey,destKey);}/***key集合与多个集合的交集存储到destKey集合中**@paramkey*@paramotherKeys*@paramdestKey*@return*/publicLongsIntersectAndStore(Stringkey,Collection<String>otherKeys,StringdestKey){returnredisTemplate.opsForSet().intersectAndStore(key,otherKeys,destKey);}/***获取两个集合的并集**@paramkey*@paramotherKeys*@return*/publicSet<String>sUnion(Stringkey,StringotherKeys){returnredisTemplate.opsForSet().union(key,otherKeys);}/***获取key集合与多个集合的并集**@paramkey*@paramotherKeys*@return*/publicSet<String>sUnion(Stringkey,Collection<String>otherKeys){returnredisTemplate.opsForSet().union(key,otherKeys);}/***key集合与otherKey集合的并集存储到destKey中**@paramkey*@paramotherKey*@paramdestKey*@return*/publicLongsUnionAndStore(Stringkey,StringotherKey,StringdestKey){returnredisTemplate.opsForSet().unionAndStore(key,otherKey,destKey);}/***key集合与多个集合的并集存储到destKey中**@paramkey*@paramotherKeys*@paramdestKey*@return*/publicLongsUnionAndStore(Stringkey,Collection<String>otherKeys,StringdestKey){returnredisTemplate.opsForSet().unionAndStore(key,otherKeys,destKey);}/***获取两个集合的差集**@paramkey*@paramotherKey*@return*/publicSet<String>sDifference(Stringkey,StringotherKey){returnredisTemplate.opsForSet().difference(key,otherKey);}/***获取key集合与多个集合的差集**@paramkey*@paramotherKeys*@return*/publicSet<String>sDifference(Stringkey,Collection<String>otherKeys){returnredisTemplate.opsForSet().difference(key,otherKeys);}/***key集合与otherKey集合的差集存储到destKey中**@paramkey*@paramotherKey*@paramdestKey*@return*/publicLongsDifference(Stringkey,StringotherKey,StringdestKey){returnredisTemplate.opsForSet().differenceAndStore(key,otherKey,destKey);}/***key集合与多个集合的差集存储到destKey中**@paramkey*@paramotherKeys*@paramdestKey*@return*/publicLongsDifference(Stringkey,Collection<String>otherKeys,StringdestKey){returnredisTemplate.opsForSet().differenceAndStore(key,otherKeys,destKey);}/***获取集合所有元素**@paramkey*@return*/publicSet<String>setMembers(Stringkey){returnredisTemplate.opsForSet().members(key);}/***随机获取集合中的一个元素**@paramkey*@return*/publicStringsRandomMember(Stringkey){returnredisTemplate.opsForSet().randomMember(key);}/***随机获取集合中count个元素**@paramkey*@paramcount*@return*/publicList<String>sRandomMembers(Stringkey,longcount){returnredisTemplate.opsForSet().randomMembers(key,count);}/***随机获取集合中count个元素并且去除重复的**@paramkey*@paramcount*@return*/publicSet<String>sDistinctRandomMembers(Stringkey,longcount){returnredisTemplate.opsForSet().distinctRandomMembers(key,count);}/****@paramkey*@paramoptions*@return*/publicCursor<String>sScan(Stringkey,ScanOptionsoptions){returnredisTemplate.opsForSet().scan(key,options);}/**------------------zSet相关操作--------------------------------*//***添加元素,有序集合是按照元素的score值由小到大排列**@paramkey*@paramvalue*@paramscore*@return*/publicBooleanzAdd(Stringkey,Stringvalue,doublescore){returnredisTemplate.opsForZSet().add(key,value,score);}/****@paramkey*@paramvalues*@return*/publicLongzAdd(Stringkey,Set<TypedTuple<String>>values){returnredisTemplate.opsForZSet().add(key,values);}/****@paramkey*@paramvalues*@return*/publicLongzRemove(Stringkey,Object...values){returnredisTemplate.opsForZSet().remove(key,values);}/***增加元素的score值，并返回增加后的值**@paramkey*@paramvalue*@paramdelta*@return*/publicDoublezIncrementScore(Stringkey,Stringvalue,doubledelta){returnredisTemplate.opsForZSet().incrementScore(key,value,delta);}/***返回元素在集合的排名,有序集合是按照元素的score值由小到大排列**@paramkey*@paramvalue*@return0表示第一位*/publicLongzRank(Stringkey,Objectvalue){returnredisTemplate.opsForZSet().rank(key,value);}/***返回元素在集合的排名,按元素的score值由大到小排列**@paramkey*@paramvalue*@return*/publicLongzReverseRank(Stringkey,Objectvalue){returnredisTemplate.opsForZSet().reverseRank(key,value);}/***获取集合的元素,从小到大排序**@paramkey*@paramstart*开始位置*@paramend*结束位置,-1查询所有*@return*/publicSet<String>zRange(Stringkey,longstart,longend){returnredisTemplate.opsForZSet().range(key,start,end);}/***获取集合元素,并且把score值也获取**@paramkey*@paramstart*@paramend*@return*/publicSet<TypedTuple<String>>zRangeWithScores(Stringkey,longstart,longend){returnredisTemplate.opsForZSet().rangeWithScores(key,start,end);}/***根据Score值查询集合元素**@paramkey*@parammin*最小值*@parammax*最大值*@return*/publicSet<String>zRangeByScore(Stringkey,doublemin,doublemax){returnredisTemplate.opsForZSet().rangeByScore(key,min,max);}/***根据Score值查询集合元素,从小到大排序**@paramkey*@parammin*最小值*@parammax*最大值*@return*/publicSet<TypedTuple<String>>zRangeByScoreWithScores(Stringkey,doublemin,doublemax){returnredisTemplate.opsForZSet().rangeByScoreWithScores(key,min,max);}/****@paramkey*@parammin*@parammax*@paramstart*@paramend*@return*/publicSet<TypedTuple<String>>zRangeByScoreWithScores(Stringkey,doublemin,doublemax,longstart,longend){returnredisTemplate.opsForZSet().rangeByScoreWithScores(key,min,max,start,end);}/***获取集合的元素,从大到小排序**@paramkey*@paramstart*@paramend*@return*/publicSet<String>zReverseRange(Stringkey,longstart,longend){returnredisTemplate.opsForZSet().reverseRange(key,start,end);}/***获取集合的元素,从大到小排序,并返回score值**@paramkey*@paramstart*@paramend*@return*/publicSet<TypedTuple<String>>zReverseRangeWithScores(Stringkey,longstart,longend){returnredisTemplate.opsForZSet().reverseRangeWithScores(key,start,end);}/***根据Score值查询集合元素,从大到小排序**@paramkey*@parammin*@parammax*@return*/publicSet<String>zReverseRangeByScore(Stringkey,doublemin,doublemax){returnredisTemplate.opsForZSet().reverseRangeByScore(key,min,max);}/***根据Score值查询集合元素,从大到小排序**@paramkey*@parammin*@parammax*@return*/publicSet<TypedTuple<String>>zReverseRangeByScoreWithScores(Stringkey,doublemin,doublemax){returnredisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,min,max);}/****@paramkey*@parammin*@parammax*@paramstart*@paramend*@return*/publicSet<String>zReverseRangeByScore(Stringkey,doublemin,doublemax,longstart,longend){returnredisTemplate.opsForZSet().reverseRangeByScore(key,min,max,start,end);}/***根据score值获取集合元素数量**@paramkey*@parammin*@parammax*@return*/publicLongzCount(Stringkey,doublemin,doublemax){returnredisTemplate.opsForZSet().count(key,min,max);}/***获取集合大小**@paramkey*@return*/publicLongzSize(Stringkey){returnredisTemplate.opsForZSet().size(key);}/***获取集合大小**@paramkey*@return*/publicLongzZCard(Stringkey){returnredisTemplate.opsForZSet().zCard(key);}/***获取集合中value元素的score值**@paramkey*@paramvalue*@return*/publicDoublezScore(Stringkey,Objectvalue){returnredisTemplate.opsForZSet().score(key,value);}/***移除指定索引位置的成员**@paramkey*@paramstart*@paramend*@return*/publicLongzRemoveRange(Stringkey,longstart,longend){returnredisTemplate.opsForZSet().removeRange(key,start,end);}/***根据指定的score值的范围来移除成员**@paramkey*@parammin*@parammax*@return*/publicLongzRemoveRangeByScore(Stringkey,doublemin,doublemax){returnredisTemplate.opsForZSet().removeRangeByScore(key,min,max);}/***获取key和otherKey的并集并存储在destKey中**@paramkey*@paramotherKey*@paramdestKey*@return*/publicLongzUnionAndStore(Stringkey,StringotherKey,StringdestKey){returnredisTemplate.opsForZSet().unionAndStore(key,otherKey,destKey);}/****@paramkey*@paramotherKeys*@paramdestKey*@return*/publicLongzUnionAndStore(Stringkey,Collection<String>otherKeys,StringdestKey){returnredisTemplate.opsForZSet().unionAndStore(key,otherKeys,destKey);}/***交集**@paramkey*@paramotherKey*@paramdestKey*@return*/publicLongzIntersectAndStore(Stringkey,StringotherKey,StringdestKey){returnredisTemplate.opsForZSet().intersectAndStore(key,otherKey,destKey);}/***交集**@paramkey*@paramotherKeys*@paramdestKey*@return*/publicLongzIntersectAndStore(Stringkey,Collection<String>otherKeys,StringdestKey){returnredisTemplate.opsForZSet().intersectAndStore(key,otherKeys,destKey);}/****@paramkey*@paramoptions*@return*/publicCursor<TypedTuple<String>>zScan(Stringkey,ScanOptionsoptions){returnredisTemplate.opsForZSet().scan(key,options);}}

第六步：用工具类进行测试

测试

@SpringBootTestclassRedis02SpringbootApplicationTests{@AutowiredprivateRedisTemplateredisTemplate;@TestvoidcontextLoads(){redisUtil.set("mykey","我是大帅哥");System.out.println(redisUtil.get("mykey"));}}

第三part：实际项目使用redis+mysql

第一步：导包

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>

第二步：yml配置文件改变

在原来的mysql配置基础上，再加上redis的配置

spring:datasource:driver-class-name:com.mysql.jdbc.Driverurl:jdbc:mysql://localhost:3306/book?useSSL=falseusername:rootpassword:roottype:com.alibaba.druid.pool.DruidDataSourceredis:#Redis数据库索引（默认为0）database:0#host主机，默认为localhosthost:127.0.0.1#端口号,默认为6379port:6379#密码，默认为空password:#连接池jedis:pool:#连接池最大连接数（使用负值表示没有限制）max-active:8#连接池中的最小空闲连接min-idle:0#连接池中的最大空闲连接max-idle:8#连接池最大阻塞等待时间（使用负值表示没有限制）max-wait:-1#连接超时时间（毫秒）timeout:5000

第三步：序列化要传输的数据

第四步：编写redisconfig配置文件

RedisConfiguration（序列化，必须配置，不然会json格式在redis中缓存会乱码； Springboot1.x和2.x版本的序列化配置也不同，需要特别注意）

packagecom.hzf.config;importorg.springframework.cache.CacheManager;importorg.springframework.cache.annotation.CachingConfigurerSupport;importorg.springframework.cache.annotation.EnableCaching;importorg.springframework.cache.interceptor.KeyGenerator;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;importorg.springframework.data.redis.cache.RedisCacheManager;importorg.springframework.data.redis.connection.RedisConnectionFactory;importorg.springframework.data.redis.core.RedisTemplate;importorg.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;importorg.springframework.data.redis.serializer.JdkSerializationRedisSerializer;importorg.springframework.data.redis.serializer.StringRedisSerializer;importjava.lang.reflect.Method;@Configuration@EnableCachingpublicclassRedisConfigurationextendsCachingConfigurerSupport{/***缓存对象集合中，缓存是以key-value形式保存的。当不指定缓存的key时，SpringBoot会使用SimpleKeyGenerator生成key。*@return*/@BeanpublicKeyGeneratorkeyGenerator(){returnnewKeyGenerator(){@OverridepublicObjectgenerate(Objecttarget,Methodmethod,Object...params){StringBuildersb=newStringBuilder();sb.append(target.getClass().getName());sb.append(method.getName());for(Objectobj:params){sb.append(obj.toString());}returnsb.toString();}};}@BeanpublicCacheManagercacheManager(RedisConnectionFactoryconnectionFactory){RedisCacheManagerredisCacheManager=RedisCacheManager.builder(connectionFactory).build();returnredisCacheManager;}/***@return返回类型*@Description:防止redis入库序列化乱码的问题*/@BeanpublicRedisTemplate<Object,Object>redisTemplate(RedisConnectionFactoryredisConnectionFactory){RedisTemplate<Object,Object>redisTemplate=newRedisTemplate<Object,Object>();redisTemplate.setConnectionFactory(redisConnectionFactory);redisTemplate.setKeySerializer(newStringRedisSerializer());//key序列化redisTemplate.setValueSerializer(newJackson2JsonRedisSerializer(Object.class));//value序列化redisTemplate.setHashKeySerializer(newStringRedisSerializer());redisTemplate.setHashValueSerializer(newJdkSerializationRedisSerializer());redisTemplate.afterPropertiesSet();returnredisTemplate;}}

第五步：在我原有的项目controller中要使用缓存

注解	作用
@Cacheable	在方法执行前Spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；没有则调用方法并将方法返回值放进缓存。
@CachePut	将方法的返回值放到缓存中。
@CacheEvict	删除缓存中的数据。

我这里将我的controller层某个方法返回的数据，上加上@Cacheable注解，也就是我们在第一次查询后的数据将放入redis中，不会继续再走mysql查询了

关于@Cacheable注解的详解，看别的博主所写
https://blog.csdn.net/qq_31404603/article/details/88081039

//主页推荐书籍@Cacheable(value="recommendbooks")@RequestMapping(value="/recommendBook",method={RequestMethod.GET})publicServerResponserecommendBook(){System.out.println("第一次查询，会显示这个信息");bookService.updaterecommend();List<Book>books=bookService.recommendBook();if(books!=null){returnServerResponse.success("操作成功").data("recommendbooks",books);}returnServerResponse.error("操作失败");}

第五步：启动类上开启使用缓存

@EnableCaching 注解配置启用缓存

第六步：测试

启动项目，访问controller层的这个使用缓存的方法
网页显示的数据如下：

后端控制台显示：

之后不管怎么刷新请求，控制台不在输出那句话，且只查询了一次
想要看到redis里面是否已经存入，我们可以直接通过命令行的方式

keys*找到所有keygetkey查找某个数据

也可以通过可视化工具进行查看
看第四part

第四part：redis可视化工具

项目中用到了redis，想查询redis中的数据，一直想找一个可视化工具，今天发现了Redis Desktop Manager，试用了一下，很好用。

第一步：下载

Redis Desktop Manager是开源的，可以在github下载到源码。但是想在windows上用的话需要安装包。
官网下载：https://redisdesktop.com/download
github地址：https://github.com/uglide/RedisDesktopManager/releases
官网地址下载需要订阅，花钱的，还是算了吧。
晚上找到了一个免费下载的云盘：
百度网盘：http://pan.baidu.com/s/1kU8sY3P