> set books java
OK
> get books
java
> MSET name zhangsan age 18
OK
> mget name age
zhangsan
18
> STRLEN name
8
> SETNX name zhangsan
0
> SETEX address 30 beijing
OK
> TTL address
18
> INCR age
19
> INCR age
20
> GET age
20
> DECR age
19
> APPEND name ',hello world'
20
> GET name
zhangsan,hello world
> GETRANGE name 0 4
zhang
> GETRANGE name 0 3
zhan
> keys *
name
key1
count
books
key2
age
> EXISTS count
1
> del count
1
> GETSET db redis
null
> GET db
redis

> LPUSH books java python go
3
> LLEN books
3
> LRANGE books 0 -1
go
python
java
> LPUSH books javascript
4
> LRANGE books 0 -1
javascript
go
python
java
> RPUSH books c
5
> LRANGE books 0 -1
javascript
go
python
java
c
> RPOP books
c
> LRANGE books 0 -1
javascript
go
python
java
> LPOP books
javascript
> LRANGE books 0 -1
go
python
java
> LINDEX books 0
go
> LINDEX books 2
java
> LSET books 2 javascript
OK
> LRANGE books 0 -1
go
python
javascript

> HSET userInfo-1 name zhangsan
1
> HSET userInfo-1 age 18
1
> HSET userInfo-1 sex male
1
> HGET userInfo-1 name
zhangsan
> HMSET userInfo-2 name lisi age 20 sex female
OK
> HMGET userInfo-1 name age sex
zhangsan
18
male
> HGETALL userInfo-1
name
zhangsan
age
18
sex
male
> HEXISTS userInfo-1 name
1
> HDEL userInfo-1 sex
1
> HGETALL userInfo-1
name
zhangsan
age
18
> HLEN userInfo-1
2
> HSETNX userInfo-1 name zhangsan
0
> HINCRBY userInfo-1 age 5
23
> HGETALL userInfo-1
name
zhangsan
age
23

> sadd db oracle mysql sqlite
3
> SADD db mysql
0
> SMEMBERS db
oracle
mysql
sqlite
> SCARD db
3
> SISMEMBER db oracle
1
> SREM db mysql
1
> SMEMBERS db
oracle
sqlite
> SADD db1 mysql oracle hbase
3
> SINTERSTORE db2 db db1
1
> SMEMBERS db2
oracle
> SUNION db db1
oracle
sqlite
mysql
hbase
> SDIFF db db1
sqlite
> SRANDMEMBER db1 2
oracle
hbase
> SPOP db1 2
oracle
hbase
> SMEMBERS db1
mysql

> zadd salary 3000 zhangsan 4000 lisi 8000 wangwu
3
> ZSCORE salary zhangsan
3000
> ZADD salary 12000 zhaoliu
1
> ZCARD salary
4
> ZRANGEBYSCORE salary 3000 5000
zhangsan
lisi
> ZRANGEBYSCORE salary 3000 5000 WITHSCORES
zhangsan
3000
lisi
4000
> ZREVRANK salary zhaoliu
0
> ZREVRANK salary wangwu
1
> ZINTERSTORE salary2 2 salary salary1
1
> ZRANGE salary 0 -1 withscores
zhangsan
3000
lisi
4000
wangwu
8000
> ZRANGE salary2 0 -1 withscores
zhangsan
6000
> ZUNIONSTORE salary3 2 salary salary1
5
> ZRANGE salary3 0 -1 withscores
lisi
4000
tony
5000
tom
6000
zhangsan
6000
wangwu
8000
> ZDIFFSTORE salary4 2 salary salary1
2
> ZRANGE salary4 0 -1 withscores
lisi
4000
wangwu
8000
> ZREVRANGE salary 0 -1
wangwu
lisi
zhangsan
> ZREM salary zhangsan
1

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

import com.alibaba.fastjson.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.types.RedisClientInfo;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    private static final Logger LOG = LoggerFactory.getLogger(RedisUtil.class);
    /**
     * 默認(rèn)過期時(shí)間，單位：秒，即，24個(gè)小時(shí) 后 過期
     */
    public static final long DEFAULT_EXPIRE = 60 * 60 * 24;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource(name = "strRedisTemplate")
    private RedisTemplate<String, String> stringRedisTemplate;

    /**
     * set 方法
     *
     * @param key   key
     * @param value value
     */
    public void set(String key, Object value) {
        set(key, value, null);
    }

    public void setWithDefaultExpire(String key, Object value) {
        set(key, value, DEFAULT_EXPIRE);
    }


    /**
     * @param key    redis key
     * @param value  redis值
     * @param expire 過期時(shí)間，秒
     */
    public void set(String key, Object value, Long expire) {
        if (expire != null && expire.longValue() != 0L) {
            redisTemplate.boundValueOps(key).set(value, expire, TimeUnit.SECONDS);
        } else {
            redisTemplate.boundValueOps(key).set(value);
        }
    }

    /**
     * @param key    redis key
     * @param value  redis值
     * @param expire 過期時(shí)間，秒
     */
    public void setString(String key, String value, Long expire) {
        if (expire != null && expire.longValue() != 0L) {
            stringRedisTemplate.boundValueOps(key).set(value, expire, TimeUnit.SECONDS);
        } else {
            stringRedisTemplate.boundValueOps(key).set(value);
        }
    }

    public Double increment(String key, double score) {
        return redisTemplate.opsForValue().increment(key, score);
    }

    /**
     * 獲取redis value
     *
     * @param key
     * @return Object 對(duì)象
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 判斷key是否存在
     *
     * @param key
     * @return Set 集合
     */
    public Set<String> keys(String key) {
        return redisTemplate.keys(key);
    }

    public void deleteKeys(Set<String> keys) {
        redisTemplate.delete(keys);
    }


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

    public void delete(String key) {
        redisTemplate.delete(key);
    }

    public void expire(String key, Long expire) {
        redisTemplate.expire(key, expire, TimeUnit.SECONDS);
    }

    public Boolean hsetAbsent(String key, String hkey, Object value) {
        return redisTemplate.opsForHash().putIfAbsent(key, hkey, value);
    }

    public void hset(String key, String hkey, Object value) {
        redisTemplate.opsForHash().put(key, hkey, value);
    }

    public void hmset(String key, Map<?, ?> hashMap) {
        redisTemplate.opsForHash().putAll(key, hashMap);
    }

    public Long lpushString(String key, String val) {
        return stringRedisTemplate.boundListOps(key).leftPush(val);
    }

    public String rpopString(String key) {
        return stringRedisTemplate.boundListOps(key).rightPop();
    }

    public Long llen(String key) {
        return stringRedisTemplate.boundListOps(key).size();
    }

    public Properties info() {
        RedisConnection connection = null;
        Properties p = null;
        try {
            connection = redisTemplate.getConnectionFactory().getConnection();
            p = connection.info("memory");
        } catch (Exception e) {
            LOG.error("redis獲取連接失敗", e);
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
        return p;
    }

    public String clients() {
        List<RedisClientInfo> clientList = redisTemplate.getClientList();
        return JSON.toJSONString(clientList);
    }

    /**
     * 左邊入隊(duì)
     */
    public Long lpush(String key, Object val) {
        return redisTemplate.boundListOps(key).leftPush(val);
    }

    /**
     * 右邊出隊(duì)
     */
    public Object rpop(String key) {
        return redisTemplate.boundListOps(key).rightPop();
    }

    /**
     * 右邊出隊(duì)
     */
    public String rpop(String key, Integer timeout) {
        return stringRedisTemplate.opsForList().rightPop(key, timeout, TimeUnit.SECONDS);
    }

    public Object hget(String key, String hkey) {
        return redisTemplate.opsForHash().get(key, hkey);
    }

    public String hgetStr(String key, String hkey) {
        return (String) stringRedisTemplate.opsForHash().get(key, hkey);
    }

    public Long hdel(String key, String hkey) {
        return redisTemplate.opsForHash().delete(key, hkey);
    }

    public void hincrement(String key, String hkey) {
        redisTemplate.opsForHash().increment(key, hkey, 1);
    }

    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    public Double zscore(String key, Object val) {
        return stringRedisTemplate.opsForZSet().score(key, val);
    }

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

    public Long zadd(String key, Set<ZSetOperations.TypedTuple<String>> tuples) {
        return stringRedisTemplate.opsForZSet().add(key, tuples);
    }

    public void zaddObj(String key, Object value, double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }

    public Long removeRangeByScoreObj(String key, double minScore, double maxScore) {
        return redisTemplate.opsForZSet().removeRangeByScore(key, minScore, maxScore);
    }

    public Long removeRangeByObj(String key, Object value) {
        return redisTemplate.opsForZSet().remove(key, value);
    }

    public Long removeRangeByScoreStr(String key, double minScore, double maxScore) {
        return stringRedisTemplate.opsForZSet().removeRangeByScore(key, minScore, maxScore);
    }

    public Double zStringScore(String key, Object value) {
        return stringRedisTemplate.opsForZSet().score(key, value);

    }

    public Set<String> zrangeByScore(String key, double minScore, double maxScore) {
        return stringRedisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore);
    }

    public Set<String> zreverseRangeByScore(String key, double minScore, double maxScore) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, minScore, maxScore);
    }

    public Set<String> zrangeByScore(String key, double minScore, double maxScore, long offset, long count) {
        return stringRedisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore, offset, count);
    }

    public Set<String> zreverseRangeByScore(String key, double minScore, double maxScore, long offset, long count) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, minScore, maxScore, offset, count);
    }

    public Set zrangeByScoreObj(String key, double minScore, double maxScore) {
        return redisTemplate.opsForZSet().rangeByScore(key, minScore, maxScore);
    }

    public Long zrank(String key, String value) {
        return stringRedisTemplate.opsForZSet().rank(key, value);
    }

    public void zremObj(String key, String member) {
        redisTemplate.opsForZSet().remove(key, member);
    }

    public Long zremStr(String key, String member) {
        return stringRedisTemplate.opsForZSet().remove(key, member);
    }

    public Map<Object, Object> hGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    public Set<Object> hkeys(String key){
        return redisTemplate.opsForHash().keys(key);
    }

    public List<Object> hValues(String key) {
        return redisTemplate.opsForHash().values(key);
    }


    public Map<String, String> hGetAllConvertString(String key) {
        Map<Object, Object> tmp = redisTemplate.opsForHash().entries(key);
        return tmp != null ? convertToString(tmp) : null;
    }

    public Set<ZSetOperations.TypedTuple<Object>> rangeByScoreWithScores(String name, double min, double max, long offset, long count) {
        return redisTemplate.opsForZSet().rangeByScoreWithScores(name, min, max, offset, count);
    }

    public Set<ZSetOperations.TypedTuple<String>> strRangeByScoreWithScores(String name, double min, double max, long offset, long count) {
        return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(name, min, max, offset, count);
    }

    public Set<String> strZRange(String key, int start, int end) {
        return stringRedisTemplate.opsForZSet().range(key, start, end);
    }

    public Set<ZSetOperations.TypedTuple<String>> strZRangeWithScores(String key, int start, int end) {
        return stringRedisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    public Double strIncrementScore(String key, String value, double delta) {
        return stringRedisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    public Double incrementScore(String key, String value, double score) {
        return redisTemplate.opsForZSet().incrementScore(key, value, score);
    }

    public Set<String> members(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    public boolean isMembers(String key, String value) {
        return stringRedisTemplate.opsForSet().isMember(key, value);
    }

    public Set<String> sMembersStr(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    public void sAddStr(String key, String value) {
        stringRedisTemplate.opsForSet().add(key, value);
    }

    public void sAdd(String key, Object val) {
        redisTemplate.opsForSet().add(key, val);
    }

    public String sPop(String key) {
        return stringRedisTemplate.opsForSet().pop(key);
    }

    public void leftPush(String key, String value) {
        stringRedisTemplate.boundListOps(key).leftPush(value);
    }

    public void sRemoveStr(String key, String value) {
        stringRedisTemplate.opsForSet().remove(key, value);
    }

    public void publish(String channel, String value) {
        stringRedisTemplate.convertAndSend(channel, value);
    }


    public static Map<String, String> convertToString(Map<Object, Object> map) {
        Objects.requireNonNull(map);
        Map<String, String> result = new ConcurrentHashMap<>(map.size());
        map.forEach((key, value) -> result.put(key.toString(), value.toString()));
        return result;
    }
}