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";
    }
}

原文地址:https://blog.csdn.net/qq_71695227/article/details/130717809

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_44894.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除!

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注