redis介紹（1）命令介紹

redis 的五大基本類型的簡單命令

對key--value中的value的一些簡單命令

　　　　keys * 查詢redis中的所有key
　　　　exists key 查詢key是否存在
　　　　flushdb 清空當前庫
　　　　flushall 清空所有庫 總共16個庫，默認0號庫
　　　　select(庫號0-15) 選擇庫
　　　　dbsize 返回當前庫中有多少key
　　　　randomkey 隨機返回一個key
　　　　ttl 獲得一個key還剩下多少時間
　　　　expire 設置一個key的有效時間
　　　　move(key，dbindex) 把當前key轉移到制定庫
　　　　del key 刪除一個key
　　　　type key[hhy]      返回當前key的類型【五種】
　　　　rename[了解]

　　

持久化

• save：將數據同步保存到磁盤
• bgsave：將數據異步保存到磁盤
• lastsave：返回上次成功將數據保存到磁盤的Unix時戳
• shundown：將數據同步保存到磁盤，然后關閉服務

遠程服務控制

• info：提供服務器的信息和統計
• monitor：實時轉儲收到的請求
• slaveof：改變復制策略設置
• config：在運行時配置Redis服務器

對String操作的命令

• set(key, value)：給數據庫中名稱為key的string賦予值value
• get(key)：返回數據庫中名稱為key的string的value
• getset(key, value)：給名稱為key的string賦予上一次的value
• mget(key1, key2,…, key N)：返回庫中多個string的value
• setnx(key, value)：添加string，名稱為key，值為value
• setex(key, time, value)：向庫中添加string，設定過期時間time
• mset(key N, value N)：批量設置多個string的值
• msetnx(key N, value N)：如果所有名稱為key i的string都不存在
• incr(key)：名稱為key的string增1操作
• incrby(key, integer)：名稱為key的string增加integer
• decr(key)：名稱為key的string減1操作
• decrby(key, integer)：名稱為key的string減少integer
• append(key, value)：名稱為key的string的值附加value
• substr(key, start, end)：返回名稱為key的string的value的子串

對List操作的命令

• rpush(key, value)：在名稱為key的list尾添加一個值為value的元素
• lpush(key, value)：在名稱為key的list頭添加一個值為value的 元素
• llen(key)：返回名稱為key的list的長度
• lrange(key, start, end)：返回名稱為key的list中start至end之間的元素
• ltrim(key, start, end)：截取名稱為key的list
• lindex(key, index)：返回名稱為key的list中index位置的元素
• lset(key, index, value)：給名稱為key的list中index位置的元素賦值
• lrem(key, count, value)：刪除count個key的list中值為value的元素
• lpop(key)：返回並刪除名稱為key的list中的首元素
• rpop(key)：返回並刪除名稱為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的頭部

對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的一個元素

 

Sorted-sort【zset】集合 　

 

   　　zset 是sets 一個升級 ，是有序集合，這一屬性在添加修改元素的時候可以指定，
　　　　每次指定后，zset 會自動沖洗按心的值調整順序，可以理解為兩列的mysql表
　　　　一兩存value，一列存順序，key理解為zset名字
　　　　zadd 向集合中添加一個元素 如果值存在則更新順序號
　　　　zadd myset 1 one
　　　　zadd myset 2 two
　　　　zadd myset 3 three

　　　　2 zrange
　　　　zrange myset 0 -1 withscores withscores顯示 順序號

　　　　3 zrem 刪除一個元素
　　　　zrem myset two

　　　　4 zincrby 對序號進行增加
　　　　　zincrby myset 3 one 順序號增加3個
　　　　   zincrby myset -3 one 順序號減少3個

　　　　5 zrank 按照索引排序 ，返回索引值

　　　　zrank myset one

　　　　6 zrevrank 返回名稱為key 的zset 中member 元素的排名
　　　　　　（按照score從大到小的排序）即下標
　　　　　　zrevrank myset two

　　　　7 zrevrange 降序排序

　　　　8 zrangebyscore
　　　　

　　　　zrangebyscore myset 2 3 withscores
　　　　這里的2 和3 是順序 不是inex

　　　　9 zcount
　　　　返回score在給定區間的數量
　　　　zcount myset 2 4

　　　　10 zcard 返回所有元素個數
　　　　zcard myset

　　　　11 zremrangebyrank 刪除集合中排名在給定區間的元素
　　　　按照索引刪除
　　　　zremrangebyrank myset 1 1
　　　　1 代表索引

　　　　12 zremrangebyscore 按照順序刪除

　　　　zremrangebyscore myset 2 5

　

對Hash操作的命令（

Hash是一種數據結構，一般翻譯做“散列”，也有直接音譯為“哈希”。Redis hash 是一個string類型的field和value的映射表。它特別適合用於存儲對象。同將對象的每個字段存成單個string類型，存儲為hash類型會占用更少的內存，並且方便的存取整個對象。）

• hset(key, field, value)：向名稱為key的hash中添加元素field
• hget(key, field)：返回名稱為key的hash中field對應的value
• hmget(key, (fields))：返回名稱為key的hash中field i對應的value
• hmset(key, (fields))：向名稱為key的hash中添加元素field 
• hincrby(key, field, integer)：將名稱為key的hash中field的value增加integer
• hexists(key, field)：名稱為key的hash中是否存在鍵為field的域
• hdel(key, field)：刪除名稱為key的hash中鍵為field的域
• hlen(key)：返回名稱為key的hash中元素個數
• hkeys(key)：返回名稱為key的hash中所有鍵
• hvals(key)：返回名稱為key的hash中所有鍵對應的value
• hgetall(key)：返回名稱為key的hash中所有的鍵（field）及其對應的value

 

 

代碼實例：redis的CURD操作

 

package deifeng.testRedis;

import java.util.HashMap;
import java.util.List;
import java.util.Set;

import org.junit.Test;

import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

/**
 * 
 * @author Administrator
 * timer:2017年2月18日下午11:02:24
 * intro:TODO
 */
public class TestCRUD {
    //創建redis 的客戶端連接，綁定主機和端口號
    private static String host="127.0.0.1";
    private static int port =6379;
    private Jedis jedis = TestCRUD.getRedisUtil(host, port);
    
    
    
    //測試連接
    public void  testConn(){
        System.out.println(jedis);
    }
    
    /**
     * 測試redis的五大基本類型操作
     */
    /**
     * String 類型的簡單命令
     * 
     *    一 -------多
     *    set      mset
     */
    @Test
    public  void testString(){
        //獲取jedis對象    返回key=hhy2的type類型
        /*String type = jedis.type("hhy2");
        System.out.println(type);*/
        /**
         * 存儲一個數據
         * 
         * set   -------mset
         */
        //jedis.flushDB();       flushAll
        String key1 = jedis.set("hhy", "hhy"); 
        System.out.println(jedis.get("hhy"));
        //是在key不存在，才會執行set操作，如果key存在，則此操作無效,返回值1代表成功，0代表失敗
        //setnx  ------msetnx
        Long setnx = jedis.setnx("hhy1", "zs");
        System.out.println(setnx);//1   代表插入的key在redis庫中不存在
        //setex  ---- mstex
        jedis.setex("hhy", 100, "zsq");//100有效期   
        
        Long tt = jedis.ttl("hhy");
        System.out.println(tt);
        /**
         * 存儲多個數據
         * mget  key1 value1  key2 value2...
         * 類似於set對一個數據存儲的語法
         */
        
        
        /**
         * getrange
         * getrange key star end
         *
         *    解釋：獲取存儲在key中value的字串。字符串的截取有star和end決定，字符串的第一個字符編號是0，第二個是1，
         *    一次類推；如果是負數，-1是最后一個字符，-2是倒數第二個字符，一次類推。
         *
         *    setrange
         *  用value重寫key值的一部分，偏移量由offset指定
         *  
         */
        
        jedis.set("test", "test123456");
        System.out.println(jedis.getrange("test", 2, 5));
        
        
        /**
         * getset
         */
        String getset = jedis.getSet("hhy", "123");
        System.out.println(getset);
        
        Long ll = jedis.append("hhy", "123");//添加以后的長度
        
        
        /**
         * 遞增/減
         * incr / incrby   ++   /  decr  /decrby  --
         */
        Long incr = jedis.incr("21");
        System.out.println(incr);
        
        /**
         * 刪除key
         * del
         */
        jedis.del("hhy");
        System.out.println("=====================");
        Set<String> keys = jedis.keys("*");
        for (String string : keys) {
            System.out.println(string +"---->"+jedis.get(string));
        }
        
    }
    
    
    
    /**
     * redis  ---- List
     * lpush  rpush  linsert  添加命令
     * lpop   rpop            刪除命令
     * lrange llen   lindex   查詢命令
     * lset                   修改命令
     * rpoplpush              兩個列表A,B，將A列表的尾元素添加到B列表的頭元素中
     */
    @Test
    public void testList(){
        jedis.flushDB();//清空當前庫
        //添加一個list集合
        /**
         * 如果保證順序
         * left  降序
         * right  順序
         */
        jedis.lpush("zs", "3","2","1");//左側插入一個list集合
        jedis.rpush("li", "7","8","9");
        /*
        //遍歷li集合
        List<String> list = jedis.lrange("li", 0, -1);
        for (String str : list) {
            System.out.println(str);
        }
        
        System.out.println("============");
        //linsert插入一條數據
        jedis.linsert("zs", LIST_POSITION.AFTER, "2", "12");
        //遍歷li集合
        List<String> zs = jedis.lrange("zs", 0, -1);
        for (String str : zs) {
            System.out.println(str);
        }
        
        //del
        *//**
         * lpop  rpop  分別代表是從左|右側刪除一條數據
         * 並且把刪除的數據值返回過來
         *//*
        System.out.println(jedis.lpop("zs"));
        
        
        *//**
         * 查詢命令  lindex  llen
         *//*
        
        System.out.println(jedis.lindex("li", 1));
        System.out.println(jedis.lset("zs", 0, "hhy"));
        
        */
        jedis.rpoplpush("li", "zs");
        System.out.println("--------------");
        List<String> zs1 = jedis.lrange("zs", 0, -1);
        for (String string : zs1) {
            System.out.println(string);
        }
    }
    
    
    
    /**
     * Redis   --   Set
     */
    @Test
    public void testSet(){
        jedis.flushDB();
        jedis.sadd("ss", "1","2","3");
        System.out.println(jedis.smembers("ss"));
        //在客戶端命令中。存在是1  不存在是0
        System.out.println(jedis.sismember("ss", "2"));
        //set集合 的大小
        System.out.println(jedis.scard("ss"));
        //返回set集合中隨機數據
        System.out.println(jedis.srandmember("ss"));
        //隨即返回redis  中的key
        System.out.println(jedis.randomKey());
        
        /**
         * spop隨機刪除set集合的一個數據
         * 集合之間的 操作
         * 
         * sinter   交集
         * sunion   並集
         * sdiff    差集
         * smove    把  1  集合轉移到 2中
         * >smove youSet mySet 4  ---將youSet中的數據4移除的同時將數據4添加到mySet中
         */
        jedis.sinter("可擴展的key，求交集");
        jedis.sunion("可擴展的key，求並集");
        jedis.sdiff("可擴展的key，求差集");
        
    }
    
    /**
     * sorted-sort
     * 
     * zadd 一次只能添加一個
     */
    @Test
    public void testSortedSort(){
        jedis.flushDB();
        jedis.zadd("hhy", 100, "zs");
        jedis.zadd("hhy", 101, "zs1");
        jedis.zadd("hhy", 102, "zs2");
        jedis.zadd("hhy", 103, "zs3");
        //獲取zset集合中的值  ---  是一個集合   asc
        /**zrange       asc
         * zrevrange    desc
         */
        Set<String> set = jedis.zrange("hhy", 0, -1);
        for (String str : set) {
            //獲取分數
            System.out.println(str);
            //通過這個集合中的值，查詢每一個值所對應的分數
            Double zscore = jedis.zscore("hhy", str);
            System.out.println(zscore);
        }
        //可以直接獲取到值--分數的對應關系，封裝到tuple對象中
        Set<Tuple> set2 = jedis.zrangeWithScores("hhy", 0, -1);
        for (Tuple tuple : set2) {
            System.out.println(tuple.getScore()+" --->"+tuple.getElement());
        }
        //查看zset集合中的數據zs1是第一名
        Long zrank = jedis.zrank("hhy", "zs1");
        System.out.println(zrank);
    }
    
    /**
     * hash類型的操作
     * 基本命令的操作
     */
    @Test
    public void testHash(){
        /**
         * 如何在user中再存一個對象？
         */
        jedis.hset("user", "name", "hhy");
        jedis.hset("user", "age", "25");
        //jedis.hmset("u", new HashMap<String,String>());
        System.out.println(jedis.hget("user", "name"));
        //查詢hash中的所有filed和value
        jedis.hkeys("user");
        jedis.hvals("user");
        //s設置多個值和獲取多個值  hmset   hmget
        
        
        //獲取所有的filed
        jedis.hgetAll("user");
        //當前有多少數據
        jedis.hlen("user");
    }
    
    /**
     * 創建redis的連接對象
     * @param host  主機
     * @param port  端口號
     * @return  jedis對象
     */
    public static Jedis getRedisUtil(String host,int port){
        return new Jedis(host,port);
    }
    
    
}

 

hash實現簡單購物車

package deifeng.testRedis;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import redis.clients.jedis.Jedis;

/**
 * 
 * @author Administrator
 * timer:2017年2月21日上午9:54:33
 * intro:使用hash類型模擬購物車的實現
 */
public class ShoppingGoods {
    //定義主機和端口號
    private static String host = "127.0.0.1";
    private static int port = 6379;
    //hash的那個key的名字
    private static String hash_name = "huhy";
    

    public static void main(String[] args) {
        //客戶端連接redis
        Jedis jedis = new Jedis(host, port);
        
        Map<String, String> hash_goods = new HashMap<String, String>();
        //添加到hash類型中數據
        hash_goods.put("電視", "3");
        hash_goods.put("書", "4");
        hash_goods.put("大風車", "6");
        hash_goods.put("衣服", "10");
        
        jedis.hmset(hash_name, hash_goods);
        
        //當前有多少數據
        //System.out.println(jedis.hlen(hash_name)+"個數據");
        
        //遍歷數據
        List<String> list = new ArrayList<String>();
        
        Set<String> sets = jedis.hkeys(hash_name);//查詢key中出所有的fileds
        Iterator<String> fileds = sets.iterator();
        while(fileds.hasNext()){
            //System.out.println(fileds.next().toString());
            //通過filed找到對應的value
            String filed = fileds.next();
            String value = jedis.hget(hash_name, filed);
            System.out.println(filed+"------->"+value);
            
            //把查詢出的filed存儲到list集合中
            list.add(filed);
        }
        
        //llist集合中保存的是數據的filed
        /**
         * 通過hmget的可以取多個值
         * hmget（key   filed ）  ----> value
         */
         List<String> ll = jedis.hmget(hash_name, list.get(0), list.get(1), list.get(2),list.get(3));  
         System.out.print(ll +" ");  
        
         //hgetall命令  
         Map<String, String> map = jedis.hgetAll(hash_name);  
         Set<Entry<String, String>> ss = map.entrySet();
         Iterator<Entry<String, String>> ii = ss.iterator();
         for (Entry<String, String> entry : ss) {
            System.out.println(entry.getKey() +"--->"+entry.getValue());
         }
         //切斷客戶端連接   釋放資源
         
         jedis.disconnect();
    }
}