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

redistemplate方法

string类型

hash类型

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类型

set类型

zset类型

常用方法

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 写 增删改查

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

	

}

查询

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

新增/修改

@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);
    }
}

删除

@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 次后 多少秒后才能登录

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