Redis命令

    【本地启动】
    cd 进入到解压的主目录 输入  redis-server.exe  redis.windows.conf  打开服务 
    cd 进入到解压的主目录 输入  redis-cli.exe 打开客户端
    链接服务器  redis-cli.exe -h 192.168.2.92 -p 6379   要在主目录下才可以
    连接redis 不需要 用户名和密码  可以自行设定

    【登录linux下的redis】
    [root@sh-192-168-0-227 bin]# ps -ef|grep redis
    root      3063     1  0 Jun15 ?        00:18:34 /usr/local/bin/redis-server *:6379                        
    root     17894 14186  0 14:21 pts/4    00:00:00 grep redis
    [root@sh-192-168-0-227 bin]# cd /usr/local/bin/
    [root@sh-192-168-0-227 bin]# ./redis-cli 
    127.0.0.1:6379> dbsize
    (integer) 27226
    127.0.0.1:6379> ping
    PONG
    127.0.0.1:6379> 
    在当期目录下 连接服务
    ./redis-cli -h 192.168.100.34 -p 6379 
    192.168.100.34:6379>
     
    CONFIG SET  requirepass "mypass"
    # 设置密码
    redis> CONFIG SET requirepass secret_password   # 将密码设置为 secret_password
    OK
    redis> QUIT                                     # 退出再连接，让新密码对客户端生效
    [huangz@mypad]$ redis
    redis> PING                                     # 未验证密码，操作被拒绝
    (error) ERR operation not permitted
    redis> AUTH wrong_password_testing              # 尝试输入错误的密码
    (error) ERR invalid password
    redis> AUTH secret_password                     # 输入正确的密码
    OK
    redis> PING                                     # 密码验证成功，可以正常操作命令了
    PONG
     
     
    # 清空密码
    redis> CONFIG SET requirepass ""   # 通过将密码设为空字符来清空密码
    OK
    redis> QUIT
    $ redis                            # 重新进入客户端
    redis> PING                        # 执行命令不再需要密码，清空密码操作成功
    PONG
     
    移动数据库里面的数据
    select 0-15
      
    选择数据库
    select 0
     
    set age 20
    get age 
    20
     
    move age 1
    （integer）1已经移除成功
    select 1
    get age
    20
     
    expire age 300过期时间
    ttl age 查看过期时间  
    移除过期时间persist age
    ping 测试连接是否存活
    PONG
    quit 退出客户端
    info 服务器信息
    multi保存队列在里面 
    exec依次执行命令
    discard取消队列里面所有的命令（事务回滚）
    RDB持久化
    命令SAVE BGSAVE（会派生好出一个子进程，然后由子进程负责创建RDB 文件，父进程继续处理命令请求）

    登陆表redis数据

  
    Redis命令总结 
 
    keys * 取出当前匹配的所有key
    如 ： keys hq:0*
 
    > exists larry
     (integer) 0
    当前的key是否存在
 
    del lv  删除当前key
 
    expire 设置过期时间
 
    > move larry ad4
     (integer) 1
    移动larry键值对到ad4数据库
 
    > persist lv
     (integer) 1
    移除当前key的过期时间
 
    randomkey 随机返回一个key
 
    rename 重命名key
 
    type 返回值的数据类型
 
     type testlist
     list
 
     > ping
     PONG
    测试连接是否还在
 
    >echo name
    "larry"
    打印
 
    > select ad4databank
     OK
    数据库切换
 
    当前数据库中key的数量
 
    > info
    服务器基本信息
 
    连接操作相关的命令
    quit：关闭连接（connection）
    auth：简单密码认证
 
    持久化
    save：将数据同步保存到磁盘
    bgsave：将数据异步保存到磁盘
    lastsave：返回上次成功将数据保存到磁盘的Unix时戳
    shundown：将数据同步保存到磁盘，然后关闭服务
 
 
    远程服务控制
    info：提供服务器的信息和统计
    monitor：实时转储收到的请求
    slaveof：改变复制策略设置
    config：在运行时配置Redis服务器
      
    ===============================================================> 
    对value操作的命令
    type(key)：    返回值的类型
    exists(key)：  确认一个key是否存在
    dbsize：       返回当前数据库中key的数目
    del(key)：     删除一个key
    keys(pattern)：返回满足给定pattern的所有key
    randomkey：    随机返回key空间的一个
    keyrename(oldname, newname)：重命名key
    expire：      设定一个key的活动时间（s）
    ttl：         获得一个key的活动时间
    select(index)：按索引查询
    move(key, dbindex)：移动当前数据库中的key到dbindex数据库
    flushdb：     删除当前选择数据库中的所有key
    flushall：    删除所有数据库中的所有key
 
    *********************************************【对String操作的命令】******************************************************
    string是最简单的类型，一个Key对应一个Value。
    string类型是二进制安全的，redis的string可以包含任何数据。
 
    1. set(key, value)：设置一个string类型的key和value（重复添加值会覆盖）           
         如： set name2  Tom
    2. get(key)：获取key对应的value值                                         
         如： get name2
    3. getset(key, value)：给名称为key的string赋予上一次的value
    4. mget(key1, key2,…, key N)：返回库中多个string的value
    5. setnx(key, value)：设置一个key的值string类型的value ，key值不存在则添加，key值存在则返回0：                      
         如： set name  com                       
    6. setex(key, time, value)：设置一个键值key的有效期time                           
         如： setex col 7 red 
    7. setrange(key, value): 设置指定key的value值的子字符串：
    8. strlen(key):  取指定key的value值的长度：        如：127.0.0.1:6379> strlen name
    9. mset(key N, value N)：一次设置多个key的值
    10. mget (key1,key2,key3..) 一次获取多个key的值
        如：127.0.0.1:6379> mset name tom age 25 sex man
            OK
            127.0.0.1:6379> mget name age sex
            1) "tom"
            2) "25"
            3) "man"
    11. msetnx(key N, value N)：设置多个value、不覆盖已存在的key：
        如 127.0.0.1:6379> msetnx name tom age 25 sex man email tom13@163.com
            (integer) 1
            127.0.0.1:6379> mget name age sex email
            1) "tom"
            2) "25"
            3) "man"
            4) "tom13@163.com"
    12. getrange(key, 起始位置，结束位置)
        如：127.0.0.1:6379> get name
            "ma.fenglei"
            127.0.0.1:6379> getrange  name 3 -1
            "fenglei"
    13. incr(key)：对key的值做加加操作,并返回新的值 (类似于i++)
        如：127.0.0.1:6379> get age
            "25"
            127.0.0.1:6379> incr age
            (integer) 26
            127.0.0.1:6379> incr age
            (integer) 27
    14. incrby(key, integer)：加指定值,key不存在设置key,并认为原来的值为0：
        如：127.0.0.1:6379> get age
            "27"
            127.0.0.1:6379> incrby age 5
            (integer) 32
            127.0.0.1:6379> incrby age 5
            (integer) 37
    15. decr(key)：对key的值做减减操作：
        如：127.0.0.1:6379> get age
            "37"
            127.0.0.1:6379> decr age
            (integer) 36
            127.0.0.1:6379> decr age
            (integer) 35
    16. decrby(key, integer)：同decr类似，减<指定值>：
        如：127.0.0.1:6379> get age
            "35"
            127.0.0.1:6379> decrby age 5
            (integer) 30
            127.0.0.1:6379> decrby age 5
            (integer) 25
    17. append(key, value)：给指定的key的字符串追加value，返回新字符串值的长度：
        如：127.0.0.1:6379> get name
            "fenglei"
            127.0.0.1:6379> append name @qq.com
            (integer) 14
            127.0.0.1:6379> get name
            "fenglei@qq.com"
    18. substr(key, start, end)：接取字符串
        如：127.0.0.1:6379> get name
            "fenglei@qq.com"
            127.0.0.1:6379> substr name 2 9
            "nglei@qq"
            127.0.0.1:6379>
    *********************************************【end】******************************************************************
 
 
     
    *********************************************【对List操作的命令】******************************************************
    list是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作中key理解为链表的名字。
 
    1. lpush(key, value)：在key对应list的头部添加字符串元素：
         如：127.0.0.1:6379> lpush mylist world
             (integer) 1
             127.0.0.1:6379> lpush mylist hello
             (integer) 2
             127.0.0.1:6379> lrange mylist 0 -1
             1) "hello"
             2) "world"
             127.0.0.1:6379>
    2. rpush(key, value)：在key对应list的尾部添加字符串元素：  
         如：127.0.0.1:6379> rpush mylist2 hello
             (integer) 1
             127.0.0.1:6379> rpush mylist2 world
             (integer) 2
             127.0.0.1:6379> lrange mylist2 0 -1
             1) "hello"
             2) "world"
    3. lrange(key, start, end)：返回名称为key的list中start至end之间的元素
        如：127.0.0.1:6379> lrange mylist 0 -1  返回key为mylist的所有的值
    4. llen(key)：返回名称为key的list的长度
    5. linsert  在key对应list的特定位置之前或之后添加字符串元素：
        如：127.0.0.1:6379> lrange mylist3 0 -1
            1) "hello"
            2) "world"
            127.0.0.1:6379> linsert mylist3 before world there
            (integer) 3
            127.0.0.1:6379> lrange mylist3 0 -1
            1) "hello"
            2) "there"
            3) "world"
    6. ltrim(key, start, end)：截取名称为key的list
        如：127.0.0.1:6379> lrange mylist8 0 -1
            1) "one"
            2) "two"
            3) "three"
            4) "four"
            127.0.0.1:6379> ltrim mylist8 1 -1
            OK
            127.0.0.1:6379> lrange mylist8 0 -1
            1) "two"
            2) "three"
            3) "four"
    7. lindex(key, index)：返回名称为key的list中index位置的元素：
        如：127.0.0.1:6379> lrange mylist5 0 -1
            1) "foo]"
            2) "hello"
            127.0.0.1:6379> lindex mylist5 0
            "foo]"
            127.0.0.1:6379> lindex mylist5 1
            "hello"
            127.0.0.1:6379>
    8. lset(key, index, value)：设置list中指定下标的元素值(下标从0开始)
        如：127.0.0.1:6379> lrange mylist4 0 -1
            1) "one"
            2) "two"
            3) "three"
            127.0.0.1:6379> lset mylist4 0 four
            OK
            127.0.0.1:6379> lrange mylist4 0 -1
            1) "four"
            2) "two"
            3) "three"
    9. lrem(key, count, value)：从key对应list中删除count个和value相同的元素。
       count>0时，按从头到尾的顺序删除，count<0时，按从尾到头的顺序删除，count=0时，删除全部，
        如：127.0.0.1:6379> lrange mylist5 0 -1
            1) "hello"
            2) "hello"
            3) "foo]"
            4) "hello"
            127.0.0.1:6379> lrem mylist5 2 hello
            (integer) 2
            127.0.0.1:6379> lrange mylist5 0 -1
            1) "foo]"
            2) "hello"
    10. lpop 从list的头部删除元素，并返回删除元素：          
         如：127.0.0.1:6379> lrange mylist 0 -1
            1) "five"
            2) "world"
            127.0.0.1:6379> lpop mylist
            "five"
            127.0.0.1:6379> lrange mylist 0 -1
            1) "world"
    11. rpop(key)：从list的尾部删除元素，并返回删除元素：
    blpop(key1, key2,… key N, timeout)：lpop命令的block版本。
    brpop(key1, key2,… key N, timeout)：rpop的block版本。
    rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部
 
    *********************************************【end】******************************************************************
 
 
 
 
 
   *********************************************【对set操作的命令】******************************************************
 
    对Set操作的命令
    sadd(key, member)：向名称为key的set中添加元素member
    srem(key, member) ：删除名称为key的set中的元素member
    spop(key) ：随机返回并删除名称为key的set中一个元素
    smove(srckey, dstkey, member) ：移到集合元素
    scard(key) ：返回名称为key的set的基数
    sismember(key, member) ：member是否是名称为key的set的元素
    sinter(key1, key2,…key N) ：求交集
    sinterstore(dstkey, (keys)) ：求交集并将交集保存到dstkey的集合
    sunion(key1, (keys)) ：求并集
    sunionstore(dstkey, (keys)) ：求并集并将并集保存到dstkey的集合
    sdiff(key1, (keys)) ：求差集
    sdiffstore(dstkey, (keys)) ：求差集并将差集保存到dstkey的集合
    smembers(key) ：返回名称为key的set的所有元素
    srandmember(key) ：随机返回名称为key的set的一个元素
 
   *********************************************【对hash操作的命令】******************************************************
 
    查看 一个
    192.168.0.227:6379> type  "CG:USER:19842"
    hash
    192.168.0.227:6379> hkeys  "CG:USER:19842"
    1) "usableDecks"
    2) "id"
    3) "battleDeck"
    4) "nicknm"
    5) "prepareHeros"
    192.168.0.227:6379> hget  "CG:USER:19842" "usableDecks"
    "{"0":{"1":1,"2":2,"4":1,"5":1,"6":1,"9":1,"11":1,"15":1,"18
    ":2,"20":1,"22":2,"23":2,"24":1,"27":2,"30":2,"32":2,"33":1,"40
    ":1,"44":1,"45":2,"47":2}}"
    192.168.0.227:6379>
 
    redis.hset("hashs", "key001", "value001");
    对Hash操作的命令  这里key 为设置的键
 
    1. hset(key, field, value)：向名称为key的hash中添加元素field的值value，
       如果哈希表中域字段已经存在且旧值已被新值覆盖
        如：127.0.0.1:6379> hset myhash fp foo
            (integer) 1
            127.0.0.1:6379> hget myhash fp
            "foo"
            127.0.0.1:6379> hset myhash google www.google.com
            (integer) 1
            127.0.0.1:6379> hkeys myhash
            1) "fp"
            2) "google"
    2. hkeys(key): 获取哈希表中的所有的键。
        如：127.0.0.1:6379> hset myhash field1 foo
            (integer) 1
            127.0.0.1:6379> hset myhash field2 bar
            (integer) 1
            127.0.0.1:6379> hkeys myhash
            1) "field1"
            2) "field2"
            127.0.0.1:6379> hget myhash field2
            "bar"
            127.0.0.1:6379> 
    2. hget(key, field)：返回名称为key的hash中field对应的value
    3. hmset(key, (fields))：同时将多个 field-value (字段-值)对设置到哈希表中。
        如： 127.0.0.1:6379> hmset myhash2 name tom age 28
             OK
             127.0.0.1:6379> hget myhash2 name
             "tom"
             127.0.0.1:6379> hget myhash2 age
             "28"
    4. hmget(key, (fields))：获取全部指定的hash field。
         如：127.0.0.1:6379> hkeys myhash2
             1) "name"
             2) "age"
             127.0.0.1:6379> hmget myhash2 name
             1) "tom"
             127.0.0.1:6379> hmget myhash2 name age
             1) "tom"
             2) "28"
             127.0.0.1:6379>
    5. hincrby(key, field, integer)：将名称为key的hash中field的value增加integer
         如：127.0.0.1:6379> hset user:002 age 29
             (integer) 1
             127.0.0.1:6379> hget user:002 age
             "29"
             127.0.0.1:6379> hincrby user:002 age 5
             (integer) 34
             127.0.0.1:6379> hget user:002 age
             "34"
             127.0.0.1:6379> hkeys user:002
             1) "age"
    6. hexists(key, field)：测试指定field在hash中是否存在。返回1为存在，0为不存在
         如：127.0.0.1:6379> hexists user:002 name
             (integer) 0
             127.0.0.1:6379> hexists user:002 age
             (integer) 1
    7. hdel(key, field)：删除指定hash的field。
    8. hlen(key)：返回名称为key的hash中元素个数
    9. hvals(key)：返回hash的所有value。
         如：127.0.0.1:6379> hvals user:002
             1) "34"
             2) "tom]"
             127.0.0.1:6379> hkeys user:002
             1) "age"
             2) "name"
    10. hgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value
         如：127.0.0.1:6379> hkeys user:002
             1) "age"
             2) "name"
             127.0.0.1:6379> hgetall user:002
             1) "age"
             2) "34"
             3) "name"
             4) "tom]"
 
 
 
 
    Redis文件夹有以下几个文件
       redis-server.exe：服务程序
       redis-check-dump.exe：本地数据库检查
       redis-check-aof.exe：更新日志检查
       redis-benchmark.exe：性能测试，用以模拟同时由N个客户端发送M个 SETs/GETs 查询 (类似于 Apache 的ab 工具).
      目前只用了 redis-server.exe,它是启动redis服务的，它在服务器上执行就可以了，我们可以写个BAT文件让它去执行autorunRedis.bat 
 

 --------------------------------------------------------------------------------------------------------------------------------

 
 
 package com.aug3.storage.redisclient.practice;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;

import java.util.*;

/**
 * Created by fenglei.ma on 2018/3/30. 16:37
 */
public class RedisTest1 {


    public static void main(String[] args) {
        Jedis redis = new Jedis("192.168.100.34", 6379);

        /* -----------------------------------------------------------------------------------------------------------  */

        //KEYS 操作
        Set keys = redis.keys("*");//列出所有的key，查找特定的key如：redis.keys("foo")
        Iterator t1 = keys.iterator();
        while (t1.hasNext()) {
            Object obj1 = t1.next();
            System.out.println(obj1);
        }

        //DEL 移除给定的一个或多个key。如果key不存在，则忽略该命令。
        redis.del("name1");

        //TTL 返回给定key的剩余生存时间(time to live)(以秒为单位)
        redis.ttl("foo");

        //PERSIST key 移除给定key的生存时间。
        redis.persist("foo");

        //EXISTS 检查给定key是否存在。
        redis.exists("foo");

        //MOVE key db  将当前数据库(默认为0)的key移动到给定的数据库db当中。如果当前数据库(源数据库)和给定数据库(目标数据库)有相同名字的给定key，或者key不存在于当前数据库，那么MOVE没有任何效果。
        redis.move("foo", 1);//将foo这个key，移动到数据库1

        //RENAME key newkey  将key改名为newkey。当key和newkey相同或者key不存在时，返回一个错误。当newkey已经存在时，RENAME命令将覆盖旧值。
        redis.rename("foo", "foonew");

        //TYPE key 返回key所储存的值的类型。
        System.out.println(redis.type("foo"));//none(key不存在),string(字符串),list(列表),set(集合),zset(有序集),hash(哈希表)

        //EXPIRE key seconds 为给定key设置生存时间。当key过期时，它会被自动删除。
        redis.expire("foo", 5);//5秒过期
        //EXPIREAT EXPIREAT的作用和EXPIRE一样，都用于为key设置生存时间。不同在于EXPIREAT命令接受的时间参数是UNIX时间戳(unix timestamp)。

        //一般SORT用法 最简单的SORT使用方法是SORT key。
        redis.lpush("sort", "1");
        redis.lpush("sort", "4");
        redis.lpush("sort", "6");
        redis.lpush("sort", "3");
        redis.lpush("sort", "0");

        List list = redis.sort("sort");//默认是升序
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        /* -----------------------------------------------------------------------------------------------------------  */
        //   STRING 操作

        //SET key value将字符串值value关联到key。
        redis.set("name", "wangjun1");
        redis.set("id", "123456");
        redis.set("address", "guangzhou");

        //SETEX key seconds value将值value关联到key，并将key的生存时间设为seconds(以秒为单位)。
        redis.setex("foo", 5, "haha");

        //MSET key value [key value ...]同时设置一个或多个key-value对。
        redis.mset("haha", "111", "xixi", "222");

        //redis.flushAll();清空所有的key
        System.out.println(redis.dbSize());//dbSize是多少个key的个数

        //APPEND key value如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。
        redis.append("foo", "00");//如果key已经存在并且是一个字符串，APPEND命令将value追加到key原来的值之后。

        //GET key 返回key所关联的字符串值
        redis.get("foo");

        //MGET key [key ...] 返回所有(一个或多个)给定key的值
        List list2 = redis.mget("haha", "xixi");
        for (int i = 0; i < list2.size(); i++) {
            System.out.println(list2.get(i));
        }

        //DECR key将key中储存的数字值减一。
        //DECRBY key decrement将key所储存的值减去减量decrement。
        //INCR key 将key中储存的数字值增一。
        //INCRBY key increment 将key所储存的值加上增量increment。


        /* -----------------------------------------------------------------------------------------------------------  */
        //  Hash 操作

        //HSET key field value将哈希表key中的域field的值设为value。
        redis.hset("website", "google", "www.google.cn");
        redis.hset("website", "baidu", "www.baidu.com");
        redis.hset("website", "sina", "www.sina.com");

        //HMSET key field value [field value ...] 同时将多个field - value(域-值)对设置到哈希表key中。
        Map map = new HashMap();
        map.put("cardid", "123456");
        map.put("username", "jzkangta");
        redis.hmset("hash", map);

        //HGET key field返回哈希表key中给定域field的值。
        System.out.println(redis.hget("hash", "username"));

        //HMGET key field [field ...]返回哈希表key中，一个或多个给定域的值。
        List list3 = redis.hmget("website", "google", "baidu", "sina");
        for (int i = 0; i < list3.size(); i++) {
            System.out.println(list3.get(i));
        }

        //HGETALL key返回哈希表key中，所有的域和值。
        Map<String, String> map1 = redis.hgetAll("hash");
        for (Map.Entry entry : map1.entrySet()) {
            System.out.print(entry.getKey() + ":" + entry.getValue() + "	");
        }

        //HDEL key field [field ...]删除哈希表key中的一个或多个指定域。
        //HLEN key 返回哈希表key中域的数量。
        //HEXISTS key field查看哈希表key中，给定域field是否存在。
        //HINCRBY key field increment为哈希表key中的域field的值加上增量increment。
        //HKEYS key返回哈希表key中的所有域。
        //HVALS key返回哈希表key中的所有值。


        /* -----------------------------------------------------------------------------------------------------------  */
        // LIST 操作
        //LPUSH key value [value ...]将值value插入到列表key的表头。
        redis.lpush("list", "abc");
        redis.lpush("list", "xzc");
        redis.lpush("list", "erf");
        redis.lpush("list", "bnh");

        //LRANGE key start stop返回列表key中指定区间内的元素，区间以偏移量start和stop指定。下标(index)参数start和stop都以0为底，也就是说，以0表示列表的第一个元素，以1表示列表的第二个元素，以此类推。你也可以使用负数下标，以-1表示列表的最后一个元素，-2表示列表的倒数第二个元素，以此类推。
        List list4 = redis.lrange("list", 0, -1);
        for (int i = 0; i < list4.size(); i++) {
            System.out.println(list4.get(i));
        }

        //LLEN key返回列表key的长度。
        //LREM key count value根据参数count的值，移除列表中与参数value相等的元素。

        /* -----------------------------------------------------------------------------------------------------------  */
        //  SET 操作
        //SADD key member [member ...]将member元素加入到集合key当中。
        redis.sadd("testSet", "s1");
        redis.sadd("testSet", "s2");
        redis.sadd("testSet", "s3");
        redis.sadd("testSet", "s4");
        redis.sadd("testSet", "s5");

        //SREM key member移除集合中的member元素。
        redis.srem("testSet", "s5");

        //SMEMBERS key返回集合key中的所有成员。
        Set set = redis.smembers("testSet");
        Iterator t12 = set.iterator();
        while (t1.hasNext()) {
            Object obj1 = t12.next();
            System.out.println(obj1);
        }

        //SISMEMBER key member判断member元素是否是集合key的成员。是（true），否则（false）
        System.out.println(redis.sismember("testSet", "s4"));

    }

    public void testredis() {
        System.out.println("start");

        Jedis redis = new Jedis("192.168.100.34", 6379);
        Pipeline pipelined = redis.pipelined();
        pipelined.set("test:key_569", "val1154564654653553");
        pipelined.sync();
        System.out.println("读取" + redis.get("test:key_569"));
        System.out.println();

        String value = String.format("%s|%s|%s|%s|%s", new Object[]{"10:38:51", "12.36", "385234.0", "3832461.32", "10.03"});
        pipelined.rpush("test:practice5", value);
        pipelined.sync();
        System.out.println("写入数据完成");
        System.out.println("读取" + redis.rpop("test:practice5"));
        System.out.println();

        Map<String, String> ssMap = new HashMap<String, String>();
        ssMap.put("name", "fangshijiu");
        ssMap.put("address", "浦江镇");
        ssMap.put("salary", "8000");
        ssMap.put("age", "28");
        pipelined.hmset("test:practice4", ssMap);
        pipelined.sync();
        System.out.println("写入数据完成");

        System.out.println("读取");
        Map<String, String> stringStringMap = redis.hgetAll("test:practice4");
        for (String key : stringStringMap.keySet()) {
            System.out.println(key + " : " + stringStringMap.get(key));
        }

        System.out.println("end");
    }


}