Redis中StringRedisTemplate中HashOperations的使用详解

更新时间：2026年03月12日 14:13:02 作者：兰舟轻帆

文章介绍了Spring Boot 2中使用Lettuce框架访问Redis的基本步骤和常用操作,包括添加依赖、注入`StringRedisTemplate`实例以及进行字符串、哈希、集合、列表和有序集合的基本操作,文章还提供了一个登录案例,并总结了个人经验,鼓励读者参考和支持

Springboot2默认情况下使用lettuce框架访问Redis

只需要在pom.xml文件添加以下依赖即可：

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

在需要访问Redis的类中注入StringRedisTemplate实例

@Autowired  
StringRedisTemplate stringRedisTemplate;

基本用法

// 获取HashOperations
HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
//add
hashOperations.put("user_hash","zhangfei","black face");
//update  put会覆盖，相当于update
hashOperations.put("user_hash","zhangfei","mangfu"); 
//list 这里感觉叫list不好叫all吧
Map<String, String> userMap = hashOperations.entries("user_hash"); // entries
Set<String> userKeys = hashOperations.keys("user_hash");// keys
List<String> userValues = hashOperations.values("user_hash"); // values
//delete
hashOperations.delete("user_hash","zhangfei3");
//是否存在
Boolean aBoolean = hashOperations.hasKey("user_hash", "zhangfei"); // 是否存在

简化String操作方式

@Controller
@RequestMapping("hash")
public class HashController {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @ResponseBody
    @RequestMapping("/add")
    public Map<String,String> add(){
        HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
        hashOperations.put("user_hash","zhangfei","black face"); // put相当于添加
        hashOperations.put("user_hash","guanyu","red face");
        return getAll();
    }
    @ResponseBody
    @RequestMapping("/update")
    public Map<String,String> update(){
        HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
        Boolean aBoolean = hashOperations.hasKey("user_hash", "zhangfei"); // 是否存在
        System.out.println(aBoolean);
        hashOperations.put("user_hash","zhangfei","mangfu"); //put 会重置，相当于update
        return getAll();
    }
    @ResponseBody
    @RequestMapping("/all")
    public Map<String,String> all(){
        return getAll();
    }
    @ResponseBody
    @RequestMapping("/delete")
    public Map<String,String> delete(){
        HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
        hashOperations.delete("user_hash","zhangfei3");
        return getAll();
    }
    public Map<String,String> getAll(){
        HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
        Map<String, String> userMap = hashOperations.entries("user_hash"); // entries
        final Set<String> userKeys = hashOperations.keys("user_hash"); // keys
        List<String> userValues = hashOperations.values("user_hash"); // values
        return userMap;
    }
}

String（字符串）

private void testValue(){  
    ValueOperations<String, String> value = stringRedisTemplate.opsForValue();  
    value.getOperations().delete("aaa"); //删除  
    value.getOperations().delete("bbb");  
      
    value.set("aaa", "123"); //set  
    System.out.println(value.setIfAbsent("aaa", "123")); //没有才set  
      
    System.out.println(value.size("aaa")); //长度  
    System.out.println(value.get("aaa")); //获取值  
      
    value.append("aaa", "456"); //追加  
    System.out.println(value.get("aaa"));  
      
    value.increment("bbb", 1); //数值自增  
    System.out.println(value.get("bbb"));  
      
    value.multiGet(Arrays.asList("aaa", "bbb", "ccc"))  
        .stream().forEach(System.out::println);  
}

Hash（散列）

private void testHash(){  
    HashOperations<String, String, String> hash = stringRedisTemplate.opsForHash();  
    hash.getOperations().delete("hash1");  
      
    hash.put("hash1", "aaa", "111"); //put  
    hash.put("hash1", "bbb", "222");  
    hash.put("hash1", "ccc", "333");  
      
    System.out.println(hash.size("hash1")); //长度  
      
    hash.entries("hash1").forEach((k,v) -> { //显示所有的key和value  
        System.out.println(k + "=" + v);  
    });  
      
    hash.keys("hash1").stream().forEach(System.out::println); //显示所有的key  
    hash.values("hash1").stream().forEach(System.out::println); //显示所有的value  
      
    System.out.println(hash.putIfAbsent("hash1", "aaa", "aaa")); //没有key才put  
      
    hash.increment("hash1", "count", 1); //数值自增  
    System.out.println(hash.get("hash1", "count"));  
      
    hash.increment("hash1", "count", 1);  
    System.out.println(hash.get("hash1", "count"));  
      
    hash.increment("hash1", "count", -1);  
    System.out.println(hash.get("hash1", "count"));  
      
    System.out.println(hash.hasKey("hash1", "amount")); //判断key是否存在  
    System.out.println(hash.get("hash1", "count"));  
    hash.delete("hash1", "count"); //删除  
}

Set（集合）

private void testSet(){  
    SetOperations<String, String> set = stringRedisTemplate.opsForSet();  
    set.getOperations().delete("set1");  
    set.getOperations().delete("set2");  
      
    set.add("set1", "111", "222", "333", "111");  
    set.add("set2", "222", "333", "444");  
      
    System.out.println(set.size("set1")); //长度  
      
    System.out.println(set.members("set1")); //获取所有值  
    System.out.println(set.members("set2"));  
      
    System.out.println(set.difference("set1", "set2")); //从前者取得与后者不一样的元素  
    System.out.println(set.intersect("set1", "set2")); //交集  
    System.out.println(set.union("set1", "set2")); //并集  
    set.remove("set1", "111"); //删除一个元素  
    System.out.println(set.pop("set1")); //弹出一个元素  
    System.out.println(set.randomMember("set2")); //随机取一个元素  
    System.out.println(set.isMember("set2", "444")); //给定元素是否是成员  
    set.move("set2", "444", "set1"); //移动  
    System.out.println(set.members("set1"));  
}

List（列表）

private void testList() {  
    ListOperations<String, String> list = stringRedisTemplate.opsForList();  
    list.getOperations().delete("list"); //清空  
      
    list.leftPush("list", "111"); //push 放到list中  
    list.leftPushIfPresent("list", "222");  
    list.rightPush("list", "333");  
    list.rightPushIfPresent("list", "444");  
      
    System.out.println(list.index("list", 0));  
    System.out.println(list.range("list", 0, -1));  
    list.trim("list", 0, 2); //截取  
    System.out.println(list.range("list", 0, -1));  
      
    System.out.println(list.leftPop("list")); //pop 取出消费掉  
    System.out.println(list.rightPop("list"));  
}

Zset（有序集合）

private void testZSet(){  
    ZSetOperations<String, String> zset = stringRedisTemplate.opsForZSet();  
    zset.getOperations().delete("zset1");  
    zset.getOperations().delete("zset2");  
      
    zset.add("zset1", "aaa", 1);  
    zset.add("zset1", "bbb", 1);  
    zset.add("zset1", "ccc", 1);  
      
    zset.add("zset2", "bbb", 1);  
    zset.add("zset2", "ccc", 1);  
    zset.add("zset2", "ddd", 1);  
      
    System.out.println(zset.size("zset1")); //长度  
    System.out.println(zset.range("zset1", 0, -1)); //取所有元素  
      
    zset.incrementScore("zset1", "bbb", 1); //增加分数score  
    zset.incrementScore("zset1", "aaa", 2);  
      
    System.out.println(zset.range("zset1", 0, -1)); //分数递增排序  
    zset.rangeWithScores("zset1", 0, -1).stream().forEach(t -> {  
        System.out.println(t.getValue() + "-" + t.getScore());  
    });  
      
    System.out.println(zset.reverseRange("zset1", 0, -1)); //分数递减排序  
    zset.reverseRangeWithScores("zset1", 0, -1).stream().forEach(t -> {  
        System.out.println(t.getValue() + "-" + t.getScore());  
    });  
      
    System.out.println(zset.rank("zset1", "ccc")); //分数递增排序，取元素的索引  
    System.out.println(zset.reverseRank("zset1", "ccc")); //分数递减排序，取元素的索引  
      
    System.out.println(zset.score("zset1", "bbb")); //取元素的分数  
      
    zset.remove("zset2", "bbb"); //删除元素  
    System.out.println(zset.range("zset2", 0, -1));  
}

登录案列

package com.cjs.example.controller;

import com.cjs.example.ResponseResult;
import com.cjs.example.domain.LoginRequest;
import com.cjs.example.domain.LoginResponse;
import com.cjs.example.domain.RefreshRequest;
import com.cjs.example.enums.ResponseCodeEnum;
import com.cjs.example.utils.JWTUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.security.MD5Encoder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
 
 @RestController
 public class LoginController {
     /**
      * Apollo 或 Nacos
      */
     @Value("${secretKey:123456}")
     private String secretKey;
 
     @Autowired
     private StringRedisTemplate stringRedisTemplate;
 
     /**
      * 登录
      */
     @PostMapping("/login")
     public ResponseResult login(@RequestBody @Validated LoginRequest request, BindingResult bindingResult) {
         if (bindingResult.hasErrors()) {
             return ResponseResult.error(ResponseCodeEnum.PARAMETER_ILLEGAL.getCode(), ResponseCodeEnum.PARAMETER_ILLEGAL.getMessage());
         }
         String username = request.getUsername();
         String password = request.getPassword();
         //  假设查询到用户ID是01
         String userId = "01";
         if ("hello".equals(username) && "world".equals(password)) {
             //  生成Token
             String token = JWTUtil.generateToken(userId, secretKey);
             //  生成刷新Token
             String refreshToken = UUID.randomUUID().toString().replace("-", "");
             //  放入缓存
             HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
 //            hashOperations.put(refreshToken, "token", token);
 //            hashOperations.put(refreshToken, "user", username);
 //            stringRedisTemplate.expire(refreshToken, JWTUtil.TOKEN_EXPIRE_TIME, TimeUnit.MILLISECONDS);
             /**
              * 如果可以允许用户退出后token如果在有效期内仍然可以使用的话，那么就不需要存Redis
              * 因为，token要跟用户做关联的话，就必须得每次都带一个用户标识，
              * 那么校验token实际上就变成了校验token和用户标识的关联关系是否正确，且token是否有效
              */
 //            String key = MD5Encoder.encode(userId.getBytes());
             String key = userId;
             hashOperations.put(key, "token", token);
             hashOperations.put(key, "refreshToken", refreshToken);
             stringRedisTemplate.expire(key, JWTUtil.TOKEN_EXPIRE_TIME, TimeUnit.MILLISECONDS);
 
             LoginResponse loginResponse = new LoginResponse();
             loginResponse.setToken(token);
             loginResponse.setRefreshToken(refreshToken);
             loginResponse.setUsername(userId);
             return ResponseResult.success(loginResponse);
         }
         return ResponseResult.error(ResponseCodeEnum.LOGIN_ERROR.getCode(), ResponseCodeEnum.LOGIN_ERROR.getMessage());
     }
 
     /**
      * 退出
      */
     @GetMapping("/logout")
     public ResponseResult logout(@RequestParam("userId") String userId) {
         HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
         String key = userId;
         hashOperations.delete(key);
         return ResponseResult.success();
     }
     /**
      * 刷新Token
      */
     @PostMapping("/refreshToken")
     public ResponseResult refreshToken(@RequestBody @Validated RefreshRequest request, BindingResult bindingResult) {
         String userId = request.getUserId();
         String refreshToken = request.getRefreshToken();
         HashOperations<String, String, String> hashOperations = stringRedisTemplate.opsForHash();
         String key = userId;
         String originalRefreshToken = hashOperations.get(key, "refreshToken");
         if (StringUtils.isBlank(originalRefreshToken) || !originalRefreshToken.equals(refreshToken)) {
             return ResponseResult.error(ResponseCodeEnum.REFRESH_TOKEN_INVALID.getCode(), ResponseCodeEnum.REFRESH_TOKEN_INVALID.getMessage());
         }
         //  生成新token
         String newToken = JWTUtil.generateToken(userId, secretKey);
         hashOperations.put(key, "token", newToken);
         stringRedisTemplate.expire(userId, JWTUtil.TOKEN_EXPIRE_TIME, TimeUnit.MILLISECONDS);
 
         return ResponseResult.success(newToken);
     }
}

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

Redis集群的搭建图文教程
下面小编就为大家分享一篇Redis集群的搭建图文教程，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2017-11-11
React实现组件之间通信的几种常用方法
在 React 中,组件之间的通信是构建复杂应用程序的核心部分,良好的组件间通信能够提高代码的可维护性和可读性,同时能够高效地管理应用状态,在这篇博客中,我们将探讨 React中几种常用的组件通信方法,并提供示例代码来帮助你理解,需要的朋友可以参考下
2025-02-02
Redis事务,Redis实现悲观锁,乐观锁方式
文章介绍了Redis事务的概念、特点和执行过程,区别于MySQL事务的ACID特性,详细讲解了未授权读取、授权读取、重复读取和串行化四种隔离级别,并解析了悲观锁和乐观锁的定义与应用场景,最后阐述了Redis通过版本号实现乐观锁的机制
2026-05-05
Redis实现每周热评的项目实践
实时统计和展示热门内容是一种常见的需求,本文主要介绍了Redis实现每周热评的项目实践,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
2024-03-03
Redis 中ZSET数据类型命令使用及对应场景总结(案例详解)
这篇文章主要介绍了Redis 中ZSET数据类型命令使用及对应场景总结,本文通过示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2023-01-01
Redis实战之Redis实现异步秒杀优化详解
这篇文章主要给大家介绍了Redis实战之Redis实现异步秒杀优化方法,文章通过图片和代码介绍的非常详细,对大家的学习或工作有一定的帮助,感兴趣的同学可以自己动手试一下
2023-09-09
Redis基本数据类型Zset有序集合常用操作
这篇文章主要为大家介绍了redis基本数据类型Zset有序集合常用操作，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2022-05-05
redis和redission分布式锁原理及区别说明
文章对比了synchronized、乐观锁、Redis分布式锁及Redission锁的原理与区别,指出在集群环境下synchronized失效,乐观锁存在数据库性能瓶颈,而Redission通过watchdog自动续期和Lua原子操作解决Redis锁的超时问题,推荐其在高并发场景下的可靠性与易用性
2025-08-08
Redis的Bitmap(位图)详解和命令演示
Redis的位图是由多个二进制位组成的数组,数组中的每个二进制位都有与之对应的偏移量,用户通过这些偏移量可以对位图中指定的一个或多个二进制位进行操作,这篇文章主要给大家介绍了关于Redis的Bitmap(位图)详解和命令演示的相关资料,需要的朋友可以参考下
2024-08-08
redis实现加锁的几种方法示例详解
这篇文章主要给大家介绍了关于redis实现加锁的几种方法，加锁命令分别是INCR、SETNX和SET，文中给出了详细的示例代码，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
2017-09-09