redis 安裝和簡單使用

1、redis 安裝   

一、首先安裝c的編譯環境

     yum -y install cpp

    yum -y install binutils

    yum -y install glibc

    yum -y install glibc-kernheaders

    yum -y install glibc-common

    yum -y install glibc-devel

    yum -y install gcc

    yum -y install make

二、解壓：tar -zxvf redis-2.8.19.tar.gz

三、編譯、安裝

make  命令[root@node1 redis-3.0.0]# make

make install  命令[root@node1 redis-3.0.0]# make install

四、拷貝配置文件

cp redis/redis.conf /etc/

修改配置文件redis.conf

daemonize yes(後臺運行)

logfile 「/usr/local/java/redis-3.0.0/log」(日誌文件)

五、啓動

命令    redis-server /etc/redis.conf [--port 6379]    後臺啓動

六、redis客戶端

命令     redis-cli [-h 127.0.0.1] [-p 6379]

七、關閉

redis-cli shutdown

2、基礎命令

得到符合規則的鍵名稱

keys 表達式（?,* ,[],\?）   如keys *  查看全部key的信息

判斷一個鍵是否存在

exists key   如exists aa 返回1表示key存在    0   表示key不存在

刪除鍵

del key    如del aa

del key1 key2

批量刪除

redis-cli del `redis-cli keys "key*"`

得到鍵值的數據類型type

返回值多是這五種類型（string,hash,list,set,zset）

注意：redis不區分命令大小寫

3、redis的help命令

help @<group>  查看哪一種數據類型怎麼用的   如help @string

help <command>  查看哪一種命令怎麼用的   如 help set

quit 退去redis客戶端

4、redis 各類數據類型的操做命令

一、string類型

set    存一個key value類型的數據   如set  aa  bb

get    根據key查詢value值    如get aa

setnx  表示若是該key存在就不覆蓋value

mset  一次存儲多個key value  如mset aa aa bb bb cc cc

mget  一次獲取多個key的value  如mget aa bb cc

incr  表示若是一個key的value的類型是數字 每執行一次incr命令該key的value的值就會自增1  如 incr aa

decr  表示若是一個key的value的類型是數字 每執行一次decr 命令該key的value的值就會自減1  如 decr  aa

incrby    表示若是一個key的value的類型是數字  該key的value按照指定的數字增長  如incrby   aa 10

decrby     表示若是一個key的value的類型是數字  該key的value按照指定的數字減小 如decrby   aa 10

incrbyfloat  表示若是一個key的value的類型是數字  該key的value按照指定的小數增長如incrbyfloat aa 0.12

append  表示在value的後面拼接   如append  aa 11

strlen  表示返回value的長度  如strlen   aa

二、hash類型  hash類型適合存儲對象

hset    存一個key  key  value類型的數據   如hset user1 name zs

hget    根據key下的key查詢value值    如hget user1 name

hmset 一次存儲多個key key value    如hmset user3 name lisi age 10 qita wu

hmget    一次取key下的多個key的value值如 hmget user3 name age love

hgetall    獲取key下的全部信息 如 hgetall user3

hsetnx  表示若是該key下key的value存在就不覆蓋value 如 hsetnx user3 name ww

hexists,判斷鍵中的屬性是否存在  如hexists user3 name

hincrby   表示若是一個key下key的value的類型是數字  該key的value按照指定的數字增長 如hincrby user3 age 10

hdel    刪除key下某個key的值  如hdel user3 age

hkeys    獲取key下的全部key的信息   如hkeys user3

hvals    獲取key下的全部value的值    如 hvals user3

hlen    獲取鍵中包含多少個key  如 hlen user3

三、list類型    list是一個有序的字符串列表

lpush    從左面開始存一個key  多個 value類型的數據   如lpush list 1 2 3 4 5

rpush    從右面開始存一個key  多個 value類型的數據   如rpush list 1 2 3 4 5

lpop    每執行一次會從集合的左面刪除一條數據  如lpop list

rpop    每執行一次會從集合的右面刪除一條數據  如rpop list

llen    查看集合的長度   如llen list

lrange(-1表示最後一個元素的位置)  查看指定範圍的數據  如lrange list 0 -1

lrem（lrem key count value）count分爲三種狀況  如 lrem list 2 3

count > 0 : 從表頭開始向表尾搜索，移除與 value 相等的元素，數量爲 count 。

count < 0 : 從表尾開始向表頭搜索，移除與 value 相等的元素，數量爲 count 的絕對值。

count = 0 : 移除表中全部與 value 相等的值。

lindex    查詢指定角標數據      如lindex list 1

lset      修改指定腳標的數據      如 lset list 1 10

ltrim    截取指定腳標的數據        如ltrim list 0 1

linsert    向指定元素先後插入元素  如linsert list before2 3 或 linsert list after 2 3

rpoplpush:將元素從一個列表轉到另外一個列表  rpoplpush list list1

四、set類型   set集合中的元素都是不重複的，無序的

sadd     存一個key 多個value類型的數據   如sadd set1 1 2 3 4 5

smembers    獲取key的全部value信息    如smembers set1

srem            刪除key下的一個或多個value        如 srem set1 4

sismember     判斷key下的value存不存在  存在返回1不存在返回0    如sismember set1 1

sdiff    返回兩個集合中和第一個集合不一樣的元素   如sdiff set2 set1

sinter(交集)    返回兩個集合中相同的元素   如sinter set1 set2

sunion(並集)    返回兩個集合中全部不重複的元素   如 sunion set1 set2

sdiffstore    把兩個集合中和第一個集合不一樣的元素 保存到另外一個集合裏  如sdiffstore set3 set1 set2

sinterstore  把兩個集合中相同的元素保存到另外一個集合裏     如 sinterstore set4 set1 set2

sunionstore    把兩個集合中全部不重複的元素 保存到另外一個集合裏     如 sunionstore    set4 set1 set2

scard        獲取集合長度            如scard set4

spop    隨機從集合中取出並刪除一個元素   如spop set4

srandmember key [count]            如 srandmember set2 10

若是 count 爲正數，且小於集合基數，那麼命令返回一個包含 count 個元素的數組，數組中的元素各不相同。若是 count 大於等於集合基數，那麼返回整個集合。

若是 count 爲負數，那麼命令返回一個數組，數組中的元素可能會重複出現屢次，而數組的長度爲 count 的絕對值

五、sorted set  有序集合，在集合類型的基礎上爲集合中的每一個元素都關聯了一個分數

zadd     存一個key 多個value類型的數據   如zadd sort1 10 1 20 2 30 3    分值越大越靠後

zscore    得到某個value的分值是多少    如zscore sort1 1

zrange     查看指定範圍的數據   如zrange sort1 0 -1  (-1表示最後一個元素)

zrevrange    反向查看指定範圍的數據   如zrevrange   sort1 0 -1  (-1表示最後一個元素)

zrangebyscore 經過分值查詢value(默認是閉區間,可以使用"("使用開區間)   如zrangebyscore   sort1 8 (10

zincrby      給某個value按指定的數增長分值    如zincrby  sort1 100 32

zcard   查看key下value的數量     如zcard sort1

zcount        獲取指定分數範圍的元素個數      如zcount sort1 10 20

zrem    刪除指定的value   如zrem sort1 33 34

zremrangebyrank        刪除指定範圍的數據    如zremrangebyrank sort1 0 -1

zremrangebyscore    刪除指定分數範圍內的數據    如zremrangebyscore   sort 10 100

+inf(正無窮)       該value   排在最下面

-inf(負無窮)     該value   排在最上面

5、redis中鍵的生存時間  expire

redis中可使用expire命令設置一個鍵的生存時間，到時間後redis會自動刪除它。

expire  設置生存時間（單位/秒）       如  expire sort1 10

pexpire設置生存時間(單位/毫秒)    如 pexpire    sort1 1000

ttl  查看key還有多少秒過時    如ttl sort1

pttl   查看key還有多少毫秒秒過時    如pttl  sort1

persist  取消生存時間        如persist  sort1

expireat    指定一個時間戳到該時間戳後 key過時   如 expireat  sort1 1351858600  

pexpireat  指定一個時間戳（毫秒）到該時間戳後 key過時   如 expireat  sort1 13518586000000  

6、redis數據的排序

sort命令能夠對列表類型，集合類型和有序集合類型鍵進行排序。

sort key [desc] [limit offset count]  如sort list1 desc limit 0 3

by 參考鍵(參考鍵能夠是字符串類型或者是hash類型的某個字段，hash類型的格式爲：鍵名->字段名)

若是參考鍵中不帶*號則不排序

若是某個元素的參考鍵不存在，則默認參考鍵的值爲0

擴展 get參數

get參數的規則和by參數的規則同樣

get # (返回元素自己的值)

如 參考鍵是字符串   sort list1 by stu:*  get # get stu:*

如 參考建是hash    sort list1 by user:*->age get # get user:*->name

擴展 store參數

使用store 參數能夠把sort的排序結果保存到指定的列表中

如 sort list1 by stu:*  get # get stu:* store list2

性能優化

1：儘量減小待排序鍵中元素的數量

2：使用limit參數只獲取須要的數據

3：若是要排序的數據數量很大，儘量使用store參數將結果緩存。

7、redis持久化

一、RDB

rdb方式的持久化是經過快照完成的，當符合必定條件時redis會自動將內存中的全部數據執行快照操做並存儲到硬盤上。默認存儲在redis根目錄的dump.rdb文件中。(文件名在配置文件中dbfilename)

redis進行快照的時機（在配置文件redis.conf中）

save 900 1：表示900秒內至少一個鍵被更改則進行快照。

save 300 10

save 60 10000

redis自動實現快照的過程,見備註

手動執行save或者bgsave命令讓redis執行快照。

兩個命令的區別在於，save是由主進程進行快照操做，會阻塞其它請求。bgsave是由redis執行fork函數複製出一個子進程來進行快照操做。

文件修復：redis-check-dump

rdb的優缺點

優勢：因爲存儲的有數據快照文件，恢復數據很方便。

缺點：會丟失最後一次快照之後更改的全部數據。

二、AOF

aof方式的持久化是經過日誌文件的方式。默認狀況下redis沒有開啓aof，能夠經過參數appendonly參數開啓。

appendonly yes

aof文件的保存位置和rdb文件的位置相同，都是dir參數設置的，默認的文件名是appendonly.aof，能夠經過appendfilename參數修改

appendfilename appendonly.aof

redis寫命令同步的時機

appendfsync always 每次都會執行

appendfsync everysec 默認 每秒執行一次同步操做（推薦，默認）

appendfsync no不主動進行同步，由操做系統來作，30秒一次

aof日誌文件重寫

auto-aof-rewrite-percentage 100(當目前aof文件大小超過上一次重寫時的aof文件大小的百分之多少時會再次進行重寫，若是以前沒有重寫，則以啓動時的aof文件大小爲依據)

auto-aof-rewrite-min-size 64mb

手動執行bgrewriteaof進行重寫

重寫的過程只和內存中的數據有關，和以前的aof文件無關。

所謂的「重寫」實際上是一個有歧義的詞語， 實際上， AOF 重寫並不須要對原有的 AOF 文件進行任何寫入和讀取， 它針對的是數據庫中鍵的當前值。

文件修復：redis-check-aof

動態切換redis持久方式，從 RDB 切換到 AOF（支持Redis 2.2及以上）

CONFIG SET appendonly yes

CONFIG SET save ""（可選）

注意：當redis啓動時，若是rdb持久化和aof持久化都打開了，那麼程序會優先使用aof方式來恢復數據集，由於aof方式所保存的數據一般是最完整的。

注意：若是想把正在運行的redis數據庫，從  RDB切換到AOF，建議先使用動態切換方式，再修改配置文件，重啓數據庫。(不能本身修改配置文件，重啓數據庫，不然數據庫中數據就爲空了。)

8、redis的config命令

使用config set能夠動態設置參數信息，服務器重啓以後就失效了。

config set appendonly yes

 config set save "90 1 30 10 60 100"

使用config get能夠查看全部可使用config set命令設置的參數

config get *

使用config rewrite命令對啓動 Redis 服務器時所指定的 redis.conf 文件進行改寫(Redis 2.8 及以上版本纔可使用)，主要是把使用config set動態指定的命令保存到配置文件中。

config rewrite

注意：config rewrite命令對 redis.conf 文件的重寫是原子性的， 而且是一致的： 若是重寫出錯或重寫期間服務器崩潰， 那麼重寫失敗， 原有 redis.conf 文件不會被修改。 若是重寫成功， 那麼 redis.conf 文件爲重寫後的新文件。

9、redis安全策略

設置數據庫密碼

修改配置requirepass password

驗證密碼auth password

注意：在配置redis複製功能的時候若是主數據庫設置了密碼，須要在從數據的配置文件中經過masterauth參數設置主數據庫的密碼，這樣從數據庫在鏈接主數據庫時就會自動使用auth命令認證了。至關於作了一個免密碼登陸。

bind參數（可讓數據庫只能在指定IP下訪問）

bind 127.0.0.1

命令重命名

修改命令的名稱rename-command flushall cleanall

禁用命令 rename-command flushall ""

10、用java簡單操做redis

package cn.crxy.redis.test8;

import static org.junit.Assert.*;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.junit.Test;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Transaction;

public class RedisTest {
    
    String host = "192.168.1.170";
    int port = 6379;
    Jedis jedis = new Jedis(host, port);
    
    /**
     * 單機單連接方式
     * 使用java代碼操做redis
     * 通常只用於測試代碼
     * @throws Exception
     */
    @Test
    public void test1() throws Exception {
        jedis.set("aa", "11");
        String string = jedis.get("aa");
        System.out.println(string);
    }
    
    
    /**
     * 單機鏈接池方式
     * @throws Exception
     */
    @Test
    public void test2() throws Exception {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(100);//總鏈接數
        poolConfig.setMaxIdle(10);//空閒連接數
        poolConfig.setMaxWaitMillis(3000);//建立鏈接的超時時間
        poolConfig.setTestOnBorrow(true);//在建立鏈接的時候是否會測試
        JedisPool jedisPool = new JedisPool(poolConfig, host, port);
        Jedis jedis = jedisPool.getResource();
        String string = jedis.get("aa");
        System.out.println(string);
        jedisPool.returnResourceObject(jedis);
    }
    
    
    /**
     * 限制用戶訪問頻率
     * @throws Exception
     */
    @Test
    public void test3() throws Exception {
        
        for(int i=0;i<20;i++){
            boolean checkLogin = checkLogin("192.168.1.1");
            System.out.println(checkLogin);
        }
        
        
        
    }
    
    
    public boolean checkLogin(String ip){
        String value = jedis.get(ip);
        if(value==null){
            jedis.set(ip, 0+"");
            jedis.expire(ip, 60);
        }else{
            int parseInt = Integer.parseInt(value);
            if(parseInt>=10){
                System.out.println("訪問受限。。。。");
                return false;
            }
        }
        jedis.incr(ip);
        return true;
    }
    
    
    
    @Test
    public void test4() throws Exception {
        String value = jedis.get("aa");
        System.out.println("休息一會。。。");
        Thread.sleep(5000);
        Transaction multi = jedis.multi();
        int parseInt = Integer.parseInt(value);
        parseInt++;
        multi.set("aa", parseInt+"");
        List<Object> exec = multi.exec();
        System.err.println(exec);
        
    }
    
    @Test
    public void test5() throws Exception {
        jedis.watch("aa");
        jedis.unwatch();
        String value = jedis.get("aa");
        System.out.println("休息一會。。。");
        Thread.sleep(5000);
        Transaction multi = jedis.multi();
        int parseInt = Integer.parseInt(value);
        parseInt++;
        multi.set("crxy", parseInt+"");
        List<Object> exec = multi.exec();
        
        if(exec==null||exec.size()==0){
            System.err.println("值被修改，執行失敗");
            test5();
        }
    }
    
    
    
    @Test
    public void test6() throws Exception {
        Jedis jedis2 = RedisUtils.getJedis();
        String string = jedis2.get("aa");
        System.out.println(string);
        RedisUtils.returnJedis(jedis2);
    }
    
    @Test
    public void test7() throws Exception {
        SortingParams sortingParameters;
    }
    
    
    @Test
    public void test8() throws Exception {
        long starttime = System.currentTimeMillis();
        for(int i=0;i<1000;i++){
            jedis.set("x"+i, i+"");
        }
        System.out.println(System.currentTimeMillis()-starttime);
    }
    
    @Test
    public void testtest9() throws Exception {
        long starttime = System.currentTimeMillis();
        Pipeline pipelined = jedis.pipelined();
        for(int i=0;i<1000;i++){
            pipelined.set("y"+i, i+"");
        }
        List<Object> syncAndReturnAll = pipelined.syncAndReturnAll();
        pipelined.close();
        System.out.println(System.currentTimeMillis()-starttime);
    }
    
    
    
    @Test
    public void testSentinel() throws Exception {
        Set<String> sentinels = new HashSet<String>();
        sentinels.add("192.168.1.170:26379");
        sentinels.add("192.168.1.171:26379");
        
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //TODO--
        JedisSentinelPool jedisSentinelPool = new JedisSentinelPool("mymaster", sentinels, poolConfig );
        HostAndPort currentHostMaster = jedisSentinelPool.getCurrentHostMaster();
        System.out.println(currentHostMaster.getHost()+"--"+currentHostMaster.getPort());
        Jedis jedisres = jedisSentinelPool.getResource();
        String value = jedisres.get("aa");
        System.out.println(value);
    }
    
    @Test
    public void testCluster() throws Exception {
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        nodes.add(new HostAndPort("192.168.1.170", 7000));
        nodes.add(new HostAndPort("192.168.1.170", 7001));
        nodes.add(new HostAndPort("192.168.1.170", 7002));
        nodes.add(new HostAndPort("192.168.1.170", 7003));
        nodes.add(new HostAndPort("192.168.1.170", 7004));
        nodes.add(new HostAndPort("192.168.1.170", 7005));
        
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //TODO--
        JedisCluster jedisCluster = new JedisCluster(nodes, poolConfig );
        String string = jedisCluster.get("aa");
        System.out.println(string);
        
    }

}