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

redisTemplate方法

String类型

Hash类型

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

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

Set类型

zSet类型

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

常用方法

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 数据

3. 不存在 id 修改方法

4. 通过 条件 修改

5. 删除 (查找 大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";
    }
}

代码007普通

打赏 收藏 海报 链接