StringRedisTemplate中HashOperations的使用

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