redisTemplate使用笔记(操作redis、list等)

命令行操作redis是一回事，java操作redis是另外一回事，有的时候服务器没有权限，所以java做出接口比较方便。

按类型区分为几大块应该比较合适。
这类基础代码百度上导出都是，随便摘一些吧。
也建议最好整理个redis接口类，用起来方便。

通用操作

通用操作即不区分类型，都适用的操作。

keys查看所有key(这里额外加了type，便于看到)

@RequestMapping("/keys")
    public HashMap keys(RedisEntity request) {
        HashMap keysMap  = new HashMap<>();
        Set<String> keys = redisTemplate.keys("*");
        for (String item:keys) {
            DataType type = redisTemplate.type(item);
            keysMap.put(item,type);
        }
        return keysMap;
    }

del(删除)

@RequestMapping("/del")
public String del(@RequestBody RedisEntity request) {
    redisTemplate.delete(request.getKey());
    return "OK";
}

type

@RequestMapping("/type")
public String type(@RequestBody RedisEntity request) {
    DataType type = redisTemplate.type(request.getKey());
    return JSON.toJSONString(type);
}

注：get，set都不属于通用范围内，不同类型的get和set方法不一样，分到具体的类型里面。

info

对，你没看错，info信息也是可以的，而且是如此简单。

Properties info = redisTemplate.getConnectionFactory().getConnection().info();

操作string

setString

@RequestMapping("/setString")
public Object set(@RequestBody RedisEntity request) {
    redisTemplate.opsForValue().set(request.getKey(), request.getValue());
    return "OK";
}

getString

@RequestMapping("/getString")
public String get(@RequestBody RedisEntity request) {
     Object o = redisTemplate.opsForValue().get(request.getKey());
     return JSON.toJSONString(o);
 }

操作list

listLeftPush(左入栈\压栈)：

Long i = redisTemplate.opsForList().leftPush(request.getKey(), request.getValue());

listLeftPop(左出栈)：

Object object = redisTemplate.opsForList().leftPop(request.getKey());

注：
入栈是2个参数，key和value。
出栈一个参数即可，因为方法名已确认左出栈。

listShowAll(展示全部)：

Object object = redisTemplate.opsForList().range(request.getKey(),0,-1);

小技巧：有点文档说，opsForList()没有遍历方法，需要先size()，再range()，那就俗手了。
这里有妙手，直接用(0,-1)就行，因为-1表示最后一个元素。

操作map

map比较麻烦，因为map有个外层key，里面的属性也是key，容易混淆，这点需要关注下。

操作cluster

一开始为了看info想到的cluster，实际cluster根本不是为了info的。
而是对集群节点的增删改等操作才会用到cluster，这里略过吧。

加锁

@ResponseBody
@RequestMapping("/lock")
public String lock(){
    ValueOperations operations = stringRedisTemplate.opsForValue();
    String wcLock = (String)operations.get(WC_LOCK);

    if(!StringUtils.isEmpty(wcLock)){

        logger.info("wcLock已经存在");
        return "wcLock已经存在";
    }else{
    	// key value timeout 时间单位
        operations.set(WC_LOCK,"1",60, TimeUnit.SECONDS);
        return "wcLock设置锁成功";
    }


}

注：超期时间要 >0 否则会报错。

expire

@ResponseBody
@RequestMapping("/expire")
public String expire(){
    ValueOperations operations = stringRedisTemplate.opsForValue();

    operations.set(WC_LOCK,"1",1L, TimeUnit.SECONDS);
    return "expire success";
}

获取值

@ResponseBody
@RequestMapping("/get")
public String get(String string){
    ValueOperations operations = stringRedisTemplate.opsForValue();
    String wcLock = (String)operations.get(string);
    Long expire = operations.getOperations().getExpire(string); // 过期时间的获取
    logger.info("key: {},timeout is: {}",expire);
    return wcLock;

}

例子代码

代码：

@RestController
@RequestMapping("")
public class LoginController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @RequestMapping("/login")
    public String login(HttpServletRequest request){

        ValueOperations valueOperations = stringRedisTemplate.opsForValue();

        valueOperations.set("shanghai","shanghai"); // 新增
        valueOperations.set("hebei","shijiazhuang2"); // 存在的话就是修改
        valueOperations.get("hebei");
        Set<String> keys = stringRedisTemplate.keys("*"); // keys * 查看所有
        for (String key:
             keys) {
            System.out.println(keys);
        }
        stringRedisTemplate.delete("one"); // 删除
        return "fail";
    }
}

redis工具类

controller

选一段几年前网上找到的通用工具类代码吧。

/*
 * 定制redis
 */
@RestController
@RequestMapping(value = "/interface/redis")
public class RedisController {

    private static Logger logger = LoggerFactory.getLogger(RedisController.class);

    @Autowired
    private RedisTemplate redisTemplate;


    @RequestMapping("/setString")
    public Object set(@RequestBody RedisRequest request) {
        redisTemplate.opsForValue().set(request.getKey(), request.getValue());
        return "OK";
    }

    // 注：get方法在不确定类型的情况下不能直接用
    @RequestMapping("/getString")
    public String get(@RequestBody RedisRequest request) {
        Object o = redisTemplate.opsForValue().get(request.getKey());
        return JSON.toJSONString(o);
    }

    // type也是通用功能，不区分类型  keys加强下  实际用不到这个接口了
    @RequestMapping("/type")
    public JsonResult type(@RequestBody RedisRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_delete请求开始，request={}", JSON.toJSONString(request));
            DataType type = redisTemplate.type(request.getKey());
            logger.info("定制redis_delete请求完成，result={}",JSON.toJSONString(result));
            result=JsonResult.success(type);
            return result;
        }catch(Exception e){
            logger.error("定制redis_delete请求异常，error：",e);
            return JsonResult.error("-1","定制redis_delete请求异常,error="+e.getMessage());
        }

    }

    // 删除的时候区分类型吗? 不区分
    @RequestMapping("/delete")
    public JsonResult delete(@RequestBody RedisRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_delete请求开始，request={}", JSON.toJSONString(request));
            redisTemplate.delete(request.getKey());
            logger.info("定制redis_delete请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_delete请求异常，error：",e);
            return JsonResult.error("-1","定制redis_delete请求异常,error="+e.getMessage());
        }
    }

    @RequestMapping("/keys")
    public JsonResult keys(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        HashMap keysMap  = new HashMap<>();
        Set<String> keys = new HashSet<String>();
        try {
            logger.info("定制redis_info请求开始，request={}",JSON.toJSONString(request));
            if(!StringUtils.isEmpty(request.getKey())){
                keys=redisTemplate.keys(request.getKey());
            }else{
                keys = redisTemplate.keys("*");
            }
            for (String item:keys) {
                DataType type = redisTemplate.type(item);
                keysMap.put(item,type);
            }
            result=JsonResult.success(keysMap);
            logger.info("定制redis_info请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch (Exception e){
            logger.error("定制redis_keys请求异常，error：",e);
            return JsonResult.error("-1","定制redis_keys请求异常,error="+e.getMessage());
        }

    }

    @RequestMapping("/info")
    public JsonResult info(@RequestBody RedisRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_info请求开始，request={}", JSON.toJSONString(request));
            Properties info = redisTemplate.getConnectionFactory().getConnection().info();
            result=JsonResult.success(info);
            logger.info("定制redis_info请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_info请求异常，error：",e);
            return JsonResult.error("-1","定制redis_info请求异常,error="+e.getMessage());
        }

    }



    // 添加单条记录
    @RequestMapping("/putToMap")
    public JsonResult putToMap(@RequestBody RedisMapRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_putToMap请求开始，request={}", JSON.toJSONString(request));
            redisTemplate.opsForHash().put(request.getKey(), request.getSonKey(),request.getSonValue());
            // 重查
            Map map = redisTemplate.opsForHash().entries(request.getKey());
            result=JsonResult.success(map);
            logger.info("定制redis_putToMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_putToMap请求异常，error：",e);
            return JsonResult.error("-1","定制redis_putToMap请求异常,error="+e.getMessage());
        }
    }


    /*
     * 添加所有到map
     * 注：这是个增量接口
     * 如果key相同，会覆盖
     * 如果map为空 不会影响原有map
     */
    @RequestMapping("/putAllToMap")
    public JsonResult putAllToMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("定制redis_putAllToMap请求开始，request={}", JSON.toJSONString(request));
            redisTemplate.opsForHash().putAll(request.getKey(),request.getMap());
            logger.info("定制redis_putAllToMap请求开始，request={}", JSON.toJSONString(request));
            return result;
        }catch(Exception e) {
            logger.error("定制redis_putAllToMap请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_putAllToMap请求异常,error=" + e.getMessage());
        }

    }

    @RequestMapping("/getFromMap")
    public JsonResult getFromMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("定制redis_getFromMap请求开始，request={}",JSON.toJSONString(request));
            Object o = redisTemplate.opsForHash().get(request.getKey(), request.getSonKey());
            result=JsonResult.success(o);
            return result;
        }catch(Exception e){
            logger.error("定制redis_putAllToMap请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_putAllToMap请求异常,error=" + e.getMessage());
        }
    }


    // 强制set  先删除 再set全部
    @RequestMapping("/setMap")
    public JsonResult setMap(@RequestBody RedisMapRequest request,HashMap map) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("定制redis_setMap请求开始，request={}",JSON.toJSONString(request));
            if(null==map){
                map = new HashMap<>();
            }
            redisTemplate.opsForHash().delete(request.getKey());
            redisTemplate.opsForHash().putAll(request.getKey(), map);
            logger.info("定制redis_setMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_setMap请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_setMap请求异常,error=" + e.getMessage());

        }

    }

    @RequestMapping("/getMapValues")
    public JsonResult getMapValues(@RequestBody RedisMapRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_getMapValues请求开始，request={}",JSON.toJSONString(request));
            List list = redisTemplate.opsForHash().values(request.getKey());
            result=JsonResult.success(list);
            logger.info("定制redis_getMapValues请求完成，request={}",JSON.toJSONString(request));
            return result;
        }catch(Exception e){
            logger.error("定制redis_getMapValues请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_getMapValues请求异常,error=" + e.getMessage());
        }

    }

    @RequestMapping("/getMapEntries")
    public JsonResult getMapEntries(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("定制redis_getMapEntries请求开始，request={}",JSON.toJSONString(request));
            Map map = redisTemplate.opsForHash().entries(request.getKey());
            result=JsonResult.success(map);
            logger.info("定制redis_getMapEntries请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_getMapEntries请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_getMapEntries请求异常,error=" + e.getMessage());
        }


    }

    @RequestMapping("/delMap")
    public JsonResult delMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("定制redis_delMap请求开始，request={}",JSON.toJSONString(request));
            Long delflag = redisTemplate.opsForHash().delete(request.getKey());
            result=JsonResult.success(delflag);
            logger.info("定制redis_delMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_delMap请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_delMap请求异常,error=" + e.getMessage());
        }
    }

    // 从map中删除一个键值对
    @RequestMapping("/deleteKeyFromMap")
    public JsonResult deleteKeyFromMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("定制redis_deleteKeyFromMap请求开始，request={}",JSON.toJSONString(request));
            Long delflag = redisTemplate.opsForHash().delete(request.getKey(), request.getSonKey());
            result=JsonResult.success(delflag);
            logger.info("定制redis_deleteKeyFromMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_deleteKeyFromMap请求异常，error：", e);
            return JsonResult.error("-1", "定制redis_deleteKeyFromMap请求异常,error=" + e.getMessage());
        }
    }

    @RequestMapping("/listAddValues")
    public JsonResult listAddValues(@RequestBody RedisListRequest request) {

        try {
            logger.info("定制redis_listAddValues请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            Long i = redisTemplate.opsForList().rightPushAll(request.getKey(), request.getValues());
            logger.info("定制redis_listAddValues请求完成，i={}", i);
            result.setMessage("定制redis_listAddValues请求完成，i="+i);
            return result;
        }catch(Exception e){
            logger.error("定制redis_listAddValues请求异常，error：",e);
            return JsonResult.error("-1","定制redis_listAddValues请求异常");
        }

    }

    @RequestMapping("/listLeftPush")
    public JsonResult listLeftPush(@RequestBody RedisListRequest request) {

        try {
            logger.info("定制redis_listLeftPush请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            Long i = redisTemplate.opsForList().leftPush(request.getKey(), request.getValue());
            logger.info("定制redis_listLeftPush请求完成，i={}",i);
            result.setMessage("定制redis_listLeftPush请求完成，i="+i);
            return result;
        }catch(Exception e){
            logger.error("定制redis_listLeftPush请求异常，error：",e);
            return JsonResult.error("-1","定制redis_listLeftPush请求异常");
        }

    }

    @RequestMapping("/listLeftPop")
    public JsonResult listLeftPop(@RequestBody RedisListRequest request) {

        try {
            logger.info("定制redis_listLeftPop请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            // 注： pop是不需要值得
            Object object = redisTemplate.opsForList().leftPop(request.getKey());
            logger.info("定制redis_listLeftPop请求完成，object={}",JSON.toJSONString(object));
            result.setMessage("定制redis_listLeftPush请求完成,object="+JSON.toJSONString(object));
            return result;
        }catch(Exception e){
            logger.error("定制redis_listLeftPush请求异常，error：",e);
            return JsonResult.error("-1","定制redis_listLeftPush请求异常");
        }

    }

    @RequestMapping("/listShowAll")
    public JsonResult listShowAll(@RequestBody RedisListRequest request) {

        try {
            logger.info("定制redis_listShowAll请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            // 小技巧，遍历全部
            Object object = redisTemplate.opsForList().range(request.getKey(),0,-1);
            logger.info("定制redis_listShowAll请求完成，object={}",JSON.toJSONString(object));
            result.setMessage("定制redis_listShowAll请求完成,object="+JSON.toJSONString(object));
            return result;
        }catch(Exception e){
            logger.error("定制redis_listShowAll请求异常，error：",e);
            return JsonResult.error("-1","定制redis_listShowAll请求异常,error="+e.getMessage());
        }

    }


    @RequestMapping("/setZset")
    public JsonResult setZset(@RequestBody RedisZsetRequest request) {

        try {
            logger.info("定制redis_setZset请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();

            Boolean flag = redisTemplate.opsForZSet().add(request.getKey(), request.getValue(), request.getScore());
            logger.info("定制redis_setZset请求完成，flag={}",flag);
            result.setMessage("定制redis_setZset请求完成,条数="+flag);
            return result;
        }catch(Exception e){
            logger.error("定制redis_setZset请求异常，error：",e);
            return JsonResult.error("-1","定制redis_setZset请求异常,error="+e.getMessage());
        }

    }


    @RequestMapping("/zsetRangeMembersAndScores")
    public JsonResult zsetRangeMembersAndScores(@RequestBody RedisZsetRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_zsetRangeMembersAndScores请求开始，request={}", JSON.toJSONString(request));
            Set set = redisTemplate.opsForZSet().range(request.getKey(), request.getStart(), request.getEnd());
            ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
            ArrayList<Object> zsetList = new ArrayList<>();
            RedisZsetEntity zsetEntity=null;
            for (Object item: set) {
                zsetEntity = new RedisZsetEntity();
                Double score = zSetOps.score(request.getKey(), item);
                zsetEntity.setKey(request.getKey());
                zsetEntity.setValue(item.toString());
                zsetEntity.setScore(score);
                zsetList.add(zsetEntity);
            }
            result=JsonResult.success(zsetList);
            logger.info("定制redis_zsetRangeMembersAndScores请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_zsetRangeMembersAndScores请求异常，error：",e);
            return JsonResult.error("-1","定制redis_zsetRangeMembersAndScores请求异常,error="+e.getMessage());
        }

    }

    @RequestMapping("/zsetIncrementScore")
    public JsonResult zsetIncrementScore(@RequestBody RedisZsetRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_zsetIncrementScore请求开始，request={}", JSON.toJSONString(request));
            ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
            Double yScore = zSetOps.score(request.getKey(), request.getValue());
            Double newScore = zSetOps.incrementScore(request.getKey(), request.getValue(), request.getDelta());
            result.setMessage("定制redis_zsetIncrementScore请求完成，yScore={}"+yScore+",newScore="+ newScore);
            logger.info("定制redis_zsetIncrementScore请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_zsetIncrementScore请求异常，error：",e);
            return JsonResult.error("-1","定制redis_zsetIncrementScore请求异常,error="+e.getMessage());
        }

    }


    @RequestMapping("/zsetIntersectAndStore")
    public JsonResult zsetIntersectAndStore(@RequestBody RedisZsetRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("定制redis_zsetIntersectAndStore请求开始，request={}", JSON.toJSONString(request));
            ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
            zSetOps.intersectAndStore(request.getKey(), request.getOtherKey(), request.getDestKey());
            // 新集合
            logger.info("定制redis_zsetIntersectAndStore请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("定制redis_zsetIntersectAndStore请求异常，error：",e);
            return JsonResult.error("-1","定制redis_zsetIntersectAndStore请求异常,error="+e.getMessage());
        }

    }




    public JsonResult removeFromList(@RequestBody RedisListRequest request) {

        try {
            logger.info("定制redis_removeFromList请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            // 小技巧，遍历全部
            Long i = redisTemplate.opsForList().remove(request.getKey(), request.getCount(), request.getValue());
            logger.info("定制redis_removeFromList请求完成，条数={}",i);
            result.setMessage("定制redis_removeFromList请求完成,条数="+i);
            return result;
        }catch(Exception e){
            logger.error("定制redis_removeFromList请求异常，error：",e);
            return JsonResult.error("-1","定制redis_removeFromList请求异常,error="+e.getMessage());
        }

    }



}

实体类

关于实体类是用一个Request兼容各种请求好，还是分别写好，左右思量，还是分别写好。

通用请求类

@Data
public class RedisRequest {
    private String key;
    private String value;
}

map请求类

@Data
public class RedisMapRequest {
    private String key;
    private String sonKey;
    private String sonValue;
    private Map<String, Object> map;
}

list请求类

@Data
public class RedisListRequest {
    private String key;
    private String value;
    private Long count;
    private String[] values;
}

zset请求类

zset相比普通set，多了个score，所以用于排序等非常方便。

@Data
public class RedisZsetRequest {
    private String key;
    private String value;
    private double score;
    private long start;
    private long end;
    private long delta;

    private String otherKey;
    private String[] otherKeys;
    private String destKey ;
}

zset实体类

@Data
public class RedisZsetEntity {

    private String key;
    private String value;
    private Double score;
}

附录

Key Type Operations：

接口	描述
GeoOperations	Redis geospatial operations like GEOADD, GEORADIUS,…​)
HashOperations	Redis hash operations
HyperLogLogOperations	Redis HyperLogLog operations like (PFADD, PFCOUNT,…​)
ListOperations	Redis list operations
SetOperations	Redis set operations
ValueOperations	Redis string (or value) operations
ZSetOperations	Redis zset (or sorted set) operations

Key Bound Operations：

接口	描述
BoundGeoOperations	Redis key bound geospatial operations.
BoundHashOperations	Redis hash key bound operations
BoundKeyOperations	Redis key bound operations
BoundListOperations	Redis list key bound operations
BoundSetOperations	Redis set key bound operations
BoundValueOperations	Redis string (or value) key bound operations
BoundZSetOperations	Redis zset (or sorted set) key bound operations
官网文档地址：
https://docs.spring.io/spring-data/redis/docs/2.0.3.RELEASE/reference/html/#redis:template

其他

让锁过期，如何操作

1、直接删除该redis缓存。
2、手动设置超时时间1秒，马上就过期了。