mongodb和redis的差別

show dbs

切換資料庫

如果資料庫不存在，則指向資料庫，但不建立，直到插入資料或建立集合時資料庫才被建立

use 資料庫名稱

預設的資料庫為test，如果你沒有建立新的資料庫，集合将存放在test資料庫中

資料庫删除

删除目前指向的資料庫

如果資料庫不存在，則什麼也不做

db.dropDatabase()

集合操作

集合建立

文法

db.createCollection(name, options)

name是要建立的集合的名稱

options是一個文檔，用于指定集合的配置

選項參數是可選的，是以隻需要到指定的集合名稱。以下是可以使用的選項清單：

例1：不限制集合大小

db.createCollection("stu")

例2：限制集合大小，後面學會插入語句後可以檢視效果

參數capped：預設值為false表示不設定上限，值為true表示設定上限

參數size：當capped值為true時，需要指定此參數，表示上限大小，當文檔達到上限時，會将之前的資料覆寫，機關為位元組

db.createCollection("sub", { capped : true, size : 10 } )

檢視目前資料庫的集合

文法

show collections

删除

文法

db.集合名稱.drop()

資料操作

資料類型

下表為MongoDB中常用的幾種資料類型：

Object ID：文檔ID

String：字元串，最常用，必須是有效的UTF-8

Boolean：存儲一個布爾值，true或false

Integer：整數可以是32位或64位，這取決于伺服器

Double：存儲浮點值

Arrays：數組或清單，多個值存儲到一個鍵

Object：用于嵌入式的文檔，即一個值為一個文檔

Null：存儲Null值

Timestamp：時間戳

Date：存儲目前日期或時間的UNIX時間格式

object id

每個文檔都有一個屬性，為_id，保證每個文檔的唯一性

可以自己去設定_id插入文檔

如果沒有提供，那麼MongoDB為每個文檔提供了一個獨特的_id，類型為objectID

objectID是一個12位元組的十六進制數

前4個位元組為目前時間戳

接下來3個位元組的機器ID

接下來的2個位元組中MongoDB的服務程序id

最後3個位元組是簡單的增量值

插入

文法

db.集合名稱.insert(document)

插入文檔時，如果不指定_id參數，MongoDB會為文檔配置設定一個唯一的ObjectId

db.stu.insert({name:'gj',gender:1})

s1={_id:'20160101',name:'hr'}

s1.gender=0

db.stu.insert(s1)

查詢文法

db.集合名稱.find()

更新文法db.集合名稱.update(<query>,<update>, {multi: <boolean>})參數query:查詢條件，類似sql語句update中where部分參數update:更新操作符，類似sql語句update中set部分參數multi:可選，預設是false，表示隻更新找到的第一條記錄，值為true表示把滿足條件的文檔全部更新db.stu.update({name:'hr'},{name:'mnc'})指定屬性更新，通過操作符

儲存文法

db.集合名稱.save(document)

如果文檔的_id已經存在則修改，如果文檔的_id不存在則添加

db.stu.save({_id:'20160102','name':'yk',gender:1})

db.stu.save({_id:'20160102','name':'wyk'})

删除文法

db.集合名稱.remove(<query>, { justOne: <boolean> })

參數query:可選，删除的文檔的條件

參數justOne:可選，如果設為true或1，則隻删除一條，預設false，表示删除多條

db.stu.remove({gender:0},{justOne:true})

全部删除

db.stu.remove({})

備份與恢複

備份

文法

mongodump -h dbhost -d dbname -o dbdirectory

-h：伺服器位址，也可以指定端口号

-d：需要備份的資料庫名稱

-o：備份的資料存放位置，此目錄中存放着備份出來的資料

例1

sudo mkdir test1bak

sudo mongodump -h 192.168.196.128:27017 -d test1 -o ~/Desktop/test1bak

恢複

文法

mongorestore -h dbhost -d dbname --dir dbdirectory

-h：伺服器位址

-d：需要恢複的資料庫執行個體

--dir：備份資料所在位置

例2

mongorestore -h 192.168.196.128:27017 -d test2 --dir ~/Desktop/test1bak/test1

授權

建立超級管理者賬戶
use admin
db.createUser({
user:'root',
pwd:'123456',
roles:[{
role:'root',
db:'admin'
}]
})

複制

配置檔案開啟權限驗證

security：

authorization: enabled

mongodb查詢

資料查詢

基本查詢

方法find()：查詢

db.集合名稱.find({條件文檔})

方法findOne()：查詢，隻傳回第一個

db.集合名稱.findOne({條件文檔})

方法pretty()：将結果格式化

db.集合名稱.find({條件文檔}).pretty()

比較運算符

等于，預設是等于判斷，沒有運算符

小于$lt

小于或等于$lte

大于$gt

大于或等于$gte

不等于$ne

例1：查詢名稱等于'gj'的學生

db.stu.find({name:'gj'})

例2：查詢年齡大于或等于18的學生

db.stu.find({age:{$gte:18}})

邏輯運算符

查詢時可以有多個條件，多個條件之間需要通過邏輯運算符連接配接

邏輯與：預設是邏輯與的關系

例3：查詢年齡大于或等于18，并且性别為1的學生

db.stu.find({age:{$gte:18},gender:1})

邏輯或：使用$or

例4：查詢年齡大于18，或性别為0的學生

db.stu.find({$or:[{age:{$gt:18}},{gender:1}]})

and和or一起使用

例5：查詢年齡大于18或性别為0的學生，并且學生的姓名為gj

db.stu.find({$or:[{age:{$gte:18}},{gender:1}],name:'gj'})

範圍運算符

使用"$in"，"$nin" 判斷是否在某個範圍内

例6：查詢年齡為18、28的學生

db.stu.find({age:{$in:[18,28]}})

支援正規表達式

使用//或$regex編寫正規表達式

例7：查詢姓黃的學生

db.stu.find({name:/^黃/})

自定義查詢

使用$where後面寫一個函數，傳回滿足條件的資料

例7：查詢年齡大于30的學生

db.stu.find({$where:function(){return this.age>20}})

投影

在查詢到的傳回結果中，隻選擇必要的字段，而不是選擇一個文檔的整個字段

如：一個文檔有5個字段，需要顯示隻有3個，投影其中3個字段即可

文法：

參數為字段與值，值為1表示顯示，值為0不顯示

db.集合名稱.find({},{字段名稱:1,...})

對于需要顯示的字段，設定為1即可，不設定即為不顯示

特殊：對于_id列預設是顯示的，如果不顯示需要明确設定為0

db.stu.find({},{name:1,gender:1})

db.stu.find({},{_id:0,name:1,gender:1})

排序

方法sort()，用于對結果集進行排序

文法

db.集合名稱.find().sort({字段:1,...})

參數1為升序排列

參數-1為降序排列

根據性别降序，再根據年齡升序

db.stu.find().sort({gender:-1,age:1})

分頁

Limit

方法limit()：用于讀取指定數量的文檔

文法：

db.集合名稱.find().limit(NUMBER)

參數NUMBER表示要擷取文檔的條數

如果沒有指定參數則顯示集合中的所有文檔

例1：查詢2條學生資訊

db.stu.find().limit(2)

skip

方法skip()：用于跳過指定數量的文檔

文法：

db.集合名稱.find().skip(NUMBER)

參數NUMBER表示跳過的記錄條數，預設值為0

例2：查詢從第3條開始的學生資訊

db.stu.find().skip(2)

一起使用

方法limit()和skip()可以一起使用，不分先後順序

建立資料集

for(i=0;i<15;i++){db.t1.insert({_id:i})}

查詢第5至8條資料

db.stu.find().limit(4).skip(5)

或

db.stu.find().skip(5).limit(4)

統計

統計個數

方法count()用于統計結果集中文檔條數

文法

db.集合名稱.find({條件}).count()

也可以與為

db.集合名稱.count({條件})

例1：統計男生人數

db.stu.find({gender:1}).count()

例2：統計年齡大于20的男生人數

db.stu.count({age:{$gt:20},gender:1})

去重

方法distinct()對資料進行去重

文法

db.集合名稱.distinct('去重字段',{條件})

例1:查找年齡大于18的性别（去重）

db.stu.distinct('gender',{age:{$gt:18}})

python操作mongodb

安裝python包

pip install pymongo

引入包pymongo

import pymongo

連接配接，建立用戶端

client=pymongo.MongoClient("localhost", 27017)

獲得資料庫test1

db=client[test1]

獲得集合stu

stu = db[stu]

添加文檔

s1={name:'gj',age:18}

s1_id = stu.insert_one(s1).inserted_id

查找一個文檔

s2=stu.find_one()

查找多個文檔1

for cur in stu.find():

print cur

查找多個文檔2

cur=stu.find()

cur.next()

擷取文檔個數

print stu.count()

redis基礎

Redis簡介

Remote DIctionary Server(Redis) 是一個key-value存儲系統。

Redis 是完全開源免費的，遵守BSD協定，是一個高性能的key-value資料庫。

Redis 與其他 key - value 緩存産品有以下三個特點：

Redis支援資料的持久化，可以将記憶體中的資料儲存在磁盤中，重新開機的時候可以再次加載進行使用。

Redis不僅僅支援簡單的key-value類型的資料，同時還提供list，set，zset，hash等資料結構的存儲。

Redis支援資料的備份，即master-slave模式的資料備份

Ubuntu安裝Redis

sudo apt-get install redis-server

停止服務

service redis stop

啟動服務

service redis start

啟動服務端

redis-server

啟動用戶端

redis-cli

Redis配置

以指定配置檔案啟動服務端

redis-server "C:\Program Files\Redis\redis.conf"

擷取所有配置資訊

config get *

擷取單項配置資訊

config get loglevel

config get dbfilename

...

設定單項配置資訊

config set loglevel warning

config set ...

設定資料庫的數量，預設資料庫為0，可以使用SELECT <dbid>指令在連接配接上指定資料庫id

databases 16

綁定的主機位址

bind 127.0.0.1

綁定的主機端口

port 6379

指定在多長時間内，有多少次更新操作，就将資料同步到資料檔案，可以多個條件配合

save <seconds><changes>

Redis預設配置檔案中提供了三個條件：

save 900 1

save 300 10

save 60 10000

分别表示900秒（15分鐘）内有1個更改，300秒（5分鐘）内有10個更改以及60秒内有10000個更改。

指定本地資料庫檔案名，預設值為dump.rdb

dbfilename dump.rdb

指定本地資料庫存放目錄

dir ./

設定Redis連接配接密碼，如果配置了連接配接密碼，用戶端在連接配接Redis時需要通過AUTH <password>指令提供密碼，預設關閉

requirepass foobared

設定當本機為slav服務時，設定master服務的IP位址及端口，在Redis啟動時，它會自動從master進行資料同步

slaveof <masterip><masterport>

當master服務設定了密碼保護時，slav服務連接配接master的密碼

masterauth <master-password>

Redis預設不是以守護程序的方式運作，可以通過該配置項修改，使用yes啟用守護程序

daemonize no

當用戶端閑置多長時間後關閉連接配接，如果指定為0，表示關閉該功能

timeout 300

redis資料操作

資料類型

redis是key-value的資料，是以每個資料都是一個鍵值對

鍵的類型是字元串

值的類型分為五種：

字元串string

哈希hash

清單list

集合set

有序集合zset

String類型

設定

設定鍵值

set key value

設定鍵值及過期時間，以秒為機關

SETEX key seconds value

redis> setex 1001 50 'zhouzhiruo'

設定多個鍵值

MSET key value [key value ...]

根據鍵擷取值，如果不存在此鍵則傳回nil

GET key

根據多個鍵擷取多個值

MGET key [key ...]

redis> MSET date "2012.3.30" time "11:00 a.m." weather "sunny"

redis> MGET date time weather

1) "2012.3.30"

2) "11:00 a.m."

3) "sunny"

要求：值是數字

将key對應的value加1

INCR key

将key對應的value加整數

INCRBY key increment

将key對應的value減1

redis> SET page_view 20

redis> INCR page_view

(integer) 21

redis> GET page_view # 數字值在 Redis 中以字元串的形式儲存

"21"

鍵存在，并且值為數字：

redis> SET rank 50

redis> INCRBY rank 20

(integer) 70

redis> GET rank

"70"

鍵不存在：

redis> EXISTS counter

(integer) 0

redis> INCRBY counter 30

(integer) 30

redis> GET counter

"30"

鍵存在，但值無法被解釋為數字：

redis> SET book "long long ago..."

redis> INCRBY book 200

(error) ERR value is not an integer or out of range

DECR key

将key對應的value減整數

DECRBY key decrement

對儲存數字值的鍵 key 執行 DECR 指令：

redis> SET failure_times 10

redis> DECR failure_times

(integer) 9

對不存在的鍵執行 DECR 指令：

redis> EXISTS count

(integer) 0

redis> DECR count

(integer) -1

其它

追加值

APPEND key value

對不存在的 key 執行 APPEND ：

redis> EXISTS myphone # 確定 myphone 不存在

(integer) 0

redis> APPEND myphone "nokia" # 對不存在的 key 進行 APPEND ，等同于 SET myphone "nokia"

(integer) 5 # 字元長度

對已存在的字元串進行 APPEND ：

redis> APPEND myphone " - 1110" # 長度從 5 個字元增加到 12 個字元

(integer) 12

redis> GET myphone

"nokia - 1110"

擷取值長度

STRLEN key

擷取字元串值的長度：

redis> SET mykey "Hello world"

redis> STRLEN mykey

(integer) 11

不存在的鍵的長度為 0 ：

redis> STRLEN nonexisting

(integer) 0

鍵操作

查找鍵，參數支援正則

KEYS pattern

redis> MSET one 1 two 2 three 3 four 4 # 一次設定 4 個 key

redis> KEYS *o*

1) "four"

2) "two"

3) "one"

redis> KEYS t??

1) "two"

redis> KEYS t[w]*

1) "two"

redis> KEYS * # 比對資料庫内所有 key

1) "four"

2) "three"

3) "two"

4) "one"

KEYS 的速度非常快，但在一個大的資料庫中使用它仍然可能造成性能問題，如果你需要從一個資料集中查找特定的 key ，你最好還是用 Redis 的集合結構(set)來代替。

判斷鍵是否存在，如果存在傳回1，不存在傳回0

EXISTS key [key ...]

redis> SET db "redis"

redis> EXISTS db

(integer) 1

redis> DEL db

(integer) 1

redis> EXISTS db

(integer) 0

檢視鍵對應的value的類型

TYPE key

# 字元串

redis> SET weather "sunny"

redis> TYPE weather

string

# 清單

redis> LPUSH book_list "programming in scala"

(integer) 1

redis> TYPE book_list

list

# 集合

redis> SADD pat "dog"

(integer) 1

redis> TYPE pat

set

删除鍵及對應的值

DEL key [key ...]

# 删除單個 key

redis> SET name huangz

redis> DEL name

(integer) 1

# 删除一個不存在的 key

redis> EXISTS phone

(integer) 0

redis> DEL phone # 失敗，沒有 key 被删除

(integer) 0

# 同時删除多個 key

redis> SET name "redis"

redis> SET type "key-value store"

redis> SET website "redis.com"

redis> DEL name type website

(integer) 3

設定過期時間，以秒為機關

建立時沒有設定過期時間則一直存在，直到使用使用DEL移除

EXPIRE key seconds

redis> SET cache_page "www.google.com"

redis> EXPIRE cache_page 30 # 設定過期時間為 30 秒

(integer) 1

redis> TTL cache_page # 檢視剩餘生存時間

(integer) 23

redis> EXPIRE cache_page 30000 # 更新過期時間

(integer) 1

redis> TTL cache_page

(integer) 29996

檢視有效時間，以秒為機關

TTL key

# 不存在的 key

redis> FLUSHDB

redis> TTL key

(integer) -2

# key 存在，但沒有設定剩餘生存時間

redis> SET key value

redis> TTL key

(integer) -1

# 有剩餘生存時間的 key

redis> EXPIRE key 10086

(integer) 1

redis> TTL key

(integer) 10084

hash

hash用于存儲對象，對象的格式為鍵值對

設定

設定單個屬性

HSET key field value

設定一個新域：

redis> HSET website google "www.g.cn"

(integer) 1

redis> HGET website google

"www.g.cn"

對一個已存在的域進行更新：

redis> HSET website google "www.google.com"

(integer) 0

redis> HGET website google

"www.google.com"

設定多個屬性

HMSET key field value [field value ...]

redis> HMSET website google www.google.com yahoo www.yahoo.com

redis> HGET website google

"www.google.com"

redis> HGET website yahoo

"www.yahoo.com"

擷取

擷取一個屬性的值

HGET key field

域存在的情況：

redis> HSET homepage redis redis.com

(integer) 1

redis> HGET homepage redis

"redis.com"

域不存在的情況：

redis> HGET site mysql

(nil)

擷取多個屬性的值

HMGET key field [field ...]

redis> HMSET pet dog "doudou" cat "nounou" # 一次設定多個域

redis> HMGET pet dog cat fake_pet # 傳回值的順序和傳入參數的順序一樣

1) "doudou"

2) "nounou"

3) (nil) # 不存在的域傳回nil值

擷取所有屬性和值

HGETALL key

redis> HSET people jack "Jack Sparrow"

(integer) 1

redis> HSET people gump "Forrest Gump"

(integer) 1

redis> HGETALL people

1) "jack" # 域

2) "Jack Sparrow" # 值

3) "gump"

4) "Forrest Gump"

擷取所有的屬性

HKEYS key

# 哈希表非空

redis> HMSET website google www.google.com yahoo www.yahoo.com

redis> HKEYS website

1) "google"

2) "yahoo"

# 空哈希表/key不存在

redis> EXISTS fake_key

(integer) 0

redis> HKEYS fake_key

(empty list or set)

傳回包含屬性的個數

HLEN key

redis> HSET db redis redis.com

(integer) 1

redis> HSET db mysql mysql.com

(integer) 1

redis> HLEN db

(integer) 2

redis> HSET db mongodb mongodb.org

(integer) 1

redis> HLEN db

(integer) 3

擷取所有值

HVALS key

# 非空哈希表

redis> HMSET website google www.google.com yahoo www.yahoo.com

redis> HVALS website

1) "www.google.com"

2) "www.yahoo.com"

# 空哈希表/不存在的key

redis> EXISTS not_exists

(integer) 0

redis> HVALS not_exists

(empty list or set)

其它

判斷屬性是否存在

HEXISTS key field

給定域不存在：

redis> HEXISTS phone myphone

(integer) 0

給定域存在：

redis> HSET phone myphone nokia-1110

(integer) 1

redis> HEXISTS phone myphone

(integer) 1

删除屬性及值

HDEL key field [field ...]

# 測試資料

redis> HGETALL abbr

1) "a"

2) "apple"

3) "b"

4) "banana"

5) "c"

6) "cat"

7) "d"

8) "dog"

# 删除單個域

redis> HDEL abbr a

(integer) 1

# 删除不存在的域

redis> HDEL abbr not-exists-field

(integer) 0

# 删除多個域

redis> HDEL abbr b c

(integer) 2

redis> HGETALL abbr

1) "d"

2) "dog"

傳回值的字元串長度

HSTRLEN key field

redis> HMSET myhash f1 "HelloWorld" f2 "99" f3 "-256"

redis> HSTRLEN myhash f1

(integer) 10

redis> HSTRLEN myhash f2

(integer) 2

redis> HSTRLEN myhash f3

(integer) 4

list

清單的元素類型為string

按照插入順序排序

在清單的頭部或者尾部添加元素

設定

在頭部插入資料

LPUSH key value [value ...]

# 加入單個元素

redis> LPUSH languages python

(integer) 1

# 加入重複元素

redis> LPUSH languages python

(integer) 2

redis> LRANGE languages 0 -1 # 清單允許重複元素

1) "python"

2) "python"

# 加入多個元素

redis> LPUSH mylist a b c

(integer) 3

redis> LRANGE mylist 0 -1

1) "c"

2) "b"

3) "a"

在尾部插入資料

RPUSH key value [value ...]

# 添加單個元素

redis> RPUSH languages c

(integer) 1

# 添加重複元素

redis> RPUSH languages c

(integer) 2

redis> LRANGE languages 0 -1 # 清單允許重複元素

1) "c"

2) "c"

# 添加多個元素

redis> RPUSH mylist a b c

(integer) 3

redis> LRANGE mylist 0 -1

1) "a"

2) "b"

3) "c"

在一個元素的前|後插入新元素

LINSERT key BEFORE|AFTER pivot value

redis> RPUSH mylist "Hello"

(integer) 1

redis> RPUSH mylist "World"

(integer) 2

redis> LINSERT mylist BEFORE "World" "There"

(integer) 3

redis> LRANGE mylist 0 -1

1) "Hello"

2) "There"

3) "World"

# 對一個非空清單插入，查找一個不存在的 pivot

redis> LINSERT mylist BEFORE "go" "let's"

(integer) -1 # 失敗

# 對一個空清單執行 LINSERT 指令

redis> EXISTS fake_list

(integer) 0

redis> LINSERT fake_list BEFORE "nono" "gogogog"

(integer) 0 # 失敗

設定指定索引的元素值

索引是基于0的下标

索引可以是負數，表示偏移量是從list尾部開始計數，如-1表示清單的最後一個元素

LSET key index value

# 對空清單(key 不存在)進行 LSET

redis> EXISTS list

(integer) 0

redis> LSET list 0 item

(error) ERR no such key

# 對非空清單進行 LSET

redis> LPUSH job "cook food"

(integer) 1

redis> LRANGE job 0 0

1) "cook food"

redis> LSET job 0 "play game"

redis> LRANGE job 0 0

1) "play game"

# index 超出範圍

redis> LLEN list # 清單長度為 1

(integer) 1

redis> LSET list 3 'out of range'

(error) ERR index out of range

移除并且傳回 key 對應的 list 的第一個元素

LPOP key

redis> LLEN course

(integer) 0

redis> RPUSH course algorithm001

(integer) 1

redis> RPUSH course c++101

(integer) 2

redis> LPOP course # 移除頭元素

"algorithm001"

移除并傳回存于 key 的 list 的最後一個元素

RPOP key

redis> RPUSH mylist "one"

(integer) 1

redis> RPUSH mylist "two"

(integer) 2

redis> RPUSH mylist "three"

(integer) 3

redis> RPOP mylist # 傳回被彈出的元素

"three"

redis> LRANGE mylist 0 -1 # 清單剩下的元素

1) "one"

2) "two"

傳回存儲在 key 的清單裡指定範圍内的元素

start 和 end 偏移量都是基于0的下标

偏移量也可以是負數，表示偏移量是從list尾部開始計數，如-1表示清單的最後一個元素

LRANGE key start stop

redis> RPUSH fp-language lisp

(integer) 1

redis> LRANGE fp-language 0 0

1) "lisp"

redis> RPUSH fp-language scheme

(integer) 2

redis> LRANGE fp-language 0 1

1) "lisp"

2) "scheme"

裁剪清單，改為原集合的一個子集

start 和 end 偏移量都是基于0的下标

偏移量也可以是負數，表示偏移量是從list尾部開始計數，如-1表示清單的最後一個元素

LTRIM key start stop

# 情況 1：常見情況， start 和 stop 都在清單的索引範圍之内

redis> LRANGE alpha 0 -1 # alpha 是一個包含 5 個字元串的清單

1) "h"

2) "e"

3) "l"

4) "l"

5) "o"

redis> LTRIM alpha 1 -1 # 删除 alpha 清單索引為 0 的元素

redis> LRANGE alpha 0 -1 # "h" 被删除了

1) "e"

2) "l"

3) "l"

4) "o"

# 情況 2： stop 比清單的最大下标還要大

redis> LTRIM alpha 1 10086 # 保留 alpha 清單索引 1 至索引 10086 上的元素

redis> LRANGE alpha 0 -1 # 隻有索引 0 上的元素 "e" 被删除了，其他元素還在

1) "l"

2) "l"

3) "o"

# 情況 3： start 和 stop 都比清單的最大下标要大，并且 start < stop

redis> LTRIM alpha 10086 123321

redis> LRANGE alpha 0 -1 # 清單被清空

(empty list or set)

# 情況 4： start 和 stop 都比清單的最大下标要大，并且 start > stop

redis> RPUSH new-alpha "h" "e" "l" "l" "o" # 重建立立一個新清單

(integer) 5

redis> LRANGE new-alpha 0 -1

1) "h"

2) "e"

3) "l"

4) "l"

5) "o"

redis> LTRIM new-alpha 123321 10086 # 執行 LTRIM

redis> LRANGE new-alpha 0 -1 # 同樣被清空

(empty list or set)

傳回存儲在 key 裡的list的長度

LLEN key

# 空清單

redis> LLEN job

(integer) 0

# 非空清單

redis> LPUSH job "cook food"

(integer) 1

redis> LPUSH job "have lunch"

(integer) 2

redis> LLEN job

(integer) 2

傳回清單裡索引對應的元素

LINDEX key index

redis> LPUSH mylist "World"

(integer) 1

redis> LPUSH mylist "Hello"

(integer) 2

redis> LINDEX mylist 0

"Hello"

redis> LINDEX mylist -1

"World"

redis> LINDEX mylist 3 # index不在 mylist 的區間範圍内

(nil)

set

無序集合

元素為string類型

元素具有唯一性，不重複

添加元素

SADD key member [member ...]

# 添加單個元素

redis> SADD bbs "discuz.net"

(integer) 1

# 添加重複元素

redis> SADD bbs "discuz.net"

(integer) 0

# 添加多個元素

redis> SADD bbs "tianya.cn" "groups.google.com"

(integer) 2

redis> SMEMBERS bbs

1) "discuz.net"

2) "groups.google.com"

3) "tianya.cn"

傳回key集合所有的元素

SMEMBERS key

# key 不存在或集合為空

redis> EXISTS not_exists_key

(integer) 0

redis> SMEMBERS not_exists_key

(empty list or set)

# 非空集合

redis> SADD language Ruby Python Clojure

(integer) 3

redis> SMEMBERS language

1) "Python"

2) "Ruby"

3) "Clojure"

傳回集合元素個數

SCARD key

redis> SADD tool pc printer phone

(integer) 3

redis> SCARD tool # 非空集合

(integer) 3

redis> DEL tool

(integer) 1

redis> SCARD tool # 空集合

(integer) 0

求多個集合的交集

SINTER key [key ...]

redis> SMEMBERS group_1

1) "LI LEI"

2) "TOM"

3) "JACK"

redis> SMEMBERS group_2

1) "HAN MEIMEI"

2) "JACK"

redis> SINTER group_1 group_2

1) "JACK"

求某集合與其它集合的差集

SDIFF key [key ...]

redis> SMEMBERS peter's_movies

1) "bet man"

2) "start war"

3) "2012"

redis> SMEMBERS joe's_movies

1) "hi, lady"

2) "Fast Five"

3) "2012"

redis> SDIFF peter's_movies joe's_movies

1) "bet man"

2) "start war"

求多個集合的合集

SUNION key [key ...]

redis> SMEMBERS songs

1) "Billie Jean"

redis> SMEMBERS my_songs

1) "Believe Me"

redis> SUNION songs my_songs

1) "Billie Jean"

2) "Believe Me"

判斷元素是否在集合中

SISMEMBER key member

redis> SMEMBERS joe's_movies

1) "hi, lady"

2) "Fast Five"

3) "2012"

redis> SISMEMBER joe's_movies "bet man"

(integer) 0

redis> SISMEMBER joe's_movies "Fast Five"

(integer) 1

zset

sorted set，有序集合

元素為string類型

元素具有唯一性，不重複

每個元素都會關聯一個double類型的score，表示權重，通過權重将元素從小到大排序

元素的score可以相同

添加

ZADD key score member [score member ...]

# 添加單個元素

redis> ZADD page_rank 10 google.com

(integer) 1

# 添加多個元素

redis> ZADD page_rank 9 baidu.com 8 bing.com

(integer) 2

redis> ZRANGE page_rank 0 -1 WITHSCORES

1) "bing.com"

2) "8"

3) "baidu.com"

4) "9"

5) "google.com"

6) "10"

# 添加已存在元素，且 score 值不變

redis> ZADD page_rank 10 google.com

(integer) 0

redis> ZRANGE page_rank 0 -1 WITHSCORES # 沒有改變

1) "bing.com"

2) "8"

3) "baidu.com"

4) "9"

5) "google.com"

6) "10"

# 添加已存在元素，但是改變 score 值

redis> ZADD page_rank 6 bing.com

(integer) 0

redis> ZRANGE page_rank 0 -1 WITHSCORES # bing.com 元素的 score 值被改變

1) "bing.com"

2) "6"

3) "baidu.com"

4) "9"

5) "google.com"

6) "10"

傳回指定範圍内的元素

ZRANGE key start stop

redis > ZRANGE salary 0 -1 WITHSCORES # 顯示整個有序內建員

1) "jack"

2) "3500"

3) "tom"

4) "5000"

5) "boss"

6) "10086"

redis > ZRANGE salary 1 2 WITHSCORES # 顯示有序集下标區間 1 至 2 的成員

1) "tom"

2) "5000"

3) "boss"

4) "10086"

redis > ZRANGE salary 0 200000 WITHSCORES # 測試 end 下标超出最大下标時的情況

1) "jack"

2) "3500"

3) "tom"

4) "5000"

5) "boss"

6) "10086"

redis > ZRANGE salary 200000 3000000 WITHSCORES # 測試當給定區間不存在于有序集時的情況

(empty list or set)

傳回元素個數

ZCARD key

redis > ZADD salary 2000 tom # 添加一個成員

(integer) 1

redis > ZCARD salary

(integer) 1

redis > ZADD salary 5000 jack # 再添加一個成員

(integer) 1

redis > ZCARD salary

(integer) 2

redis > EXISTS non_exists_key # 對不存在的 key 進行 ZCARD 操作

(integer) 0

redis > ZCARD non_exists_key

(integer) 0

傳回有序集key中，score值在min和max之間的成員

ZCOUNT key min max

redis> ZRANGE salary 0 -1 WITHSCORES # 測試資料

1) "jack"

2) "2000"

3) "peter"

4) "3500"

5) "tom"

6) "5000"

redis> ZCOUNT salary 2000 5000 # 計算薪水在 2000-5000 之間的人數

(integer) 3

redis> ZCOUNT salary 3000 5000 # 計算薪水在 3000-5000 之間的人數

(integer) 2

傳回有序集key中，成員member的score值

ZSCORE key member

redis> ZRANGE salary 0 -1 WITHSCORES # 測試資料

1) "tom"

2) "2000"

3) "peter"

4) "3500"

5) "jack"

6) "5000"

redis> ZSCORE salary peter # 注意傳回值是字元串

"3500"

redis進階

釋出訂閱

釋出者不是計劃發送消息給特定的接收者（訂閱者），而是釋出的消息分到不同的頻道，不需要知道什麼樣的訂閱者訂閱。

訂閱者對一個或多個頻道感興趣，隻需接收感興趣的消息，不需要知道什麼樣的釋出者釋出的釋出者和訂閱者的解耦合可以帶來更大的擴充性和更加動态的網絡拓撲用戶端發到頻道的消息，将會被推送到所有訂閱此頻道的用戶端。

用戶端不需要主動去擷取消息，隻需要訂閱頻道，這個頻道的内容就會被推送過來消息的格式。

推送消息的格式包含三部分

part1:消息類型，包含三種類型

subscribe，表示訂閱成功

unsubscribe，表示取消訂閱成功

message，表示其它終端釋出消息

如果第一部分的值為subscribe，則第二部分是頻道，第三部分是現在訂閱的頻道的數量

如果第一部分的值為unsubscribe，則第二部分是頻道，第三部分是現在訂閱的頻道的數量，如果為0則表示目前沒有

訂閱任何頻道，當在Pub/Sub以外狀态，用戶端可以發出任何redis指令

如果第一部分的值為message，則第二部分是來源頻道的名稱，第三部分是消息的内容

指令

SUBSCRIBE 頻道名稱 [頻道名稱 ...]

取消訂閱

如果不寫參數，表示取消所有訂閱

UNSUBSCRIBE 頻道名稱 [頻道名稱 ...]

釋出

PUBLISH 頻道消息

主從配置

一個master可以擁有多個slave，一個slave又可以擁有多個slave，如此下去，形成了強大的多級伺服器叢集架構

比如，将ip為192.168.1.10的機器作為主伺服器，将ip為192.168.1.11的機器作為從伺服器

設定主伺服器的配置

bind 192.168.1.10

設定從伺服器的配置

注意：在slaveof後面寫主機ip，再寫端口，而且端口必須寫

bind 192.168.1.11

slaveof 192.168.1.10 6379

在master和slave分别執行info指令，檢視輸出資訊

在master上寫資料

set hello world

在slave上讀資料

get hello

安全配置

Redis 安全

配置密碼

檢視密碼

CONFIG get requirepass

設定密碼

CONFIG set requirepass 123456

遠端連接配接

redis-cli -h 127.0.0.1 -p 6379 -a 123456

登入之後授權

auth 123456

python操作redis

redis子產品使用

安裝

pip install redis

引入子產品

import redis

連接配接

try:

r=redis.StrictRedis(host='localhost',port=6379)

except Exception,e:

print e.message

方式一：根據資料類型的不同，調用相應的方法，完成讀寫

更多方法同前面學的指令

r.set('name','hello')

r.get('name')

方式二：pipline

緩沖多條指令，然後一次性執行，減少伺服器-用戶端之間TCP資料庫包，進而提高效率

pipe = r.pipeline()

pipe.set('name', 'world')

pipe.get('name')

pipe.execute()

封裝

連接配接redis伺服器部分是一緻的

這裡将string類型的讀寫進行封裝

import redis

class RedisHelper():

def __init__(self,host='localhost',port=6379):

self.__redis = redis.StrictRedis(host, port)

def get(self,key):

if self.__redis.exists(key):

return self.__redis.get(key)

else:

return ""

def set(self,key,value):

self.__redis.set(key,value)

示例：使用者登入

業務過程如下：

輸入使用者名、密碼

密碼加密

判斷redis中是否記錄了使用者名，如果有則成功

如果redis中沒有使用者名，則到mysql中查詢

從mysql中查詢成功後，将使用者名記錄到redis中

from t2 import RedisHelper

from t3 import MysqlHelper

import hashlib

name=raw_input("請輸入使用者名：")

pwd=raw_input("請輸入密碼：")

sha1=hashlib.sha1()

sha1.update(pwd)

pwd1=sha1.hexdigest()

try:

redis=RedisHelper()

if redis.get('uname')==name:

print 'ok'

else:

mysql=MysqlHelper('localhost',3306,'test1','root','mysql')

upwd=mysql.get_one('select upwd from userinfos where uname=%s',[name])

if upwd==None:

print '使用者名錯誤'

elif upwd[0]==pwd1:

redis.set('uname', name)

print '登入成功'

else:

print "密碼錯誤"

except Exception,e:

print e.message