Redis部署与基本操作使用教程

一、简介

redis是一个key-value存储系统。
和Memcached类似，它支持存储的value类型相对更多，
包括string(字符串)、list(链表)、set(集合)和zset(有序集合)。
这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。

在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。
区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis 是一个高性能的key-value数据库。
redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。
它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。

        Memcache
        内存缓存服务，缓存数据保存在内存中，一旦断电重启，数据将丢失

    mongoDB
    开源免费的NOSQL 数据库，提供数据持久化服务，以文档的形式提供数据组织方式，而不是表
    Redis
    开源免费的 NOSQL数据库，提供数据持久化服务，即能实现内存缓存服务，也能提供数据结构服务
    取代MySQL 自建索引
    用来弥补关系型数据的不足

二、安装

1、默认安装位置

[root@localhost ~]#
wget http://download.redis.io/releases/redis-2.8.6.tar.gz
[root@localhost ~]#tar xzf redis-2.8.6.tar.gz
[root@localhost ~]#cd redis-2.8.6
[root@localhost ~]#make
#不指定安装位置，则会把redis的可执行文件安装到  redis-2.8.6/src/目录下

2、指定安装位置

[root@localhost ~]#tar xzf redis-2.8.6.tar.gz
[root@localhost ~]# cd redis-2.8.6
[root@localhost ~]# make
[root@localhost ~]# make PREFIX=/usr/local/redis install
#指定安装位置，如果没有指定安装位置PREFIX=/usr/local/redis，则make install会把redis安装到/usr/local/bin/目录下
[root@localhost~]# mkdir/usr/local/redis/etc
[root@localhost~]#cp /root/redis-2.8.6/redis.conf /usr/local/redis/etc/

3、安装的可执行文件的作用

redis-server    服务器端
redis-cli   客户端
redis-benchmark 调试
redis-check-dump    数据导出
redis-check-aof 数据导入

三、启动与关闭

1、  启动

路径/redis-server 配置文件

/usr/local/redis/bin/redis-server/usr/local/redis/etc/redis.conf

注意：需要修改配置文件

[root@localhostredis]# vi /usr/local/redis/etc/redis.conf

daemonizeno 改为
daemonize yes #后台启动

端口 6379

[root@localhostredis]# /usr/local/redis/bin/redis-cli

#客户端连接
    -h  IP  ：       连接指定的redis服务器
    -p  6379：       指定redis服务器的端口
    -a  密码：     使用密码登录
    -n 数据库号：    指定连接哪个数据库

2、  关闭redis

[root@localhost ~]# /usr/local/redis/bin/redis-cli shutdown

或

[root@localhost ~]# pkill  -9 redis

四、配置文件

[root@localhostredis]# vi /usr/local/redis/etc/redis.conf
#是否以后台进程运行，默认为no，如果需要以后台进程运行则改为yes
daemonize no


#如果以后台进程运行的话，就需要指定pid，你可以在此自定义redis.pid文件的位置。
pidfile /var/run/redis.pid


#接受连接的端口号，如果端口是0则redis将不会监听TCP socket连接
port 6379

# If you want you can bind a single interface, if the bind option is not
# specified all the interfaces will listen for incoming connections.
#
# bind 127.0.0.1

# Specify the path for the unix socket that will be used to listen for
# incoming connections. There is no default, so Redis will not listen
# on a unix socket when not specified.
#
# unixsocket /tmp/redis.sock
# unixsocketperm 755


#连接超时时间，单位秒。(0 to disable)？
timeout 300000000


#日志级别，默认是verbose（详细），各种日志级别：
#debug:很详细的信息，适合开发和测试
#verbose:包含许多不太有用的信息，但比debug要清爽一些（many rarely useful info, but not a mess like #the debug level）
#notice:比较适合生产环境
#warning:警告信息
loglevel verbose


#指定log文件的名字，默认是stdout。stdout会让redis把日志输出到标准输出。但是如果使用stdout而又以后台进#程的方式运行redis，则日志会输出到/dev/null
logfilestdout


#'syslog-enabled'设置为yes会把日志输出到系统日志，默认是no
# syslog-enabled no


#指定syslog的标示符，如果'syslog-enabled'是no，则这个选项无效。
# syslog-identredis


#指定syslog 设备（facility), 必须是USER或者LOCAL0到LOCAL7.
# syslog-facility local0


#设置数据库数目。默认的数据库是DB 0。可以通过SELECT 来选择一个数据库，dbid是[0,'databases'-1]的数字
databases 16

################## 快照#################################
#
# 硬盘上保存数据:
#
#   save
#
#   和都满足时就会触发数据保存动作。
#   
#
#   以下面的例子来说明：
#   过了900秒并且有1个key发生了改变 就会触发save动作
#   过了300秒并且有10个key发生了改变 就会触发save动作
#   过了60秒并且至少有10000个key发生了改变 也会触发save动作
#
#   注意：如果你不想让redis自动保存数据，那就把下面的配置注释掉！

save 900 1
save 300 10
save 60 10000


#存储数据时是否压缩数据。默认是yes。
rdbcompression yes

# 保存dump数据的文件名
dbfilenamedump.rdb

# 工作目录.
#
# 数据会被持久化到这个目录下的‘dbfilename’指定的文件中。
#
#
# 注意，这里指定的必须是目录而不能是文件。
dir ./

######## REPLICATION（复制，冗余）#################################

# Master-Slave replication. 使用slaveof把一个 Redis 实例设置成为另一个Redis server的从库（热备）. 注意： #配置只对当前slave有效。
# 因此可以把某个slave配置成使用不同的时间间隔来保存数据或者监听其他端口等等。
#命令格式：
# slaveof


#如果master有密码保护，则在slave与master进行数据同步之前需要进行密码校验，否则master会拒绝slave的请#求。
#
# masterauth

#当slave丢失与master的连接时，或者slave仍然在于master进行数据同步时（还没有与master保持一致），#slave可以有两种方式来响应客户端请求：
#
# 1) 如果 slave-serve-stale-data 设置成 'yes' (the default) slave会仍然响应客户端请求,此时可能会有问题。
#
# 2) 如果 slave-serve-stale data设置成  'no'  slave会返回"SYNC with master in progress"这样的错误信息。 但 INFO 和SLAVEOF命令除外。
#
slave-serve-stale-data yes

############### 安全 ###################################

# 需要客户端在执行任何命令之前指定 AUTH
#
# requirepassfoobared

# 命令重命名.
#
#
# 例如:
#
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# 同样可以通过把一个命令重命名为空串来彻底kill掉这个命令，比如：
#
# rename-command CONFIG ""

#################### 限制 ####################################

# 设置最大连接数. 默认没有限制,  '0' 意味着不限制.
#
# maxclients 128


#最大可使用内存。如果超过，Redis会试图删除EXPIRE集合中的keys，具体做法是：Redis会试图释放即将过期的#keys，而保护还有很长生命周期的keys。
#
#如果这样还不行，Redis就会报错，但像GET之类的查询请求还是会得到响应。
#
#警告：如果你想把Redis视为一个真正的DB的话，那不要设置,只有你只想把Redis作为cache或者
#有状态的server（'state' server)时才需要设置。
#
# maxmemory

#内存清理策略：如果达到了maxmemory，你可以采取如下动作：
#
# volatile-lru -> 使用LRU算法来删除过期的set
# allkeys-lru -> 删除任何遵循LRU算法的key
# volatile-random ->随机地删除过期set中的key
# allkeys->random -> 随机地删除一个key
# volatile-ttl -> 删除最近即将过期的key（the nearest expire time (minor TTL)）
# noeviction -> 根本不过期，写操作直接报错
#
#
# 默认策略:
#
# maxmemory-policy volatile-lru

# 对于处理redis内存来说，LRU和minor TTL算法不是精确的，而是近似的（估计的）算法。所以我们会检查某些样本#来达到内存检查的目的。默认的样本数是3，你可以修改它。
#
# maxmemory-samples 3

################# APPEND ONLY MODE ###############################

#默认情况下，Redis会异步的把数据保存到硬盘。如果你的应用场景允许因为系统崩溃等极端情况而导致最新数据丢失#的话，那这种做法已经很ok了。否则你应该打开‘append only’模式，开启这种模式后，Redis会在#appendonly.aof文件中添加每一个写操作，这个文件会在Redis启动时被读取来在内存中重新构建数据集。
#
#注意：如果你需要，你可以同时开启‘append only’模式和异步dumps模式（你需要注释掉上面的‘save’表达式来禁#止dumps），这种情况下，Redis重建数据集时会优先使用appendonly.aof而忽略dump.rdb
#
appendonly no

#  append only 文件名 (默认: "appendonly.aof")
# appendfilenameappendonly.aof

# 调用fsync()函数通知操作系统立刻向硬盘写数据
#
# Redis支持3中模式:
#
# no:不fsync, 只是通知OS可以flush数据了，具体是否flush取决于OS.性能更好.
# always: 每次写入append only 日志文件后都会fsync . 性能差，但很安全.
# everysec: 没间隔1秒进行一次fsync. 折中.
#
# 默认是 "everysec"
# appendfsync always
appendfsynceverysec
# appendfsync no

# 当AOF fsync策略被设置为always或者everysec并且后台保存进程（saving process)正在执行大量I/O操作时
# Redis可能会在fsync()调用上阻塞过长时间
#
no-appendfsync-on-rewrite no

# append only 文件的自动重写
# 当AOF 日志文件即将增长到指定百分比时，Redis可以通过调用BGREWRITEAOF 来自动重写append only文件。
#
# 它是这么干的：Redis会记住最近一次重写后的AOF 文件size。然后它会把这个size与当前size进行比较，如果当前# size比指定的百分比大，就会触发重写。同样，你需要指定AOF文件被重写的最小size，这对避免虽然百分比达到了# 但是实际上文件size还是很小（这种情况没有必要重写）却导致AOF文件重写的情况很有用。
#
#
# auto-aof-rewrite-percentage 设置为 0 可以关闭AOF重写功能

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

################## SLOW LOG ###################################

# Redis slow log用来记录超过指定执行时间的查询。
#
# 你可以指定两个参数：一个是慢查询的阀值，单位是毫秒；另外一个是slow log的长度，相当于一个队列。

# 负数则关闭slow log，0则会导致每个命令都被记录
slowlog-log-slower-than 10000

# 不设置会消耗过多内存，所以还是要设置一下。可以使用SLOWLOG RESET命令来回收slow log使用的内存
slowlog-max-len 1024

################ 虚拟内存 ###############################
#使用redis 就别用虚拟内存了，绝对不是一个好主意，加个机器吧，所以这里不翻译啦！！

### WARNING! Virtual Memory is deprecated in Redis 2.4
### The use of Virtual Memory is strongly discouraged.

# Virtual Memory allows Redis to work with datasets bigger than the actual
# amount of RAM needed to hold the whole dataset in memory.
# In order to do so very used keys are taken in memory while the other keys
# are swapped into a swap file, similarly to what operating systems do
# with memory pages.
#
# To enable VM just set 'vm-enabled' to yes, and set the following three
# VM parameters accordingly to your needs.

vm-enabled no
# vm-enabled yes

# This is the path of the Redis swap file. As you can guess, swap files
# can't be shared by different Redis instances, so make sure to use a swap
# file for every redis process you are running. Redis will complain if the
# swap file is already in use.
#
# The best kind of storage for the Redis swap file (that's accessed at random)
# is a Solid State Disk (SSD).
#
# *** WARNING *** if you are using a shared hosting the default of putting
# the swap file under /tmp is not secure. Create a dir with access granted
# only to Redis user and configure Redis to create the swap file there.
vm-swap-file /tmp/redis.swap

# vm-max-memory configures the VM to use at max the specified amount of
# RAM. Everything that deos not fit will be swapped on disk *if* possible, that
# is, if there is still enough contiguous space in the swap file.
#
# With vm-max-memory 0 the system will swap everything it can. Not a good
# default, just specify the max amount of RAM you can in bytes, but it's
# better to leave some margin. For instance specify an amount of RAM
# that's more or less between 60 and 80% of your free RAM.
vm-max-memory 0

# Redis swap files is split into pages. An object can be saved using multiple
# contiguous pages, but pages can't be shared between different objects.
# So if your page is too big, small objects swapped out on disk will waste
# a lot of space. If you page is too small, there is less space in the swap
# file (assuming you configured the same number of total swap file pages).
#
# If you use a lot of small objects, use a page size of 64 or 32 bytes.
# If you use a lot of big objects, use a bigger page size.
# If unsure, use the default :)
vm-page-size 32

# Number of total memory pages in the swap file.
# Given that the page table (a bitmap of free/used pages) is taken in memory,
# every 8 pages on disk will consume 1 byte of RAM.
#
# The total swap size is vm-page-size * vm-pages
#
# With the default of 32-bytes memory pages and 134217728 pages Redis will
# use a 4 GB swap file, that will use 16 MB of RAM for the page table.
#
# It's better to use the smallest acceptable value for your application,
# but the default is large in order to work in most conditions.
vm-pages 134217728

# Max number of VM I/O threads running at the same time.
# This threads are used to read/write data from/to swap file, since they
# also encode and decode objects from disk to memory or the reverse, a bigger
# number of threads can help with big objects even if they can't help with
# I/O itself as the physical device may not be able to couple with many
# reads/writes operations at the same time.
#
# The special value of 0 turn off threaded I/O and enables the blocking
# Virtual Memory implementation.
vm-max-threads 4

################高级配置###############################

# Hashes are encoded in a special way (much more memory efficient) when they
# have at max a given numer of elements, and the biggest element does not
# exceed a given threshold. You can configure this limits with the following
# configuration directives.
hash-max-zipmap-entries 512
hash-max-zipmap-value 64

# Similarly to hashes, small lists are also encoded in a special way in order
# to save a lot of space. The special representation is only used when
# you are under the following limits:
list-max-ziplist-entries 512
list-max-ziplist-value 64

# Sets have a special encoding in just one case: when a set is composed
# of just strings that happens to be integers in radix 10 in the range
# of 64 bit signed integers.
# The following configuration setting sets the limit in the size of the
# set in order to use this special memory saving encoding.
set-max-intset-entries 512

# Similarly to hashes and lists, sorted sets are also specially encoded in
# order to save a lot of space. This encoding is only used when the length and
# elements of a sorted set are below the following limits:
zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
# order to help rehashing the main Redis hash table (the one mapping top-level
# keys to values). The hash table implementation redis uses (see dict.c)
# performs a lazy rehashing: the more operation you run into an hash table
# that is rhashing, the more rehashing "steps" are performed, so if the
# server is idle the rehashing is never complete and some more memory is used
# by the hash table.
#
# The default is to use this millisecond 10 times every second in order to
# active rehashing the main dictionaries, freeing memory when possible.
#
# If unsure:
# use "activerehashing no" if you have hard latency requirements and it is
# not a good thing in your environment that Redis can reply form time to time
# to queries with 2 milliseconds delay.
#
# use "activerehashing yes" if you don't have such hard requirements but
# want to free memory asap when possible.
activerehashing yes

################## INCLUDES ###################################

# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all redis server but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# include /path/to/local.conf
# include /path/to/other.conf

五、Redis的数据类型

1. 共计5种类型

string(字符串)、hash(哈希表) list(双向队列)、set(集合)和zset(有序集合)

2. String（子串类型）

String是最简单的类型，一个Key对应一个Value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。

1）set 键 "值"
设置一个键和值，键存在则覆盖，返回ok

127.0.0.1:6379> set name liming
OK

2）get 键
获取一个键的值，返回值

127.0.0.1:6379> get name
"liming"

3） setnx 键 值
只有当该键不存在时设置一个键的值，若键已存在则返回0表示失败（防止覆盖），

127.0.0.1:6379>setnx age 18
(integer) 1
127.0.0.1:6379>setnx age 18
(integer) 0

4） setex 键 [有效时间] 值
设置一个指定有效期的键和值（单位秒）。不写有效时间则表示永久有效，等价于set

127.0.0.1:6379>setex movie 30 canglaoshi
OK
127.0.0.1:6379>ttl movie                //获取键的有效时间
(integer) 26
127.0.0.1:6379>ttl movie
(integer) 20
127.0.0.1:6379> get movie
"canglaoshi"
127.0.0.1:6379>ttl movie
(integer) -2
127.0.0.1:6379> get movie
(nil)

5）ttl 键
以秒为单位，返回给定 key 的剩余生存时间
>当 key 不存在时，返回 -2 。
当 key 存在但没有设置剩余生存时间时，返回 -1 。
否则，以秒为单位，返回 key 的剩余生存时间。

127.0.0.1:6379> ttl name
(integer) -1

6） setrange 键 位置 子字串
替换子字符串 (替换长度由子子串长度决定)

127.0.0.1:6379> set key1 "hello world"
OK
127.0.0.1:6379> get key1
"hello world"
127.0.0.1:6379>setrange key1 6 liming
(integer) 12
127.0.0.1:6379> get key1
"hello liming"
    #将key1键对应值的第6个位置开始替换（字符串位置从0开始计算）

7） mset 键1 值1 键2 值2 键3 值3 ....
批量设置键和值,成功则返回ok

127.0.0.1:6379>mset name1 lm name2 sc name3 zjj
OK

8） mget 键1 键2 键3....
批量获取值

127.0.0.1:6379>mget name1 name2 name3
1) "lm"
2) "sc"
3) "zjj"

9） msetnx 键1 值1 键2 值2 键3 值3 ....
批量设置不存在的键和值,成功则返回ok

10） getset 键 新值
获取原值，并设置新值

127.0.0.1:6379> set name "shenchao"
OK
127.0.0.1:6379> get name
"shenchao"
127.0.0.1:6379>getset name "liming"
"shenchao"
127.0.0.1:6379> get name
"liming"

11） getrange 键 0 4
获取指定范围的值（获取指定0到4位置上的值，字符串位置从0开始计算）。参考setrange。

127.0.0.1:6379>getrange key1 0 4
"hello"

12） incr键
指定键的值做加1操作，返回加后的结果（只能加数字）。

127.0.0.1:6379> set age 18
OK
127.0.0.1:6379>incr age
(integer) 19
127.0.0.1:6379> get age
"19"

13） incrby 键 m
//其中m可以是正整数或负整数
加指定值，键不存在时候会设置键

127.0.0.1:6379>incrby age 10
(integer) 29
127.0.0.1:6379> get age
"29"
127.0.0.1:6379>incrby age -5
(integer) 24

14）decr 键
指定键的值做减1操作，返回减后的结果。

127.0.0.1:6379>decr age
(integer) 23
127.0.0.1:6379> get age
"23"

15） decrby 键 n
//其中n可以是正整数或负整数
设置某个键减上指定值

127.0.0.1:6379>decrby age 5
(integer) 18
127.0.0.1:6379>decrby age -10
(integer) 28
127.0.0.1:6379> get age
"28"

16）append 键 追加字串
给指定key的字符串追加value，返回新字符串值的长度

127.0.0.1:6379> append name1 " have a hot body!"
(integer) 19
127.0.0.1:6379> get name1
"lm have a hot body!"

17） strlen 键名
strlen求一个键长度

127.0.0.1:6379>strlen name1
(integer) 19

18）del命令：删除一个键

127.0.0.1:6379>del name3
(integer) 1
127.0.0.1:6379> get name3
(nil)

3. hashs类型

注意：redis中没有表概念，所有的数据都存入键中。

    string键类型：所有的值（可以是任何数据类型）都保存在一个键当中，放在一个内存块中

    hashs键类型：所有的值也都保存在一个键当中，只是放在不同的内存块中，每个块称作字段

1）hset key field value
设置一个键，在键中保存字段和值

hset 哈希集（键） 字段 值

127.0.0.1:6379>hset user1 name4 ysm
(integer) 1
127.0.0.1:6379> keys *                  //查看库中所有的键
1) "aa"
2) "name"
3) "name1"
4) "user1"
5) "name2"
6) "age"
7) "key1"

2）hsetnx 键 字段 值
设置一个键中，不存在的字段和值。如果字段存在则报错（成功返回1，失败返回0）

127.0.0.1:6379>hsetnx user1 name1 lm
(integer) 1
127.0.0.1:6379>hsetnx user1 name1 sc
(integer) 0                 //报错
127.0.0.1:6379>hget user1 name1
"lm"                        //内容没有更新

3）hmset 键 字段1 值1 字段2 值2 …
在一个键中，批量设置字段

127.0.0.1:6379>hmset user2 name liming age 36 interest AV-Girl
OK

4）hget 键 字段
获取键中的一个指定字段的值

127.0.0.1:6379>hget user1 name1
"lm"
127.0.0.1:6379>hget user2 interest
"AV-Girl"

5）hmget 键 字段1 [字段2…]
获取键中一个或多个字段的值

127.0.0.1:6379>hmget user2 name age interest
1) "liming"
2) "36"
3) "AV-Girl"

6） hexists ：判断指定的字段是否存在于键中

hexists 键 字段

例如：

127.0.0.1:6379> HEXISTS user2 age
(integer) 1                         //存在
127.0.0.1:6379> HEXISTS user1 age   
(integer) 0                         //不存在

7） hlen ：获取键中的字段数量

hlen 键

127.0.0.1:6379>hlen user2
(integer) 3                         //user2键中有3个字段

8）hkeys ：获取键中的所有字段名

127.0.0.1:6379>hkeys user2
1) "name"
2) "age"
3) "interest"

9）hvals：获取键中所有字段的值

127.0.0.1:6379>hvals user2
1) "liming"
2) "36"
3) "AV-Girl"

10）hgetall ：获取键中的所有字段和值

127.0.0.1:6379>hgetall user2
1) "name"
2) "liming"
3) "age"
4) "36"
5) "interest"
6) "AV-Girl"

11）hincrby：将键中指定字段的值，增加指定的数字

127.0.0.1:6379>hincrby user2 age 5
(integer) 41

127.0.0.1:6379> HINCRBY user2 name 5
(error) ERR hash value is not an integer    //值不是数字的字段，不能加数字

12）hdel 键 字段1 字段2
删除键中的一个或多个字段

127.0.0.1:6379>hdel user2 age interest
(integer) 2
127.0.0.1:6379>hkeys user2
1) "name"
    //删除一个键，还是要使用del命令

4. list类型（双向链表结构）

    List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作中key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。

1）lpush 键 值1 [值2…]
从队列左边向队列写入一个或多个值（认为队列的左面为队列头，右边为队列尾）

127.0.0.1:6379>lpush list1 1
(integer) 1
127.0.0.1:6379>lpush list1 2
(integer) 2
127.0.0.1:6379>lpush list1 3
(integer) 3
127.0.0.1:6379>lpush list1 4
(integer) 4

127.0.0.1:6379>lpush list2 one two three four
(integer) 4

2）lrange 键 起始下标 终止下标
从队列中获取指定的返回值（从队列左边向右获取）

下标：0代表队列中第一个元素，1代表第二个元素，依次类推
    -1代表队列中最后一个元素，-2代表倒数第二个元素

127.0.0.1:6379> LRANGE list1 0 -1
1) "4"      //4是从左面写入队列的最后一个值，所以在队列的开头
2) "3"
3) "2"
4) "1"      //1是从左面写入队列的第一个值，所以直接放到了队列尾。
            
127.0.0.1:6379> LRANGE list2 0 -1
1) "four"
2) "three"
3) "two"
4) "one"

127.0.0.1:6379> LRANGE list1 0 1
1) "4"
2) "3"

127.0.0.1:6379> LRANGE list2 -4 3
1) "four"       //-4代表从队列右边数第四个元素
2) "three"
3) "two"
4) "one"        //3代表从队列左边数第四个元素

3）rpush键 值1 [值2…]
从队列右边向队列写入一个或多个值

127.0.0.1:6379> RPUSH list3 1 2 3 4
(integer) 4
127.0.0.1:6379> LRANGE list3 0 -1
1) "1"      //从队列右边向队列写入值，第一个值就会写到队列的开头
2) "2"
3) "3"
4) "4"

4）linsert 键 before|after 原值 新值
在队列中指定元素之前或之后插入新值

127.0.0.1:6379> LINSERT list3 before 3 hello
(integer) 5
127.0.0.1:6379> LRANGE list3 0 -1
1) "1"
2) "2"
3) "hello"
4) "3"
5) "4"

5）lset 键 下标 新值
给队列中指定元素设定新值

127.0.0.1:6379>lset list3 2 "5"
OK
127.0.0.1:6379> LRANGE list3 0 -1
1) "1"
2) "2"
3) "5"
4) "3"
5) "4"

6）lrem 键 n 指定值

从队列中删除n个值为“指定值”的元素
n > 0   从队列头向尾删除n个元素
n < 0   从队列尾向头删除n个元素
n = 0   删除所有值为“指定值”的元素

127.0.0.1:6379>rpush list4 hello 1 hello 2 hello 3 hello
(integer) 7
127.0.0.1:6379>lrange list4 0 -1
1) "hello"
2) "1"
3) "hello"
4) "2"
5) "hello"
6) "3"
7) "hello"
127.0.0.1:6379>lrem list4 -2 hello          //删除后两个hello
(integer) 2
127.0.0.1:6379>lrange list4 0 -1
1) "hello"
2) "1"
3) "hello"
4) "2"
5) "3"
127.0.0.1:6379>lrem list4 0 hello           //删除所有hello
(integer) 2
127.0.0.1:6379>lrange list4 0 -1
1) "1"
2) "2"
3) "3"

7）ltrim 键 起始下标 结束下标
修剪队列，让队列只保留指定指定范围内的元素

127.0.0.1:6379> RPUSH list5 1 2 3 4
(integer) 4
127.0.0.1:6379>ltrim list5 1 2
OK
127.0.0.1:6379>lrange list5 0 -1
1) "2"
2) "3"

8）lpop 键
从指定的队列左面移除一个值

127.0.0.1:6379>lrange list1 0 -1
1) "4"
2) "3"
3) "2"
4) "1"
127.0.0.1:6379>lpop list1
"4"
127.0.0.1:6379>lrange list1 0 -1
1) "3"
2) "2"
3) "1"

9）rpop 键
从指定队列的右边移除一个值

127.0.0.1:6379>lrange list1 0 -1
1) "3"
2) "2"
3) "1"
127.0.0.1:6379>rpop list1
"1"
127.0.0.1:6379>lrange list1 0 -1
1) "3"
2) "2"

10）rpoplpush 源队列 目标队列
移除源队列的最后一个元素，并把该元素写入目标队列

127.0.0.1:6379>lrange list1 0 -1
1) "3"
2) "2"
127.0.0.1:6379>lrange list5 0 -1
1) "2"
2) "3"
127.0.0.1:6379> RPOPLPUSH list1 list5
"2"
127.0.0.1:6379>lrange list1 0 -1
1) "3"
127.0.0.1:6379>lrange list5 0 -1
1) "2"
2) "2"
3) "3"

11）lindex 键 下标
获取队列中指定下标元素的值

127.0.0.1:6379>lrange list2 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379>lindex list2 1
"three"
127.0.0.1:6379>lindex list2 3
"one"

12）llen 键
获得队列的长度

127.0.0.1:6379>llen list2
(integer) 4

5. sets类型和操作

    Set是集合，它是string类型的无序集合。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现社交网站中的好友推荐和blog的tag功能。

1） sadd 键 值1[值2…]
添加一个或多个元素到集合中

127.0.0.1:6379>sadd mset1 1
(integer) 1
127.0.0.1:6379>sadd mset1 2 3 4
(integer) 3

2） smembers 键
获取集合里面所有的元素

127.0.0.1:6379>smembers mset1
1) "1"
2) "2"
3) "3"
4) "4"

3） srem 键 值1[值2…]
从集合中删除指定的一个或多个元素

127.0.0.1:6379>srem mset1 3 4
(integer) 2
127.0.0.1:6379>smembers mset1
1) "1"
2) "2"

    （删除键，依然使用“del 键” 命令）

4） spop 键
随机从集合中删除一个元素，并返回

127.0.0.1:6379>sadd mset2 4 5 6 7 8
(integer) 5
127.0.0.1:6379>spop mset2
"4"
127.0.0.1:6379>spop mset2
"5"
127.0.0.1:6379>spop mset2
"8"
127.0.0.1:6379>smembers mset2
1) "6"
2) "7"

5） srandmember 键 值
随机返回集合中一个元素，但不删除

127.0.0.1:6379>sadd mset3 4 5 6 7 8
(integer) 5
127.0.0.1:6379>srandmember mset3
"5"
127.0.0.1:6379>srandmember mset3
"5"
127.0.0.1:6379>srandmember mset3
"4"

6） scard 键
获取集合里面元素个数

127.0.0.1:6379>scard mset1
(integer) 2

7） sismember 键 值
确定一个指定的值是否是集合中的元素

127.0.0.1:6379>smembers mset1
1) "1"
2) "2"
127.0.0.1:6379>sismember mset1 3
(integer) 0
127.0.0.1:6379>sismember mset1 1
(integer) 1

8） sdiff 集合1 集合2
返回集合1与集合2的差集。以集合1为主

127.0.0.1:6379>sadd mset4 1 2 3
(integer) 3
127.0.0.1:6379>sadd mset5 2 3 4
(integer) 3
127.0.0.1:6379>sdiff mset4 mset5
1) "1"

9） sdiffstore 新集合 集合1 集合2
返回集合1和集合2的差集，并把结果存入新集合

127.0.0.1:6379>sadd mset4 1 2 3
(integer) 3
127.0.0.1:6379>sadd mset5 2 3 4
(integer) 3
127.0.0.1:6379>sdiffstore mset6 mset5 mset4
(integer) 1             //返回值为1 ，证明成功
127.0.0.1:6379>smembers mset6
1) "4"                  //结果存入了mset6，值为4

10） sinter 集合1 集合2
获得两个集合的交集

127.0.0.1:6379>smembers mset4
1) "1"
2) "2"
3) "3"
127.0.0.1:6379>smembers mset5
1) "2"
2) "3"
3) "4"
127.0.0.1:6379> sinter mset4 mset5
1) "2"
2) "3"

11） sinterstore 新集合 集合1 集合2
获得集合1和集合2的交集，并把结果存入新集合

127.0.0.1:6379>sinterstore mset7 mset4 mset5
(integer) 2
127.0.0.1:6379>smembers mset7
1) "2"
2) "3"

12） sunion 集合1 集合2
获得指定集合的并集

127.0.0.1:6379>sunion mset4 mset5
1) "1"
2) "2"
3) "3"
4) "4"

13） sunionstore 新集合 集合1 集合2
获得指定集合的并集，并把结果保存如新集合

127.0.0.1:6379>sunionstore mset8 mset4 mset5
(integer) 4
127.0.0.1:6379>smembers mset8
1) "1"
2) "2"
3) "3"
4) "4"

14） smove 源集合 目标集合 值
将指定的值从源集合移动到目标集合

127.0.0.1:6379>smembers mset1
1) "1"
2) "2"
127.0.0.1:6379>smembers mset2
1) "6"
2) "7"
127.0.0.1:6379>smove mset1 mset2 1
(integer) 1
127.0.0.1:6379>smembers mset1
1) "2"
127.0.0.1:6379>smembers mset2
1) "1"
2) "6"
3) "7"

一、Redis基础部分:

1、redis介绍与安装比mysql快10倍以上

*****************redis适用场合****************

1.取最新N个数据的操作

2.排行榜应用,取TOP N 操作

3.需要精确设定过期时间的应用

4.计数器应用

5.Uniq操作,获取某段时间所有数据排重值

6.实时系统,反垃圾系统7.Pub/Sub构建实时消息系统

7.Pub/Sub构建实时消息系统8.构建队列系统

9.缓存

=============================================

SET操作每秒钟 110000 次,GET操作每秒钟 81000 次,服务器配置如下:

Linux 2.6, Xeon X3320 2.5Ghz.

stackoverflow 网站使用 Redis 做为缓存服务器。

同时也会将数据写到硬盘上。所以数据是安全的(除突然断电外,重启服务会写到dump.rdb文件中)

 

1.安装:

tar zxvf redis-2.6.9.tar.gz

cd redis-2.6.9

make

cd src && make install

2.移动配置文件位置(为了便于管理)

cd /usr/local/

mkdir -p /usr/local/redis/bin

mkdir -p /usr/local/redis/etc

mv /lamp/redis-2.6.9/redis.conf /usr/local/redis/etc

cd /lamp/redis-2.6.9/src

mv mkreleasehdr.sh redis-benchmark redis-check-aof redis-check-dump redis-cli redis-server /usr/local/redis/bin

3.修改配置文件

vi /usr/local/redis/etc/redis.conf

 

一、将daemonize no 中no改为yes[yes指后台运行]

4.启动/随机启动:

cd /usr/local/redis/bin

./redis-server /usr/local/redis/etc/redis.conf#启动redis并指定配置文件。

#vi /etc/rc.local #设置随机启动。

/usr/local/redis/bin/redis-server /usr/local/redis/etc/redis.conf

5.查看是否启动成功

ps -ef | grep redis

netstat -tunpl | grep 6379#查看端口是否占用。

6.进入客户端/退出

cd /usr/local/redis/bin

./redis-cli#进入

quit#退出

7.关闭redis  

pkill redis-server#关闭

./redis-cli shutdown#关闭

************************************Redis安全************************************

 

Redis的安全性???(由以下4种方式)

1.用ACL控制器安全性。

2.在redis.conf配置文件增加下面这一行配置,即可把redis绑定在单个接口上(但并不是只有接受这个网卡的数据)。

bind 127.0.0.1

3.给redis加上较长密码(无需要记住)

4.在redis.conf配置启用认证功能。

5.SSL代理

6.禁用指定命令。

************************************** Redis配置 **********************************************

daemonize    如果需要在后台运行,把该项改为yes  

pidfile      配置多个pid的地址 默认在/var/run/redis.pid

bind 绑定ip,设置后只接受来自该ip的请求

port 监听端口,默认为6379

timeout      设置客户端连接时的超时时间,单位为秒

loglevel     分为4级,debug、verbose、notice、warning

logfile      配置log文件地址

databases    设置数据库的个数,默认使用的数据库为0

save         设置redis进行数据库镜像的频率

rdbcompression    在进行镜像备份时,是否进行压缩

Dbfilename        镜像备份文件的文件名

Dir   数据库镜像备份的文件放置路径

Slaveof     设置数据库为其他数据库的从数据库

Masterauth 主数据库连接需要的密码验证

Requirepass     设置登录时需要使用的密码

Maxclients 限制同时连接的客户数量

Maxmemory 设置redis能够使用的最大内存

Appendonly 开启append only模式

以下了解即可:

Appendfsync 设置对appendonly.aof文件同步的频率

vm-enabled 是否开启虚拟内存支持

vm-swap-file 设置虚拟内存的交换文件路径

vm-max-memory 设置redis使用的最大物理内存大小

vm-page-size 设置虚拟内存的页大小

vm-pages 设置交换文件的总的page数量

vm-max-threads 设置VM IO同时使用的线程数量

Glueoutputbuf 把小的输出缓存存放在一起

hash-max-zipmap-entries 设置hash的临界值

Activerehashing 重新hash

*******************************************************************

5种数据类型:字符串、哈希、链表、集合、有序集合。

支持:push/pop、add/remove 、取交集、并集、差集、排序。

redis<===同步====>mysql

同时也会将数据写到硬盘上。所以数据是安全的(除突然断电外,重启服务会写到dump.rdb文件中)

*******************************************************************

select num#选择库,默认在0库,共16个库

auth liweijie#授权用户所需密码(密码就是redis.conf中配置的密码)

flushdb#清空数据库。

String(字符串)类型:

set name lijie#设置键name的值为lijie

get name#获取name的值。

keys *#查询所有的键。

setnx name liweijie#如果键已存在则返回0,不更新,防止覆盖。

setex haircolor 10 red #设置键的值的有效期为10秒。

setrange email 6 lampbre.com#替换键的值从第6个字符开始换为lampbre.com

mset name1 李大伟 name2 李小伟#设置多个键的值。

msetnxname1 张三 name3 李四#判断键是否存在,不存在则设置,否则不设置返回0

mget name1 name2 name3#一次获取多个键的值。

getset name1 Tom#重新设置键的值,并返回旧的键值。

getrange email 6 18#截取email键的值,从第6-18位间的字符。

incr uid#每次自增1 (如果key中uid不存在,则设置并从0开始,下同)

incrby uid 5#每次自增5

incrby uid -5#每次自减5

decr uid #每次自减1

decrby uid 5#每次自减5

appendname1 @126.com#给name1的值,添加字符串@126.com

strlenname1#返回键name1的值的长度。

*************************************************************************

Hashes(哈希)类型:

hset user:001 name liweijie#哈希设置用户user:001的name键值为liweijie

hset user:001 age 21#同样,增加一个age键值为21

hsetnx user:001 age 22#同上,但检测键是否存在。若不存在创建。

hmset user:002 name liweijie2 age 26 sex 1#同时设置多个键的值。

hget user:001 name#哈希获取用户user:001的name键的值。

hget user:001 age #同上。

hmget user:001 name age sex#获取多个指定的键的值。

hgetall user:001#获取所有键的值。

hincrbyuser:001 age -8#在指定键上加上给定的值。

hexists user:001 sex#检测指定的键值是否存在。

hlen user:001#返回指定哈希的键个数/字段个数。

hdel user:001 sex#删除指定(user:001)哈希的指定字段或是键值。

hkeys user:003#返回哈希里所有字段或是键值。

*********************************************************************

Lists(链表)类型及操作(?；蚨恿?:

lpush mylist "world"#从头部插入字符串

lpush mylist "hello"#同上

lrange mylist 0 -1#获取从0到最后一个如[1) "hello" 2) "world"]

rpush mylist "jiejie"#在尾部插入

linsert mylist before "hello" "this is linsert" #指定插入位置(在hello之前插入)。

lset mylist 0 "what"#设置修改指定下标的值。

lrem mylist 1 "hello"#删除(1个)一个值为hello的元素。(n<0从尾部删除,n=0全部删除)

ltrim mylist 1 2 #保留表中下标为1/2的元素。

lpop mylist#弹出开头元素并返回。

rpop mylist#弹出尾部元素并返回。

rpoplpush mylist mylist2 #从mylist尾部弹出插入到mylist2的头部。

lindex mylist 0#获取表下标为0的元素值。

llen mylist#返回表元素个数(相当于count($arr  ))。

*********************************************************************

sets(集合)类型及操作(好友推荐、blog、tag功能):

smembers myset#查看myset集合中所有元素值。

sadd myset "hello"#向mysets集合中添加一个值hello

srem myset "hello"#删除myset集合中名称为hello的元素。

spop myset #随机弹出并返回mysets中的一个元素。

sdiff myset2 myset3#返回myset2中的与myset3的差集(以myset2为准)。

sdiffstore myset4 myset2 myset3#返回myset2中的与myset3的差集,并存入myset4中去。

sinter myset2 myset3#返回myset2与myset3的交集。

sinterstore myset5 myset2 myset3#返回myset2与myset3的交集,并存入myset5中去。

sunion myset2 myset3#求并集(去重复)

sunionstore myset6 myset2 myset3#求并集,并存入myset6中去。

smove myset2 myset3 "three"#将myset2中的three移到myset3中去。

scard myset2#返回元素个数。

sismember myset2 "one"#判断元素one是不是myset2集合的(相当于is_array())。

srandmember myset2#随机返回myset2集合中的一个元素,但不删除(相当于array_rand())。

*********************************************************************

sorted sets(有序集合)类型及操作(以scores排序):

zadd myzset 1 "one"#向顺序1的添加元素one

zadd myzset 2 "two"#同上。

zadd myzset 3 "two"#相当于更新顺序为2的值

zrange myzset 0 -1 withscores#查看所有元素并带上排序(默认升序)。

zrem myzset "two"#删除two

zincrby myzset 2 "two"#将two的顺序值加上2

zrank myzset "two"#返回集合中元素的索引下标值。

zrevrank myzset two#元素反转并返回新下标值。

zrevrange myzset 0 -1 withscores#按顺序反转(相当于降序排序)

zrangebyscore myzset 1 10 withscores#返回顺序为1-10的元素(可做分页)。

zcount myzset 1 10 #返回顺序在1-10之间元素的个数。

zcard myzset#返回集合中所有元素的个数。

zremrangebyrank myzset 1 2#删除集合中下标为1到2的元素。

zremrangebyscore myzset 1 10#删除集合中顺序为1到10的元素。

Redis常用命令  

键/值相关命令。

keys * #查询所有

keys user*#查询指定的

exists user:001#判断是否存在。

del name#删除指定的键。

expire addr 10#设置过期时间

ttl addr#查询过期时间

select 0 #选择数据库

move age 1#将age移到1数据库。

get age #获取

persist age#移除age的过期时间。

randomkey#随机返回一个key

rename name1 name2#重命名键

type myset#返回键的类型。

ping #测试redis连接是否存活。

echo lamp#输出一个lamp

select 10#选择数据库。

quit/exit/crtl+C#退出客户端

dbsize#返回库里的键的个数。

服务器相关命令:

info#显示redis服务器的相关信息。

config get */loglevel #返回所有/指定的配置信息。

flushdb#删除当前库中的所有键/表。

flushall#删除所有数据库中的所有键/表

 

二、Redis高级部分:

1、Redis安全性:  

1.用ACL控制器安全性。

2.给redis加上较长密码

# requirepass foobared

requirepass beijing

3.在redis.conf配置启用认证功能。

方式一:Auth beijing

方式二:./redis-cli -a beijing

4.在redis.conf配置文件增加下面这一行配置,即可把redis绑定在单个接口上(但并不是只有接受这个网卡的数据)。

bind 127.0.0.1(单台机器的时候可以配置,分布式或主从复制时最好不要配置)

5.SSL代理

6.禁用指定命令。

2、Redis主从复制:  

redis只需在从服务器(slave)上配置即可:

slaveof 211.122.11.11 6379 #指定master 的ip 和端口

masterauth beijing#这是master主机的密码

Info#查看主/从服务器的状态。

3、Redis事务处理:  

Redis事务很不完善。

4、Redis持久化机制:  

1.两种方式:一、备份数据到磁盘(快照)[ snapshotting(快照)也是默认方式]