Redis的五种基本数据类型解读(String、List、Hash、Set、ZSet)

> 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);
    /**
     * 默认过期时间，单位：秒，即，24个小时 后 过期
     */
    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 过期时间，秒
     */
    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 过期时间，秒
     */
    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 对象
     */
    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);
    }

    /**
     * 左边入队
     */
    public long lpush(string key, object val) {
        return redistemplate.boundlistops(key).leftpush(val);
    }

    /**
     * 右边出队
     */
    public object rpop(string key) {
        return redistemplate.boundlistops(key).rightpop();
    }

    /**
     * 右边出队
     */
    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;
    }
}