redisTemplate中String,Hash,List,Set,zSet的方法及部分方法的使用

最新推荐文章于 2024-08-28 04:07:50 发布
最新推荐文章于 2024-08-28 04:07:50 发布
阅读量1.3k 收藏 8
点赞数 3
文章标签： list redis java 缓存 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71695227/article/details/130717809
版权

redisTemplate方法

String类型

String类型
redisTemplate.hasKey(key)判断是否有key所对应的值，有则返回true，没有则返回false
redisTemplate.opsForValue().get(key)有则取出key值所对应的值
redisTemplate.opsForValue().get(key, start, end)
redisTemplate.opsForValue().get(“stringkey”, 2, 3);		返回key中字符串的子字符
从开始截取到结束(包头包尾)
redisTemplate.opsForValue().size(key)获取字符串的长度
redisTemplate.opsForValue().set(key, value)设置当前的key以及value值
redisTemplate.opsForValue().set(key, value, timeout, unit)设置当前的key以及value值并且设置过期时间
unit : TimeUnit.MILLISECONDS(ms)
public List multiGet(Collection keys) {
return redisTemplate.opsForValue().multiGet(keys);
}		批量获取值
参数 : 集合(list)
redisTemplate.opsForValue().set(“BBB”,“您的”,1);将key的值从下标1往后替换为新的value,key不存在相当于新增
redisTemplate.opsForValue().setIfAbsent(“key”, “1”);如果键不存在则新增,存在则不改变已经有的值。
redisTemplate.opsForValue().setIfPresent(“BBB”, “好的”);如果key存在则修改，key不存在不做任何操作
redisTemplate.opsForValue().append(key, value)在原有的值基础上新增字符串到末尾
redisTemplate.opsForValue().getAndSet(key, value)获取key对应的值，如果key存在则修改,不存在则新增
redisTemplate.delete(key)删除单个key值
redisTemplate.delete(keys)批量删除key
其中keys:Collection keys
redisTemplate.dump(key)将当前传入的key值序列化为byte[]类型
redisTemplate.expire(key, timeout, unit);

redisTemplate.expireAt(key, date);
设置过期时间
key : key
timeout : 数 (1000)
unit : TimeUnit.MILLISECONDS(ms)
key : key
date : 时间(new Date())

return : Boolean
redisTemplate.rename(oldKey, newKey);
修改redis中key的名称
redisTemplate.randomKey()从redis中随机取出一个key
public Set getPatternKey(String pattern) {
return redisTemplate.keys(pattern);
}		查找匹配的key值，返回一个Set集合类型
redisTemplate.type(key);
返回传入key所存储的值的类型
return : DataType
redisTemplate.renameIfAbsent(oldKey, newKey);如果旧值存在时，将旧值改为新值
return : Boolean
redisTemplate.getExpire(key);返回当前key所对应的剩余过期时间
return : Long
redisTemplate.getExpire(key, unit);
返回剩余过期时间并且指定时间单位
unit : TimeUnit.MILLISECONDS(ms)

return : Boolean
redisTemplate.persist(key);将key持久化保存
retutn : Boolean
public Boolean moveToDbIndex(String key, int dbIndex)
{
return redisTemplate.move(key, dbIndex);
}		将当前数据库的key移动到指定redis中数据库当中
public Double incrByDouble(String key, double inc) {
return redisTemplate.opsForValue().increment(key, inc);
}
获取值的方式必须是
redisTemplate.boundValueOps(personTimeKey).get(0,-1);		以增量的方式将double(long)值存储在变量中

通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）
redisTemplate.opsForValue().decrement(“AAA”,2);以指定递减量递减的方式将long值存储在变量中(value为其他类型时报错，Double也不行，只能为Long)，返回最新值
Map valueMap = new HashMap();
valueMap.put(“valueMap1”,“map1”);
valueMap.put(“valueMap2”,“map2”);
valueMap.put(“valueMap3”,“map3”);
redisTemplate.opsForValue().multiSet(valueMap);		设置map集合到redis
put key 对应 redis key
Map valueMap = new HashMap();
valueMap.put(“valueMap1”,“map1”);
valueMap.put(“valueMap2”,“map2”);
valueMap.put(“valueMap3”,“map3”);
redisTemplate.opsForValue().multiSetIfAbsent(valueMap);		如果对应的map集合名称不存在，则添加否则不做修改
3 个 key 在redis都不存在 新增
否则 不新增不修改
List list = new ArrayList();
list.add(“valueMap1”);
list.add(“valueMap2”);
list.add(“valueMap3”);
List valueList = redisTemplate.opsForValue().multiGet(list);		在使用multiGet获得相应的值

返回值List<泛型>
List list = mpService.list();
redisTemplate.opsForValue().set(“BBB”, JSON.toJSONString(list));		存入JSON字符串（对象集合）
对象和对象集合一定要转成JSON存放，容易解析
String bbb = (String) redisTemplate.opsForValue().get(“BBB”);
List mpEntities = JSON.parseArray(bbb, MPEntity.class);
System.out.println("mpEntities = " + mpEntities);		获取解析JSON字符串

Hash类型

Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。
Redis 中每个 hash 可以存储 2^32 - 1 键值对（40多亿）。

Hash类型
redisTemplate.opsForHash().get(key, field)获取变量中的指定map键是否有值,如果存在该map键则获取值，没有则返回null。
public List hValues(String key) {
return redisTemplate.opsForHash().values(key);
}		获取hash表中存在的所有的值
public Map<Object, Object> hGetAll(String key) {
return redisTemplate.opsForHash().entries(key);
}		获取变量中的键值对
redisTemplate.opsForHash().put(key, hashKey, value)新增hashMap值
public void hPutAll(String key, Map<String, String> maps) {
redisTemplate.opsForHash().putAll(key, maps);
}		以map集合的形式添加键值对(批量新增)
key : 可视为 大key
Map<String, String>
String : 小key
String : value
redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);仅当hashKey不存在时才设置
public Long hashDelete(String key, Object fields) {
return redisTemplate.opsForHash().delete(key, fields);
}		删除一个或者多个hash表字段
redisTemplate.opsForHash().hasKey(key, field);**查看hash表中指定字段是否存在
**return : boolean
public Long hashIncrBy(String key, Object field, long increment) {
return redisTemplate.opsForHash().increment(key, field, increment);
}		给哈希表key中的指定字段的整数值加上增量increment
以增量的方式将double(long)值存储在变量中

通过increment(K key, long delta)方法以增量方式存储long值（正值则自增，负值则自减）<b
redisTemplate.opsForHash().keys(key)获取所有hash表中字段
redisTemplate.opsForHash().size(key)获取hash表中字段的数量
redisTemplate.opsForHash().scan(key, ScanOptions.NONE);该方法是通过游标的方式获取键值对的，如何遍历完一次后，如果游标没有关闭，会导致连接会一直增长，连接数到达峰值后，则会停止工作。所以每次使用完游标后，都要对其进行关闭。

运用redisTemplate的哈希存储数据（少量数据）时，需要匹配key获取全部键值对时，可以使用 Cursor<Map.Entry<String, Object>> cursor = redisTemplate.opsForHash().scan(key, ScanOptions.NONE);方法。但是该方法执行次数达到一定量时，就会卡主，导致获取数据失败。

如果在配置redis时，配置了其连接池的大小，则会直接把异常抛出来，就不用debug定位找异常处了。

redis:
    database: 0                         #Redis数据库索引（默认为0）
    host:                     #Redis服务器地址
    port: 6379                          #Redis服务器连接端口
    password:           #Redis服务器连接密码（默认为空）
    pool:
      max-active: 8 # 连接池最大连接数（使用负值表示没有限制）
      max-wait: 1 # 连接池最大阻塞等待时间（使用负值表示没有限制）
      max-idle: 8 # 连接池中的最大空闲连接
      min-idle: 0 # 连接池中的最小空闲连接
    timeout: 3000                       #连接超时时间（毫秒）

List类型

List类型
redisTemplate.opsForList().index(key, index)通过索引获取列表中的元素
redisTemplate.opsForList().range(key, start, end)获取列表指定范围内的元素(start开始位置, 0是开始位置，end 结束位置, -1返回所有)
redisTemplate.opsForList().leftPush(key, value)存储在list的头部，即添加一个就把它放在最前面的索引处
redisTemplate.opsForList().leftPushAll(key, value)把多个值存入List中(value可以是多个值，也可以是一个Collection value)
redisTemplate.opsForList().leftPushAll(key, value)把多个值存入List中(value可以是多个值，也可以是一个Collection value)
redisTemplate.opsForList().leftPushIfPresent(key, value)List存在的时候再加入
redisTemplate.opsForList().leftPush(key, pivot, value)如果pivot处值存在则在pivot前面添加
redisTemplate.opsForList().rightPush(key, value)
redisTemplate.opsForList().rightPushAll(key, value)		按照先进先出的顺序来添加(value可以是多个值，或者是Collection var2)
redisTemplate.opsForList().rightPush(key, pivot, value)在pivot元素的右边添加值
redisTemplate.opsForList().set(key, index, value)设置指定索引处元素的值
redisTemplate.opsForList().leftPop(key)
redisTemplate.opsForList().leftPop(key, timeout, unit)		移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)
redisTemplate.opsForList().rightPop(key)
redisTemplate.opsForList().rightPop(key, timeout, unit)		移除并获取列表最后一个元素
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey)
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit)		从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边
redisTemplate.opsForList().remove(key, index, value)删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素)
redisTemplate.opsForList().trim(key, start, end)将List列表进行剪裁
redisTemplate.opsForList().size(key)获取当前key的List列表长度

Set类型

Set类型
redisTemplate.opsForSet().add(key, values)添加元素
redisTemplate.opsForSet().remove(key, values)移除元素(单个值、多个值)
redisTemplate.opsForSet().pop(key)删除并且返回一个随机的元素
redisTemplate.opsForSet().size(key)获取集合的大小
redisTemplate.opsForSet().isMember(key, value)判断集合是否包含value
redisTemplate.opsForSet().intersect(key, otherKey)获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)
redisTemplate.opsForSet().intersect(key, otherKeys)获取多个集合的交集(Collection var2)
redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)
redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)key集合与多个集合的交集存储到destKey无序集合中
redisTemplate.opsForSet().union(key, otherKeys)获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)
redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)
redisTemplate.opsForSet().difference(key, otherKeys)获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)
redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)差集存储到destKey中(otherKeys可以为单个值或者集合)
redisTemplate.opsForSet().randomMember(key)随机获取集合中的一个元素
redisTemplate.opsForSet().members(key)获取集合中的所有元素
redisTemplate.opsForSet().randomMembers(key, count)随机获取集合中count个元素
redisTemplate.opsForSet().distinctRandomMembers(key, count)获取多个key无序集合中的元素（去重），count表示个数
redisTemplate.opsForSet().scan(key, options)遍历set类似于Interator(ScanOptions.NONE为显示所有的)

zSet类型

ZSetOperations提供了一系列方法对有序集合进行操作

zSet类型
redisTemplate.opsForZSet().add(key, value, score)添加元素(有序集合是按照元素的score值由小到大进行排列)
redisTemplate.opsForZSet().remove(key, values)删除对应的value,value可以为多个值
redisTemplate.opsForZSet().incrementScore(key, value, delta)增加元素的score值，并返回增加后的值
redisTemplate.opsForZSet().rank(key, value)返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
redisTemplate.opsForZSet().reverseRank(key, value)返回元素在集合的排名,按元素的score值由大到小排列
redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)获取集合中给定区间的元素(start 开始位置，end 结束位置, -1查询所有)
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)

redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
//返回值为:Set<ZSetOperations.TypedTuple>		按照Score值查询集合中的元素，结果从小到大排序
redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)从高到低的排序集中获取分数在最小和最大值之间的元素
redisTemplate.opsForZSet().count(key, min, max)根据score值获取集合元素数量
redisTemplate.opsForZSet().size(key)
redisTemplate.opsForZSet().zCard(key)		获取集合的大小
redisTemplate.opsForZSet().score(key, value)获取集合中key、value元素对应的score值
redisTemplate.opsForZSet().removeRange(key, start, end)移除指定索引位置处的成员
redisTemplate.opsForZSet().removeRangeByScore(key, min, max)移除指定score范围的集合成员
redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)获取key和otherKey的并集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）
redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)获取key和otherKey的交集并存储在destKey中（其中otherKeys可以为单个字符串或者字符串集合）
Cursor<TypedTuple> scan = opsForZSet.scan(“test3”, ScanOptions.NONE);
while (scan.hasNext()){
ZSetOperations.TypedTuple item = scan.next();
System.out.println(item.getValue() + “:” + item.getScore());
}		遍历集合（和iterator一模一样）

常用方法

package com.itxs;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.ContextConfiguration;

@SpringBootTest
@ContextConfiguration(classes = RedisAutoConfiguration.class)//打开redis的自动装配
class SpringbootReidsDemo1ApplicationTests {
    //Spring和Reids整合完成后产生的模版工具RedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;

    //查看Redis数据库是否存在key
    @Test
    void redisIf(){
        UserBean user = new UserBean();
        String loginKey = "loginKey";
        //redisTemplate.hasKey() //判断是否存在
        if (redisTemplate.hasKey(loginKey)) {
            //存在 查 Redis 数据库
            user = (UserBean) redisTemplate.opsForValue().get(loginKey);
            System.out.println("------------>"+user);
        } else {
            //不存在 查 mysql 数据库
            QueryWrapper<UserBean> qw = new QueryWrapper<>();
            qw.eq("user_Nickname", userBean.getUserNickname());
            user = loginDao.selectOne(qw);
            //把查询的数据 添加到 Redis 数据库
            redisTemplate.opsForValue().set(loginKey, user);
        }
    }

    //新增后多少时间删除
    @Test
    void redisAddAfterDelete(){
        String loginKey = "loginKey";
        redisTemplate.opsForValue().set(loginKey,recruitmentBean,10, TimeUnit.SECONDS);
    }


    //删除缓存中的内容
    @Test
    void redisDelete(){
        //TimeUnit.DAYS 天
        //TimeUnit.HOURS 小时
        //TimeUnit.MINUTES 分钟
        //TimeUnit.SECONDS 秒
        //TimeUnit.MILLISECONDS 毫秒
        //TimeUnit.MICROSECONDS 微妙
        //TimeUnit.NANOSECONDS 纳秒

        //设置过期时间  MILLISECONDS 毫秒
        redisTemplate.expire("jk",1000, TimeUnit.MILLISECONDS);
        Boolean flag = redisTemplate.delete("mapKey");
        System.out.println(flag);
    }

    //String类型
    @Test
    void redisString() {
        //存String类型的数据
        String key = "name";
        redisTemplate.opsForValue().set(key,"zz");
        //取
        String name = (String) redisTemplate.opsForValue().get(key);
        System.out.println(name);
    }

    @Test
    void redisBean(){
        //存一个实体：前提是将实体进行序列化转换为字节流
        Store store = new Store();
        store.setStoreId(1);
        store.setStoreName("张铮生蚝店");
        store.setStoreInfo("2023-05-06");
        store.setStoreStatus(1);
        store.setStoreDetail("西安市长安区王寺街道");
        store.setStorePhone("15538573535");
        redisTemplate.opsForValue().set("sotreKey",store);
        Store sotreKey = (Store) redisTemplate.opsForValue().get("sotreKey");
        System.out.println(sotreKey.getStoreId());
        System.out.println(sotreKey.getStoreName());
        System.out.println(sotreKey.getStoreInfo());
        System.out.println(sotreKey.getStoreStatus());
        System.out.println(sotreKey.getStoreDetail());
        System.out.println(sotreKey.getStorePhone());
    }

    //List类型
    @Test
    void redisList(){
        //从左边第一个元素开始存 leftPush
        redisTemplate.opsForList().leftPush("myList",1);
        redisTemplate.opsForList().leftPush("myList","张铮生蚝店");
        redisTemplate.opsForList().leftPush("myList","2023-05-06");
        redisTemplate.opsForList().leftPush("myList",1);
        redisTemplate.opsForList().leftPush("myList","西安市长安区王寺街道");
        redisTemplate.opsForList().leftPush("myList","15538573535");
        //取
        //取所有的 结束-1
        List<Object> list = redisTemplate.opsForList().range("myList",0,-1);
        for (Object myObList:list) {
            System.out.println(myObList);
        }
    }

    //HashMap类型
    @Test
    void redisMap(){
        //哈希 opsForHash存 put 第一个参数 大key 第二个小Key 后面对应小key的值
        redisTemplate.opsForHash().put("myHashMapKey","storeId",1);
        redisTemplate.opsForHash().put("myHashMapKey","storeName","张铮生蚝店");
        redisTemplate.opsForHash().put("myHashMapKey","storeInfo","2023-05-06");
        redisTemplate.opsForHash().put("myHashMapKey","storeStatus",1);
        redisTemplate.opsForHash().put("myHashMapKey","storeDetail","西安市长安区王寺街道");
        redisTemplate.opsForHash().put("myHashMapKey","storePhone","15538573535");
        //取（取所有）
        List<Object> myHashMapKey = redisTemplate.opsForHash().values("myHashMapKey");
        for (Object myHashMapKeys : myHashMapKey
            ) {
            System.out.println(myHashMapKeys);
        }

        //直切存Map
        HashMap<Object, Object> map = new HashMap<>();
        map.put("total",1);
        map.put("rows",10);
        //存入reids
        redisTemplate.opsForHash().putAll("mapKey",map);
        //获取缓存内容
        System.out.println(redisTemplate.opsForHash().entries("mapKey"));
    }

    //zSet 类型 Set 是String类型是无序集合，集合成员是唯一的，这就意味着集合中不能出现重复的数据。
    @Test
    void redisSet(){
        //存入reids
        redisTemplate.opsForSet().add("mySet",1);
        redisTemplate.opsForSet().add("mySet","张铮");
        //取
        Set<Object> mySet = redisTemplate.opsForSet().members("mySet");
        for (Object set:mySet) {
            ///取缓存中的内容
            System.out.println(set);
        }
    }

    //set 类型 redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员
    @Test
    void rediszSet(){
        //存
        redisTemplate.opsForZSet().add("myKeyzSet","语文",80);
        redisTemplate.opsForZSet().add("myKeyzSet","数学",40);
        //区间查询
        Set myKeyzSet = redisTemplate.opsForZSet().rangeByScore("myKeyzSet", 50, 80);
        for (Object myKey:myKeyzSet
            ) {
            System.out.println(myKey);
        }
        //查所有
        Set myKeyzSet2 = redisTemplate.opsForZSet().range("myKeyzSet", 0, -1);
        for (Object myAllKey:myKeyzSet2
            ) {
            System.out.println(myAllKey);
        }
    }
}

使用 hash 写 增删改查

   package com.itxs;
   
   import org.junit.jupiter.api.Test;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
   import org.springframework.boot.test.context.SpringBootTest;
   import org.springframework.data.redis.core.RedisTemplate;
   import org.springframework.test.context.ContextConfiguration;
   
   @SpringBootTest
   @ContextConfiguration(classes = RedisAutoConfiguration.class)//打开redis的自动装配
   class SpringbootReidsDemo1ApplicationTests {
       //Spring和Reids整合完成后产生的模版工具RedisTemplate
       @Autowired
       private RedisTemplate redisTemplate;
   
       //查看Redis数据库是否存在key
       @Test
       void redisIf(){
           UserBean user = new UserBean();
           String loginKey = "loginKey";
           //redisTemplate.hasKey() //判断是否存在
           if (redisTemplate.hasKey(loginKey)) {
               //存在 查 Redis 数据库
               user = (UserBean) redisTemplate.opsForValue().get(loginKey);
               System.out.println("------------>"+user);
           } else {
               //不存在 查 mysql 数据库
               QueryWrapper<UserBean> qw = new QueryWrapper<>();
               qw.eq("user_Nickname", userBean.getUserNickname());
               user = loginDao.selectOne(qw);
               //把查询的数据 添加到 Redis 数据库
               redisTemplate.opsForValue().set(loginKey, user);
           }
       }
   
       //新增后多少时间删除
       @Test
       void redisAddAfterDelete(){
           String loginKey = "loginKey";
           redisTemplate.opsForValue().set(loginKey,recruitmentBean,10, TimeUnit.SECONDS);
       }
   
   
       //删除缓存中的内容
       @Test
       void redisDelete(){
           //TimeUnit.DAYS 天
           //TimeUnit.HOURS 小时
           //TimeUnit.MINUTES 分钟
           //TimeUnit.SECONDS 秒
           //TimeUnit.MILLISECONDS 毫秒
           //TimeUnit.MICROSECONDS 微妙
           //TimeUnit.NANOSECONDS 纳秒
   
           //设置过期时间  MILLISECONDS 毫秒
           redisTemplate.expire("jk",1000, TimeUnit.MILLISECONDS);
           Boolean flag = redisTemplate.delete("mapKey");
           System.out.println(flag);
       }
   
       //String类型
       @Test
       void redisString() {
           //存String类型的数据
           String key = "name";
           redisTemplate.opsForValue().set(key,"zz");
           //取
           String name = (String) redisTemplate.opsForValue().get(key);
           System.out.println(name);
       }
   
       @Test
       void redisBean(){
           //存一个实体：前提是将实体进行序列化转换为字节流
           Store store = new Store();
           store.setStoreId(1);
           store.setStoreName("张铮生蚝店");
           store.setStoreInfo("2023-05-06");
           store.setStoreStatus(1);
           store.setStoreDetail("西安市长安区王寺街道");
           store.setStorePhone("15538573535");
           redisTemplate.opsForValue().set("sotreKey",store);
           Store sotreKey = (Store) redisTemplate.opsForValue().get("sotreKey");
           System.out.println(sotreKey.getStoreId());
           System.out.println(sotreKey.getStoreName());
           System.out.println(sotreKey.getStoreInfo());
           System.out.println(sotreKey.getStoreStatus());
           System.out.println(sotreKey.getStoreDetail());
           System.out.println(sotreKey.getStorePhone());
       }
   
       //List类型
       @Test
       void redisList(){
           //从左边第一个元素开始存 leftPush
           redisTemplate.opsForList().leftPush("myList",1);
           redisTemplate.opsForList().leftPush("myList","张铮生蚝店");
           redisTemplate.opsForList().leftPush("myList","2023-05-06");
           redisTemplate.opsForList().leftPush("myList",1);
           redisTemplate.opsForList().leftPush("myList","西安市长安区王寺街道");
           redisTemplate.opsForList().leftPush("myList","15538573535");
           //取
           //取所有的 结束-1
           List<Object> list = redisTemplate.opsForList().range("myList",0,-1);
           for (Object myObList:list) {
               System.out.println(myObList);
           }
       }
   
       //HashMap类型
       @Test
       void redisMap(){
           //哈希 opsForHash存 put 第一个参数 大key 第二个小Key 后面对应小key的值
           redisTemplate.opsForHash().put("myHashMapKey","storeId",1);
           redisTemplate.opsForHash().put("myHashMapKey","storeName","张铮生蚝店");
           redisTemplate.opsForHash().put("myHashMapKey","storeInfo","2023-05-06");
           redisTemplate.opsForHash().put("myHashMapKey","storeStatus",1);
           redisTemplate.opsForHash().put("myHashMapKey","storeDetail","西安市长安区王寺街道");
           redisTemplate.opsForHash().put("myHashMapKey","storePhone","15538573535");
           //取（取所有）
           List<Object> myHashMapKey = redisTemplate.opsForHash().values("myHashMapKey");
           for (Object myHashMapKeys : myHashMapKey
               ) {
               System.out.println(myHashMapKeys);
           }
   
           //直切存Map
           HashMap<Object, Object> map = new HashMap<>();
           map.put("total",1);
           map.put("rows",10);
           //存入reids
           redisTemplate.opsForHash().putAll("mapKey",map);
           //获取缓存内容
           System.out.println(redisTemplate.opsForHash().entries("mapKey"));
       }
   
       //zSet 类型 Set 是String类型是无序集合，集合成员是唯一的，这就意味着集合中不能出现重复的数据。
       @Test
       void redisSet(){
           //存入reids
           redisTemplate.opsForSet().add("mySet",1);
           redisTemplate.opsForSet().add("mySet","张铮");
           //取
           Set<Object> mySet = redisTemplate.opsForSet().members("mySet");
           for (Object set:mySet) {
               ///取缓存中的内容
               System.out.println(set);
           }
       }
   
       //set 类型 redis 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员
       @Test
       void rediszSet(){
           //存
           redisTemplate.opsForZSet().add("myKeyzSet","语文",80);
           redisTemplate.opsForZSet().add("myKeyzSet","数学",40);
           //区间查询
           Set myKeyzSet = redisTemplate.opsForZSet().rangeByScore("myKeyzSet", 50, 80);
           for (Object myKey:myKeyzSet
               ) {
               System.out.println(myKey);
           }
           //查所有
           Set myKeyzSet2 = redisTemplate.opsForZSet().range("myKeyzSet", 0, -1);
           for (Object myAllKey:myKeyzSet2
               ) {
               System.out.println(myAllKey);
           }
       }
   }

使用 hash 写 增删改查

hash存储结构

在这里插入图片描述

mysql - 表
-- 用户表
DROP TABLE IF EXISTS `jk_user`;
CREATE TABLE `jk_user`  (
  `user_Id` int(0) NOT NULL,
  `user_Name` varchar(255) ,
  `User_nickname` varchar(255),
  `user_Password` varchar(255) ,
  PRIMARY KEY (`user_Id`) USING BTREE
) 

INSERT INTO `jk_user` VALUES (1, '张三', '张三', '123');
INSERT INTO `jk_user` VALUES (2, '李四', '李四', '123');
INSERT INTO `jk_user` VALUES (3, '王五', '王五', '123');


-- 银行卡
DROP TABLE IF EXISTS `bankcard_zz`;
CREATE TABLE `bankcard_zz`  (
  `card_id` int(0) NOT NULL AUTO_INCREMENT,
  `card_name` varchar(255) ,
  `card_number` int(0) ,
  `card_user` int(0) ,
  `card_time` datetime(0) ,
  PRIMARY KEY (`card_id`) USING BTREE
) 

INSERT INTO `bankcard_zz` VALUES (1, '橘猫银行', 11111111, 1, '2023-05-08 14:27:53');
INSERT INTO `bankcard_zz` VALUES (2, '橘猫银行', 22222222, 1, '2023-05-17 14:27:56');
INSERT INTO `bankcard_zz` VALUES (3, '橘猫银行', 33333333, 2, '2023-05-25 14:27:59');
INSERT INTO `bankcard_zz` VALUES (4, '橘猫银行', 44444444, 2, '2023-05-12 14:28:02');
INSERT INTO `bankcard_zz` VALUES (5, '橘猫银行', 55555555, 3, '2023-05-08 08:16:19');
INSERT INTO `bankcard_zz` VALUES (6, '橘猫银行', 66666666, 3, '2023-05-08 08:18:31');
INSERT INTO `bankcard_zz` VALUES (7, '橘猫银行', 77777777, 3, '2023-05-08 08:19:46');
封装Bean

bankcard_zz 表

@Data
@TableName("bankcard_zz")
public class BankcardBean implements Serializable {
    @TableId(value = "card_Id" , type = IdType.AUTO)
    private Integer cardId         ;//银行卡id
    @TableField("card_Name")
    private String  cardName       ;//银行名称
    @TableField("card_Number")
    private Integer cardNumber     ;//银行卡编号
    @TableField("card_User")
    private Integer cardUser       ;//用户id
    @TableField("card_Time")
    private String  cardTime       ;//创建时间

}

jk_user 表

@Data
@TableName("jk_user")
public class UserBean {
    @TableId(value = "user_Id" , type = IdType.AUTO)
    private Integer userId         ;//用户id
    @TableField("user_Name")
    private String  userName       ;//用户名称
    @TableField("user_Nickname")
    private String  userNickname   ;//用户昵称
    @TableField("user_Password")
    private String  userPassword   ;//用户密码
    
    //业务字段
    @TableField(exist = false , select = false)
    private String  code           ;//验证码
}
dao 层 持久层
package com.jk.zz.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jk.zz.pojo.BankcardBean;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface BankcardDao extends BaseMapper<BankcardBean> {

}
impl
package com.jk.zz.service.impl;

import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.jk.zz.dao.BankcardDao;
import com.jk.zz.pojo.BankcardBean;
import com.jk.zz.pojo.UserBean;
import com.jk.zz.service.BankcardService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


@Service
public class BankcardServiceImpl implements BankcardService {
    @Autowired
    private BankcardDao bankcardDao;
	
    
    @Autowired(required = false)
    private RedisTemplate redisTemplate;
	
    //公用的 大key
    public String bigKey = "bigKey";

	

}

@Autowired

required:

默认值为true 表示当注入的对象不存在时会报错。

设置为false时表示如果有直接注入，没有跳过，不会报错。

查询

设置一个 大key : public String bigKey = “bigKey”;

小key : 用户id

  1. 存在
  2. 通过 大key 小key 查询 内容
  3. 通过 json 格式 转换 保存到 list
  4. 不存在
  5. 通过 用户id 查询 数据 (当前登录的数据)
  6. redisTemplate.opsForHash().put(bigKey,userId,list); 存入 Redis 数据库
  7. 返回数据

在这里插入图片描述

@Override
public List<BankcardBean> queryBankcardList(HttpSession session) {
    //登录的用户
    UserBean user = (UserBean) session.getAttribute("sessionUser");
    //小key
    String userId = String.valueOf(user.getUserId());
    List<BankcardBean> list = new ArrayList<>();
    //判断 Redis 数据库是否存在 大key 小key 
    boolean ifKey = redisTemplate.opsForHash().hasKey(bigKey,userId);
    if (ifKey) {//存在
        List<Object> list1 = (List<Object>) redisTemplate.opsForHash().get(bigKey, userId);
        list = JSONArray.parseArray(JSONArray.toJSONString(list1),BankcardBean.class);
        System.out.println("我走了 Redis 查询 !!");
    }else {//不存在
        LambdaQueryWrapper<BankcardBean> lqw = new LambdaQueryWrapper<>();
        lqw.eq(BankcardBean :: getCardUser, user.getUserId());
        list = bankcardDao.selectList(lqw);
        redisTemplate.opsForHash().put(bigKey,userId,list);
    }

    return list;
}
新增/修改

大key : public String bigKey = “bigKey”;

小key : 用户id

  1. 存在 id 新增方法

  2. 判断 大key 小key 是否存在

    1. 存在

      1. 通过 大key 小key 查询 内容
      2. 查询内容 拼接 新增内容
      3. 重新赋值 (覆盖)
        在这里插入图片描述
 2. 不存在

   1. 添加 大key 小key 数据

  1. 不存在 id 修改方法

  2. 通过 条件 修改

  3. 删除 (查找 大key 的 小key , 根据 小key 删除数据)

在这里插入图片描述

执行删除后 , 方法执行成功 , 前端回调刷新页面方法

@Override
public void addBankcard(BankcardBean bankcardBean, HttpSession session) {
    //登录的用户
    UserBean user = (UserBean) session.getAttribute("sessionUser");
    //小key
    String userId = String.valueOf(user.getUserId());
    //时间格式转换
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    List<BankcardBean> list = new ArrayList<>();
	//判断 Redis 数据库是否存在 大key 小key 
    boolean ifKey = redisTemplate.opsForHash().hasKey(bigKey,userId);
    //bankcardBean 判断是否有 id 新增方法
    if (bankcardBean.getCardId() == null) {
        //往 bean 里添加数据
        bankcardBean.setCardUser(user.getUserId());
        bankcardBean.setCardTime(sdf.format(new Date()));
        bankcardDao.insert(bankcardBean);
        if (ifKey) {//存在
            //通过 大key 小key 查询 内容
            List<Object> list1 = (List<Object>) redisTemplate.opsForHash().get(bigKey, userId);
            //查询内容 拼接 新增内容
            list1.add(bankcardBean);
            redisTemplate.opsForHash().put(bigKey,userId,list1);
            //重新赋值 (覆盖)
            System.out.println("我走了 Redis 新增 !!");
        }else {//不存在
            //添加
            List<BankcardBean> list2 = new ArrayList<>();
            list2.add(bankcardBean);
            redisTemplate.opsForHash().put(bigKey,userId,list2);
        }
    } else {//没有 id 修改方法
        LambdaUpdateWrapper<BankcardBean> luw = new LambdaUpdateWrapper<>();
        luw.set(BankcardBean :: getCardName, bankcardBean.getCardName())
            .set(BankcardBean :: getCardNumber, bankcardBean.getCardNumber());
        luw.eq(BankcardBean::getCardId, bankcardBean.getCardId())
            .eq(BankcardBean::getCardUser, user.getUserId());
        //通过 条件 修改
        bankcardDao.update(null, luw);
        //删除 (查找 大key 的 小key , 根据 小key 删除数据)
        redisTemplate.rename(bigKey, userId);
    }
}
删除

在这里插入图片描述

小key : 用户id

  1. 根据 id 删除

  2. 删除 (查找 大key 的 小key , 根据 小key 删除数据)

执行删除后 , 方法执行成功 , 前端回调刷新页面方法

@Override
public void deleteBankcardById(Integer id, HttpSession session) {
    UserBean user = (UserBean) session.getAttribute("sessionUser");
    String userId = String.valueOf(user.getUserId());
    bankcardDao.deleteById(id);
    redisTemplate.rename(bigKey, userId);
}

Redis 登录 限制 3 次后 多少秒后才能登录

通过条件查询用户

  1. 判断验证码是否正确 不正确 return “4”
  2. 判断当前登录账号是否存在
  3. 存在 true
    1. 用户 id 作为 key
    2. 判断 Redis 存不存在 key
    3. 判断登录密码是否正确
      1. true
        1. 判断 Redis 存不存在 key
          1. 判断当前登录失败是否失败了三次以上 true return “6”;
          2. 添加 session数据 return “1” (登录成功)
      2. false
        1. 判断 Redis 存不存在 key
          1. 存在 true
            1. 当有账户 密码不正确 key存在的情况下+1 , 返回 +1 后的 数
            2. 判断是否失败了三次 (账号存在,密码错误)
              1. true : 启动定时 锁定60秒 (60s 后删除 Redis里的key)
              2. return “5”
          2. 不存在 false
            1. 创建 key : value = 1
        2. return “3”
  4. 不存在 false return “2”

var login = “”;
switch (data){
case “0” : login = “账号或密码不正确!”; break;
case “1” : login = “登录成功!”; break;
case “2” : login = “账号不正确!!”; break;
case “3” : login = “密码不正确!!”; break;
case “4” : login = “验证码不正确!!”; break;
case “5” : login = “账户已锁定 , 睡吧 60 后再醒!!”; break;
case “6” : login = “账户已锁定 , 稍后操作!!”; break;
}

package com.jk.zz.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jk.zz.dao.LoginDao;
import com.jk.zz.pojo.UserBean;
import com.jk.zz.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;
import java.util.concurrent.TimeUnit;



@Service
public class LoginServiceImpl implements LoginService {
    @Autowired
    private LoginDao loginDao;

    @Autowired(required = false)
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public String getLogin(UserBean userBean, HttpSession session) {
        LambdaQueryWrapper<UserBean> qw = new LambdaQueryWrapper<>();
        qw.eq(UserBean :: getUserNickname, userBean.getUserNickname());
        UserBean user = loginDao.selectOne(qw);
        String code2 = (String) session.getAttribute("checkcode");

        if (!userBean.getCode().equalsIgnoreCase(code2)) {
            return "4";
        }

        if (user != null) {
            //用户 id 作为 key
            String notLoginKey = "notLogin_"+user.getUserId();
            // 判断 Redis 存不存在 key
            boolean ifkey = stringRedisTemplate.hasKey(notLoginKey);
            if (userBean.getUserPassword().equals(user.getUserPassword())) {
                if(ifkey){
                    Long count = Long.valueOf(stringRedisTemplate.opsForValue().get(notLoginKey));
                    if(count>2){
                        return "6";
                    }
                }
                session.setAttribute("user", user);
                return "1";
            }else {
                // 存在
                if (ifkey) {
                    // 当有账户 密码不正确 key存在的情况下 +1
                    Long count = stringRedisTemplate.opsForValue().increment(notLoginKey,1);
                    if(count>=3){//失败了三次
                        //启动定时   锁定60秒
                        stringRedisTemplate.expire(notLoginKey,60, TimeUnit.SECONDS);
                        return "5";
                    }
                }else {// 不存在
                    //创建 key : value = 1
                    stringRedisTemplate.opsForValue().increment(notLoginKey,1);
                }
                return "3";
            }

        }
        return "2";
    }
}

notLoginKey));
                    if(count>2){
                        return "6";
                    }
                }
                session.setAttribute("user", user);
                return "1";
            }else {
                // 存在
                if (ifkey) {
                    // 当有账户 密码不正确 key存在的情况下 +1
                    Long count = stringRedisTemplate.opsForValue().increment(notLoginKey,1);
                    if(count>=3){//失败了三次
                        //启动定时   锁定60秒
                        stringRedisTemplate.expire(notLoginKey,60, TimeUnit.SECONDS);
                        return "5";
                    }
                }else {// 不存在
                    //创建 key : value = 1
                    stringRedisTemplate.opsForValue().increment(notLoginKey,1);
                }
                return "3";
            }

        }
        return "2";
    }
}
铮崽困了
关注
011_RedisTemplate操作Hash
yummy的博客
04-21 1261
011_RedisTemplate操作Hash 1、测试代码如图所示： @Test void testHash(){ stringRedisTemplate.opsForHash().put("user:103","name","李易峰"); stringRedisTemplate.opsForHash().put("user:103","age","21"); Map<Object, Object> entries = strin
RedisTemplate 中hash方法的使用
qq_37655169的博客
11-20 5110
键值对的的操作在java里面也是很频繁的，下面记录了RedisTemplate 操作hash 的方法。 package com; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.concurrent...
RedisTemplate的各种操作（set、hash、list、string）
热门推荐
lichuangcsdn的博客
06-30 10万+
注入以下RedisTemplate @Autowired private RedisTemplate&lt;String,String&gt; redisTemplate; 1、保存和读取Set： 代码示例： SetOperations&lt;String, String&gt; set = redisTemplate.opsForSet(); set.add("set1","22...
stringRedisTemplate 批量存入zset
最新发布
weixin_40361401的博客
08-28 48
我整理的一些关于【set】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/bLN8S1使用 StringRedisTemplate 批量存入 ZSet 的方法与示例 在现代应用中，数据存储的效率和灵活性是非常重要的。Redis 是一个高性能的键值数据库，支持多种数据结构，包括...
RedisTemplate操作哈希数据
爱媳妇儿爱编程
12-09 4529
Redis是一个开源的内存数据结构存储系统，它可以用作数据库、缓存和消息代理。Redis 的核心是提供数据类型的集合,在Redis中，有多种数据结构，如字符串、列表、集合、有序集合和哈希表,它可以帮助解决从缓存到队列再到事件处理的各种问题。RedisTemplate是Spring Data Redis提供的一个用于操作Redis的模板类，它提供了丰富的方法来操作Redis中的哈希数据。
Redis关于Hash类型数据的操作，使用redisTemplate
lirtyuj的博客
07-01 2818
因为在redis的Hash数据类型里，有内层外层两个key，所以暂时先称外层key为大key，内层key为小key，内层value值为value。
Redis 五大数据类型（String、List、Hash、Set 及 Zset）
Xucf1
02-26 1152
文章目录一、String 数据类型1.概述2.命令示例2.1 EXISTE、APPEND、GET、SET、STRLEN2.2 INCR、DECR、DEL、INCRBY、DECRBY2.3 GETSET、SETEX、TTL、SETNX2.4 SETRANGE、GETRANGE2.5 MSET、MGET、MSETNX二、List 数据类型1.概述2.命令示例2.1 LPUSH、LPUSHX、LRANGE、LPOP/LIEN2.2 LREM、LSET、LINDEX、LTRIM2.4 LINSERT2.5 RPUS
redis中string,list,set,zset,hash,hyperloglog等命令详解(一份就够超全超详细)
04-26
内容包含了redis中全部命令string,list,set,zset,hashhyperloglog,geo,stream,pubsub,scripting,server,cluster,connection,generic,transactions. 格式有命令完整语法格式,命令说明,起始版本三部分组成,例如 MGET ...
Redis 数据类型String，List，Set，ZSet，Hash详解
qq_56263094的博客
07-23 574
可以看到Redis在string类型所做的优化已经十分完善，根据数据类型，数据大小采用不同的编码方式，以此来节省空间，提高效率。
在Java中使用redisTemplate操作缓存的方法示例
08-26
在Java中使用redisTemplate操作缓存的方法示例，主要介绍了在Java中使用redisTemplate操作缓存的方法示例，在Redis中可以存储String、List、Set、Hash、Zset。感兴趣的可以了解一下背景在最近的项目中，有一个需求是...
以下哪些是redis支持的数据类型 String List Set zset Hash
06-09
Redis 支持以下五种数据类型： 1. String（字符串）：Redis 的字符串是二进制安全的，意味着可以包含任何数据，例如一个 JPEG 图像或者序列化...综上所述，Redis 支持 String、List、Set、Zset 和 Hash 五种数据类型。
RedisTemplate常用集合使用说明-opsForZSet(六)
04-30
NULL 博文链接：https://357029540.iteye.com/blog/2389154
redisTemplate的日常使用hash类型
weixin_43167662的博客
07-30 8511
redisTemplate.getExpire(key,TimeUnit.SECONDS); 这个方法，是使用redisTemplate获取到设置的过期时间。如果传入单位，则按照该单位的数据进行返回。 redisTemplate.getExpire(key); 返回的Long类型的时间单位是秒 ...
SpringBoot--RedisTemplate详解（Hash、Set、ZSet）
吴声子夜歌的博客
02-05 4309
Redis的Hash数据结构 Redis的散列可以让用户将多个键值对存储到一个Redis键里面。 public interface HashOperations<H,HK,HV> HashOperations提供一系列方法操作hash： 初始数据: //template.opsForHash().put("redisHash","name","tom"); //temp...
StringRedisTemplate
qq_45243783的博客
04-30 1万+
StringRedisTemplate继承自RedisTemplate,在这里说明一下，当我们使用RedisTemplate往redis中存储java对象的时候，他会顺带着将该java对象的字节码文件也同时存进了内存中，这是为了实现自动反序列化 尽管JSON的序列化方式可以满足我们的需求，但是仍然存在一些问题，如上图所示，为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis,会带来额外的内存开销。 在使用RedisTemplate是一般我们都会使用自定义
RedisTemplate中zset类型的使用
weixin_30315723的博客
08-30 955
简述 上一文中简述了使用StringRedisTemplate操作redis中的set类型，今天来记录一下操作zset类型的主要方法 代码 @RunWith(SpringRunner.class) @SpringBootTest public class ZSetDemo { @Autowired private StringRedi...
Redis入门到通关之ZSet命令
莫等闲 白了少年头 空悲切
04-16 1672
Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加hash表。可排序元素不重复查询速度快因为SortedSet 的可排序特性，经常被用来实现排行榜这样的功能。
StringRedisTemplate常用hash操作
愿你看淡世界沧桑，内心安然无恙
04-14 7560
基础model类： class Student{ private Long id; private String name; private Long classId; Student(Long id ,String name,Long classId){ this.id = id; this.name = name; this.classId = cla...
Redis19----RedisTemplate操作Hash类型
weixin_54048131的博客
05-26 443
基础篇-22.Redis的Java客户端-RedisTemplate操作Hash类型_哔哩哔哩_bilibili 用Hash操作用这个 Hash表中我们要用put 这里我们添加一个字段 Hash表得到值的写法：get entries的意思是，拿到所有的键值对 keys的意思是拿到所有的key values拿到所有的values 传入一个Key,最终拿到Map的结果
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值