redis常用命令与常用api

---

前言

本篇主要记录redis的常用命令跟java开发中常用到的api

---

一、基本数据类型

redis可以存储5种不同数据结构类型之间的映射

结构类型	结构存储的值	结构的读写能力
STRING	可以是字符串、整数或者浮点数	key-value形式；对整数和浮点数执行自增或者自减操作
LIST	一个链表，链表上的节点都包含了字符串	链表两端插入或者弹出；对链表进行修建；读取单个或者多个元素；根据值查找或者删除
SET	元素不重复、无序的collection	添加、获取、删除单个元素；检查元素是否存在；计算交集、并集、差集；从集合中随机取
HASH	包含字符串的无序散列表	添加、获取、移除单个键值对；获取所有键值对
ZSET(有序集合)	字符串成员与浮点数分值之间的有序映射，元素的排列顺序由分值决定	添加、获取、删除单个元素；根据分值范围(range)或者成员来获取元素

二、数据类型相关命令与api

引入坐标依赖

<dependencyManagement>
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-dependenciesartifactId>
                <version>${spring-boot.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
dependencyManagement>

<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starterartifactId>
dependency>
  <dependency>
    <groupId>org.springframework.bootgroupId>
     <artifactId>spring-boot-starter-data-redisartifactId>
  dependency>      

1.STRING

命令	用例和描述
INCR	INCR key-name 将键存储的值加上1
DECR	DECR key-name 将键存储的值减1
INCRBY	INCRBY key-name amount 将键值存储的值加上amount
DECRBY	DECRBY key-name amount 将键值存储的值减去整数amount
INCRBYFLOAT	INCRBYFLOAT key-name amount 将键值对的值加上浮点数amount

命令	用例和描述
APPEND	APPEND key-name value 将值value追加到给定键key-name当前存储的值得末尾
GETRANGE	GETRANGE key-name start end 获取一个由偏移量start至偏移量end范围内所有字符组成的子串，包括start 和end
STRLEN	STRLEN key-name 返回字符串长度
SETRANGE	SETRANGE key-name offset value 将从offset偏移量开始的子串设置给定的值
GETBIT	GETBIT key-name offset 将字符串看成是二进制位串 并返回位串中偏移量位offset的二进制位的值
SETBIT	SETBIT key-name offset value 将字符串看成是二进制位串 并将偏移量位offset的值设置成value

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public String get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public long incr(String key, Long delta) {
        return redisTemplate.opsForValue().increment(key, Optional.ofNullable(delta).orElse(1L));
    }

    public long decr(String key, Long delta) {
        return redisTemplate.opsForValue().decrement(key, Optional.of(delta).orElse(1L));
    }

    public int append(String key, String val) {
        return redisTemplate.opsForValue().append(key, val);
    }

    public String getRange(String key, int start, int end) {
        return redisTemplate.execute((RedisCallback<String>) (connection) -> {
            byte[] range = connection.getRange(key.getBytes(StandardCharsets.UTF_8), start, end);
            return Optional.ofNullable(range).map(r -> new String(range)).orElse(null);
        });
    }
}

2.列表

命令	用例和描述
RPUSH	RPUSH key-name value [value …] 将一个或者多个值推入到右端
LPUSH	LPUSH key-name value [value …] 将一个或者多个值推入到左端
RPOP	RPOP key-name 移除并返回列表最右端的元素
LPOP	LPOP key-name 移除并返回列表最左端的元素
LINDEX	LINDEX key-name offset 返回列表偏移量为offset的元素
LRANGE	LRANGE key-name start end 返回列表从start偏移量到end偏移量范围内的所有元素，包含start和end
LTRIM	LTRIM key-name start end 对列表进行修剪，只保留从start偏移量到end偏移量范围的元素，包含start和end

命令	用例和描述
BLPOP	BLPOP key-name [key-name …] timeout 从第一个非空列表中弹出位于最左端的元素 或者timeout秒内阻塞并等待可弹出元素出现
BRPOP	BLPOP key-name [key-name …] timeout 从第一个非空列表中弹出位于最右端的元素 或者timeout秒内阻塞并等待可弹出元素出现
RPOPLPUSH	RPOPLPUSH source-key desc-key 从source-key 列表中弹出位于最右端的元素 并将这个元素从左端推入到desc-key列表中,并向用户返回这个元素
BRPOPLPUSH	RPOPLPUSH source-key desc-key timeout 从source-key 列表中弹出位于最右端的元素 并将这个元素从左端推入到desc-key列表中,并向用户返回这个元素;如果source-key为空，在timeout秒之内等等可弹出元素

 public long rpush(String key, Collection<String> values) {
        return redisTemplate.opsForList().rightPushAll(key, values.toArray(new String[0]));
    }

    public String rpop(String key) {
        return redisTemplate.opsForList().rightPop(key);
    }

    public Collection<String> lrange(String key, long start, long end) {
        return redisTemplate.execute((RedisCallback<List<String>>) connection -> {
            List<byte[]> bytes = connection.lRange(key.getBytes(StandardCharsets.UTF_8), start, end);
            return Optional.ofNullable(bytes).map(each -> each.stream().map(String::new).collect(Collectors.toList())).orElse(null);
        });
    }

    public Collection<String> brpop(String key, int timeout) {
        return redisTemplate.execute((RedisCallback<List<String>>) connection -> {
            List<byte[]> bytes = connection.bRPop(timeout, key.getBytes(StandardCharsets.UTF_8));
            return Optional.ofNullable(bytes).map(each -> each.stream().map(String::new).collect(Collectors.toList())).orElse(null);
        });
    }

3.集合

命令	用例和描述
SADD	SADD key-name item [item …] 将一个或者多个元素添加到集合里面， 并返回被添加到元素当中原本并不存在于集合里面的元素数量
SREM	SREM key-name item [item …] 从集合里面移除一个或者多个元素，并返回被移除元素的数量
SISMEMBER	SISMEMBER key-name item 检查元素item是否存在于集合key-name里
SCARD	SCARD key-name 返回集合包含的元素的数量
SMEMBERS	SMEMBERS key-name 返回集合包含的所有元素
SRANDMEMBER	SRANDMEMBER key-name count 从集合中随机返回一个或多个元素；count为正数时，返回的随机数不会重复， 为负数时，返回的随机元素可能会出现重复
SPOP	SPOP key-name 随机移除集合中的一个元素，并返回被移除的元素
SMOVE	SMOVE source-key dest-key item 将item从集合source-key移到dest-key中；成功移除则返回1，否则返回0

命令	用例和描述
SDIFF	SDIFF key-name [key-name …] 返回存在于第一集合但不存在其他集合中的元素
SDIFFSTORE	SDIFFSTORE dest-key key-name [key-name …] 将存在第一集合但不存在其他集合的元素存储到dest-key中
SINTER	SINTER key-name [key-name …] 返回同时存在于所有集合中的元素
SINTERSTORE	SINTERSTORE dest-key key-name [key-name …] 将交集存到dest-key中
SUNION	SUNION key-name [key-name …] 返回给定key的并集
SUNIONSTORE	SUNIONSTORE dest-key key-name [key-name …] 将并集存到dest-key中
ZINTERSTORE	ZINTERSTORE dest-key key-count key [key …] [WEIGHTS weight [weight …]][AGGREGATE SUM|MIN|MAX]

public long sadd(String key, Collection<String> values) {
        return redisTemplate.opsForSet().add(key, values.toArray(new String[0]));
    }

    public long size(String key, String item) {
        return redisTemplate.opsForZSet().size(key);
    }

    public boolean sIsExits(String key, String value) {
        return redisTemplate.execute((RedisCallback<Boolean>) con -> {
            return con.sIsMember(key.getBytes(StandardCharsets.UTF_8), value.getBytes(StandardCharsets.UTF_8));
        });
    }

    public Collection<String> sMembers(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    public Collection<String> sDiff(String key1, String key2) {
        return redisTemplate.opsForSet().difference(key1, key2);
    }

    public Collection<String> sInter(String key1, String key2) {
        return redisTemplate.opsForSet().intersect(key1, key2);
    }

    public Collection<String> sUnion(String key1, String key2) {
        return redisTemplate.opsForSet().union(key1, key2);
    }

4.散列

命令	用例和描述
HMGET	HMGET key-name key [key …]从散列中取一个或多个键的值
HMSET	HMSET key-name key value [key value] 为散列里面的一个或多个键设置值
HDEL	HDEL key-name key [key …] 删除散列里面的一个或多个键值对，返回成功找到并并删除的键值对数量
HLEN	HLEN key-nam 返回散列包含的键值对数量

命令	用例和描述
HEXISTS	HEXISTS key-name key 检查给定键是否存在于散列表中
HKEYS	HKEYS key-name 获取散列包含的所有的键
HVALS	HVALS key-name 获取散列包含所有的值
HGETALL	HGETALL key-name 获取散列包含所有的键值对
HINCRBY	HINCRBY key-name key increment 将键key存储的值加上整数increment
HINCRBYFLOAT	HINCRBYFLOAT key-name key increment 将键key存储的值加上浮点数increment

public void hmSet(String key, Map<String, String> vals) {
        redisTemplate.opsForHash().putAll(key, vals);
    }

    public String hmGet(String key, String field) {
        return String.valueOf(redisTemplate.opsForHash().get(key, field));
    }

    public long hLen(String key) {
        return redisTemplate.opsForHash().size(key);
    }

    public Collection<String> hVals(String key) {
        List<Object> values = redisTemplate.opsForHash().values(key);
        return values.stream().map(String::valueOf).collect(Collectors.toList());
    }

    public Collection<String> hKeys(String key) {
        Set<Object> keys = redisTemplate.opsForHash().keys(key);
        return keys.stream().map(String::valueOf).collect(Collectors.toSet());
    }

5.有序集合

命令	用例和描述
ZADD	ZADD key-name score member [score member …] 将带有给定分值的成员添加到有序集合里面
ZREM	ZREM key-name member [member …] 从有序集合中移除给定的成员，并返回被移除成员的数量
ZCARD	ZCARD key-name 返回有序集合包含的成员数量
ZINCRBY	ZINCRBY key-name increment member 将member成员的分支加上increment
ZCOUNT	ZCOUNT key-name min max 返回分支介于min和max之间的成员数量
ZRANK	ZRANK key-name member 返回成员member在有序集合中的排名，排名按照从小到大
ZREVRANK	ZREVRANK key-name member 返回有序集合里成员member的排名，成员按照分值从大到小排列
ZSCORE	ZSCORE key-name member 返回成员的分值
ZRANGE	ZRANGE key-name start stop [WITHSCORES] 返回有序集合中排名介于start和stop之间的成员。排名从低到高 如果有[WITHSCORES]，成员的分值也一并返回
ZREVRANGE	ZREVRANGE key-name start stop [WITHSCORES] 排名从高到低

命令	用例和描述
ZRANGEBYSCORE	ZRANGEBYSCORE key min max[WITHSCORES][LIMIT offset count] 返回有序集合中分支介于min和max之间的所有成员
ZREVRANGEBYSCORE	ZREVRANGEBYSCORE key min max [WITHSCORES][LIMIT offset count] 获取有序集合中分支介于min和max之间的所有成员，从大到小的顺序
ZREMRANGEBYRANK	ZREMRANGEBYRANK key-name start stop 移除有序集合中排名介于start 和stop之间的所有成员
ZREMRANGEBYSCORE	ZREMRANGEBYSCORE key-name min max 移除有序集合中分值介于min和max之间的所有成员

public boolean zAdd(String key, String value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    // 返回在有序集合中的排名,分值从小到大
    public long zRank(String key, String member) {
        return redisTemplate.opsForZSet().rank(key, member);
    }

    // 返回集合中排名介于start和end之间的成员，分值从低到高
    public Collection<String> zRange(String key, int start, int end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }
	// 获取有序集合中分支介于min和max之间的所有成员，从大到小的顺序
    public Collection<String> zRangeByScore(String key, int min, int max, int offset, int count) {
        Set<ZSetOperations.TypedTuple<String>> all = redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max, offset, count);
        return Optional.ofNullable(all)
                .map(e -> e.stream()
                        .map(ZSetOperations.TypedTuple::getValue)
                        .collect(Collectors.toSet())).orElse(null);
    }

三、其他命令

1.键的过期时间

命令	用例和描述
PERSIST	PERSIST key-name 移除键的过期时间
TTL	TTL key-name 查看给定键距离过期还有多少秒
EXPIPE	EXPIPE key-name seconds 让给定键在指定的秒数之后过期
EXPIPEAT	EXPIPEAT key-name timestamp 将给定键的过期时间设置为给定的UNIX时间戳
PTTL	PTTL key-name 查看给定键过期时间还有多少秒

---

总结

本篇只要总结了常用命令 和开发过程中长用到的操作api