Redis使用教程

1.Redis 基础   

Redis是用C语言开发的一个开源的高性能键值对（Key-value）数据库，他通过提供多种键值数据类型来适应不同场景的存储需求。Redis支持的键值数据类型如下：

字符串类型 （String）：“zhanshen”

哈希（hash）

字符串列表（list）

字符串集合（set）

有序字符串集合（sorted set）

1.1 Redis 安装

*1:安装Redis编译的c环境，yum install gcc–c++  *2:将Redis-2.6.16.tar.gz上传到Linux系统中  *3:解压到software目录下，tar –xvf redis-2.6.16.tar.gz –C /software  *4:进入Redis-2.6.16目录，使用make命令编译redis  *5:在Redis目录中，使用 make PREFIX=/software/redis install 命令安装redis到/software/redis中  *6:拷贝redis-2.6.16中的redis.conf到安装目录redis中         cp redis.conf /redis  *7:启动redis在bin下执行命令redis-service redis.conf  *8:如需远程连接redis，需配置redis端口7379在Linux防火墙中开发  /sbin/iptables -I INPUT -p tcp --dport 6379 -j ACCEPT /etc/rc.d/init.d/iptables save

 

Bin目录下的可执行文件：

   Redis-benchmark       ---性能测试工具

   Redis-check-aof        ---AOF文件修复工具

   Redis-check-dump      ---RDB文件检查工具（快照持久化文件）

   Redis-cli               ---命令行客户端

   Redis-server            ---redis服务器启动命令

1.2 Redis的启动和关闭

Redis启动方式：

&1：前端模式启动：

 直接运行bin/redis-server 将以前端模式启动，前端模式启动的缺点是启动完成后，不能再进行其他操作，如果要操作必须使用ctrl+c，同时redis-server程序结束

&2：后端模式启动

     修改redis.conf配置文件，daemonize yes 以后端模式启动

     Vim /software/redis/redis.conf

启动服务器：./redis-server redis.conf

启动客户端：./redis-cli

            ./redis-cli –h 192.168.113.129 –p 6379

Redis关闭服务

第一种：看进程：ps –ef | grep redis

         杀死进程：kill -9 4465

第二种：正确停止redis的方式是想redis发送shutdown命令：./redis-cli shutdown

 

1.3 redis 数据结构

redis是一种高级的key-value的存储系统，其中value支持五中数据类型

字符串（String） 哈希（hash）字符串列表（list）字符串集合（set）

有序字符串集合（sorted set）

Key的定义规则：

Key不要太长，最好不要操作1024个字节

Key不要太短，太短会降低key的可读性

Key有一个统一的命名规范

 

1.3.1 存储String

  字符串类型是redis中最为基础的数据存储类型，在redis是二进制安全的，意味着该类型存入和获取数据相同，在redis中字符串类型的value最多可以容纳的数据长度是512M.常用命令：

赋值：set key value :设定key持有指定的字符串value，如果该key存在则进行覆盖操作，总是返回ok

取值：get key :获取key的value，如果与该key关联的value不是String类型，redis将返回错误信息，因为get命令只能用于获取String value，如果该key不存在，返回（nil）

     getset key value :先获取该key的值，然后在设置该key的值

删除：del key: 删除指定key

数值增减：

      Incr key:将指定的key的value原子性的递增1，如果该key不存在，其初始值为0，在incr之后其值为1，如果value的值不能转成整形，如hello，则该操作将执行失败并返回相应的错误。

        decr key：将指定的key的value原子性的递减1，如果该key不存在，其初始值为0，在incr之后其值为-1，如果value的值不能转成整形，若hello，则该操作将执行失败并返回相应的错误。

1.3.2 存储hash

       Redis中的hash类型可以看成具有String key和String value的map容器，所以该类型非常适合于存储值对象的信息，如username,password,如果hash中包含很少的字段，那么该类型的数据也将占用很少的磁盘空间，每一个Hash可以存储4294967295个键值对。

常用命令：

       赋值：

              hset key field value:为指定的key设定field/value对（键值对）

      

             hset key field value[field2 value2…] :设置key中的多个field/value

取值：

hget key field :返回指定的key中的field的值

Hmget key fields:获取key中多个field的值

hgetall key:获取key中的所有filed-value

删除：

hdel key field[field…]:删除一个或多个字段，返回值是被删除的字段个数

del key:删除整个

 

其他命令：

hexists key field :判断指定的key中的field是否存在

hlen key:获取key所包含的field的数量

hkeys key:获取所有的key

hvals key :获取所有的value

1.3.3 存储list

       在redis中，list类型是按照插入顺序排序的字符串链表，和数据结构中的普通链表一样，可以在头部（left）和尾部（right）添加新的元素，在插入时，如果该键不存在，redis将为该键创建一个新的链表，与此相反，如果链表中的所有元素均被移除，那么该键也将会被从数据库中删除，List可以包含的最大元素数量是4294957295

       从元素插入和删除的效率视角来看，如果是在链表的两头插入或删除元素，这将会是非常高效的操作，及时链表中已经存储了百万条记录，该操作也可以在常量时间内完成，然而需要说明的是，如果元素插入或删除操作是作用于链表中间，那将会是非常低效的，相信对于有良好数据结构基础的开发者而言，这一点并不难理解。

       ArrayList使用数组方式存储数据，所以根据索引查询数据速度快，而新增或者删除元素是需要涉及到位移操作，所以比较慢

       LinkedList使用双向连接方式存储数据，每个元素都记录前后元素的指针，所以插入，删除数据时只是更改了前后元素的指针指向既可，速度非常快，然后通过下标查询元素时需要从头开始索引，所以比较慢。

       双向链表中添加数据：

双向链表中删除数据

常用命令：

两端添加：

lpush key values[value1,value2],在指定的key所关联的list的头部插入所有的value是，如果该key不存在，该命令在插入的之前创建一个与该key关联的空链表，之后再向该链表的头部插入数据，插入成功，返回元素的个数：

       rpush key values[value1,value2]:在该list的尾部添加元素

      

       lpushx key value:仅在参数中指定的key存在时（如果与key管理的list中没有值是，则该key是不存在的）在指定的key所关联的list的头部插入value。

       rpushx key value:在该list的尾部添加元素

      

       查看列表：

       lrange key start end :获取链表中从start到end的元素的值，start，end从0开始计数，也可为负数，若为-1，则表示链表尾部的元素，-2则表示倒数第二个，依次类推。。。

      

       两端弹出：

       lpop key:返回并弹出指定的key关联的链表中的第一个元素，即头部元素，如果该key不存在，返回nil,若key存在看，则返回链表的头部元素

       rpop key:从尾部弹出元素

• 

获取个数：

llen key :返回指定的key关联的链表中的元素的数量：

lset key index value:设置链表的index的脚标的元素值0代表链表的头元素，-1代表链表的尾元素

lrem key count value:删除count个值为value的元素，如果count大于0，从头向尾遍历并删除count个值为value的元素，如果count小于0，从尾到头遍历删除，如果count等于0，则删除链表中所有等于value的元素。

linsert key before|after pivot value:在pivot元素前或者后插入value元素

rpoplpush resource destination:将链表中的尾部元素弹出并添加到头部

 

1.3.4 存储set类型

       在redis中我们将set类型看做为没有排序的字符集合，和list类型一样，可以在该类型的数据值上执行添加，删除或判断某一元素是否存在等操作，需要说明的是，这些操作的间是常量时间，set可包含的最大元素是4294967295。

       和list类型不同的是，set集合中不允许出现重复的元素，和list类型相比，set类型在功能上还存在着一个非常重要的特性，即在服务器完成多个sets之间的聚合计算操作。如unions,intersections和differences. 这些操作均在服务端完成，因此效率极高。

       sadd key value1，value2…:向set中添加数据，如果该key的值已有则不会重复添加

       smembers key:获取set中所有的成员

       scard key :获取set中成员的数量

      

       sismember key member:判断参数中指定的成员是否在该set中，1表示存在，0表示不存在或者改key本身不存在

       srem key member1、member2…:删除set中指定的成员

      

       srandmember key：随机返回set中的一个成员

      

       sdiff key1 key2:返回key1与key2中相差的成员，而且与key的顺序有关返回差集

      

       sdiffstore destination key1 key2:将key1,key2相差的成员存储在destination上

      

       sinter key[key1,key2…]:返回交集

sinterstore destination key1 key2:将返回的交集存储在destination上

sunion key1,key2:返回并集

sunionstore destination key1 key2:将返回的并集存储在destination上

1.3.5 存储sortedset类型

       SortedSets 和set类型极为相似，他们都是字符串的集合，都不允许重复的成员出现在一个set中，他们的主要差别是sorted-sets中每一个成员都会有一个分数score与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序，然而需要额外指出的是，尽管sorted-set是中成员是惟一的，但是分数score却是可以重复的。

       在sorted-set中添加，删除或更新一个成员都是非常快速的操作，时间复杂度为集合中成员数量的对数，由于sorted-sets中的成员在集合中的位置是有序的，因此，即便是访问位于集合中部的成员也仍然是非常高效。

       添加元素

       zadd key score member score member2…:将将所有成员以及该成员的分数存放到sorted-set 中,如果该元素已经存在则会用到新的分数替换原来的分数，返回值是新加入到集合中的元素个数，不包含之前已经存在的元素

      

       获得元素

       zscore key member:返回指定成员的分数

      

       scard key：获取集合中的成员数量

      

       删除元素

       zrem key member[member…]:移除集合中指定的成员，可以指定多个成员

      

范围查询

zrange key start end[withscores]:获得集合中脚标为start-end 的成员，[withscores]参数表明返回的成员包括其分数

Zrevrange key start stop[withscores]:照元素分数从大到小的顺序返回索引从start到stop之间的所有元素

zremrangebyrank key start stop:按照排名范围删除元素

zremrangebyscore key min max :按照分数范围删除元素

1.4 keys通用操作

       keys pattern:获取所有与pattern匹配的key,返回所有与该key匹配的keys。*表示任意一个或多个字符，？表示任意一个字符

      

      

       del key1 key2…:删除指定的key

      

       exists key:判断该key是否存在，1代表存在，0代表不存在

      

       rename key newkey:为当前的key重命名：

      

       expire key:设置过期时间，单位：秒

      

       ttl key:获取该key所剩的超时时间，如果没有设置，返回-1，如果返回-2表示不存在

      

Persist key:清除过期时间

       type key:获取指定key的类型，该命令将以字符串的格式返回，返回的字符串为string，list,set,hash和zset,如果key不存在返回none。

      

1.5 常见问题

   1.Redis在使用命令行操作时，如果查看内容中包含中文，会显示16进制的字符串

  

     解决办法：

使用echo :

$ echo –e ‘redis-cli get username’

Redis-cli 后面加 -–raw

Redis-cli –raw

      

 

1.6 redis其他

一个redis示例可以包含多个数据库，客户端可以指定连接某个redis实例的那个数据库，就好比一个mysql中创建多个数据库，客户端连接时指定连接那个数据库。

一个redis实例最多可提供16个数据库，下标从0到15 ，客户端默认连接第一个，可以通过select 选择连接那个数据库：

 

       将 key 移到另一个库：

move newkey1 1:将当前库的key移到1号库中

       ping,测试是否连接成功

      

       echo,在命令行打印一些内容

      

       quit:退出连接

      

       dbsize,返回当前数据库中key的数目

      

       info,获取服务器的信息和统计

      

       flushdb,删除当前选择数据库中的所有key

      

       flushall,删除所有数据库中所有key

      

 

2 Redis 进阶

2.1 消息订阅与发布

       Redis 发布订阅（pub/sub）是一种消息通信模式，发送者（pub）发送消息，订阅者（sub）接收消息。

       Redis客户端可以订阅任意数量的频道

                                          Pub/Sub(发布/订阅)

subscribe channel:订阅频道，例：subscribe mychat，订阅mychat这个频道

psubscribe channel*:批量订阅频道，例：psubscribe s*:订阅多个s开头的频道

publish channel content:在指定的频道中发布消息，如publish mychat ‘hello world”

pubsub subcommand:查看订阅与系统发布：

pubsubscribe [pattern[pattern]]:退订所有给定模式的频道

unsubscribe channel:退订给定的频道

 

例：在一个窗口中，订阅mychat 频道，如果此时没有人发布消息，此窗口处于等待状态

       另一个窗口，发布消息

消息即时显示

 

2.2 Redis事务

2.3 Redis持久化

Redis的所有数据都是保存在内存中的

Rdb:快照形式，定期把内存中当前时刻的数据保存到磁盘，Redis默认支持的持久化方案

Aof形式中：append only file：把所有对redis数据库操作的命令，增删改操作的命令，保存到文件中，数据库恢复时把所有命令执行以便既可。

在redis.conf配置文件中配置

Aof的配置：

两种持久化方案同时开启使用aof文件来恢复数据库

3. Redis集群搭建

3.1 Redis-cluster架构图

 

Redis-cluster投票:容错

架构解释：

(1)所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽.

(2)节点的fail是通过集群中超过半数的节点检测失效时才生效.

(3)客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可

(4)redis-cluster把所有的物理节点映射到[0-16383]slot上,cluster 负责维护（均匀分配）node<->slot<->value

Redis 集群中内置了 16384 个哈希槽，当需要在 Redis 集群中放置一个 key-value 时，redis 先对 key 使用 crc16 算法算出一个结果，然后把结果对 16384 求余数，这样每个 key 都会对应一个编号在 0-16383 之间的哈希槽，redis 会根据节点数量大致均等的将哈希槽映射到不同的节点

3. 2 Redis集群搭建

Redis集群中至少应该有三个节点，保证集群高可用，需要每个节点设置一个备份机

Redis集群至少需要6台服务器

使用ruby脚本搭建集群，如要ruby的运行环境

安装ruby

yum install ruby

yum install rubygems

安装ruby脚本使用的包(自己上传)

gem install redis-3.0.0.gem

搭建伪分布式，使用一台虚拟机运行留个redis实例，需要修改redis的端口号7001-7006

修改redis.conf配置文件：

使用批处理将实例全部启动

授权：

复制redis-trib.rb文件到安装目录

使用ruby脚本搭建集群

./redis-trib.rb create --replicas 1 192.168.130.129:7001 192.168.130.129:7002 192.168.130.129:7003 192.168.130.129:7004 192.168.130.129:7005 192.168.130.129:7006

创建关闭集群的脚本

vi shutdown-all.sh

redis01/redis-cli -p 7001 shutdown redis02/redis-cli -p 7002 shutdown redis01/redis-cli -p 7003 shutdown redis01/redis-cli -p 7004 shutdown redis01/redis-cli -p 7005 shutdown redis01/redis-cli -p 7006 shutdown

集群使用：

Redis-cli连接集群

[root@localhost redis-cluster]# redis01/redis-cli -p 7002 -c

-c：代表连接的是redis集群

4. Jedis 使用

单机版使用：

1. jedis使用

 

1. 使用连接池

集群版使用：

常用的操作redis的方法提取出一个接口，分别对应单机版和集群版创建两个示例：

接口定义：

package cn.e3mall.common.jedis; import java.util.List; public interface JedisClient {     String set(String key, String value);     String get(String key);     Boolean exists(String key);     Long expire(String key, int seconds);     Long ttl(String key);     Long incr(String key);     Long hset(String key, String field, String value);     String hget(String key, String field);     Long hdel(String key, String... field);     Boolean hexists(String key, String field);     List<String> hvals(String key);     Long del(String key); }

单机版实现：

package cn.e3mall.common.jedis; import java.util.List; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; public class JedisClientPool implements JedisClient {      private JedisPool jedisPool;     public JedisPool getJedisPool() {         return jedisPool;     }     public void setJedisPool(JedisPool jedisPool) {         this.jedisPool = jedisPool;     }     @Override     public String set(String key, String value) {         Jedis jedis = jedisPool.getResource();         String result = jedis.set(key, value);         jedis.close();         return result;     }     @Override     public String get(String key) {         Jedis jedis = jedisPool.getResource();         String result = jedis.get(key);         jedis.close();         return result;     }     @Override     public Boolean exists(String key) {         Jedis jedis = jedisPool.getResource();         Boolean result = jedis.exists(key);         jedis.close();         return result;     }     @Override     public Long expire(String key, int seconds) {         Jedis jedis = jedisPool.getResource();         Long result = jedis.expire(key, seconds);         jedis.close();         return result;     }     @Override     public Long ttl(String key) {         Jedis jedis = jedisPool.getResource();         Long result = jedis.ttl(key);         jedis.close();         return result;     }     @Override     public Long incr(String key) {         Jedis jedis = jedisPool.getResource();         Long result = jedis.incr(key);         jedis.close();         return result;     }     @Override     public Long hset(String key, String field, String value) {         Jedis jedis = jedisPool.getResource();         Long result = jedis.hset(key, field, value);         jedis.close();         return result;     }     @Override     public String hget(String key, String field) {         Jedis jedis = jedisPool.getResource();         String result = jedis.hget(key, field);         jedis.close();         return result;     }     @Override     public Long hdel(String key, String... field) {         Jedis jedis = jedisPool.getResource();         Long result = jedis.hdel(key, field);         jedis.close();         return result;     }     @Override     public Boolean hexists(String key, String field) {         Jedis jedis = jedisPool.getResource();         Boolean result = jedis.hexists(key, field);         jedis.close();         return result;     }     @Override     public List<String> hvals(String key) {         Jedis jedis = jedisPool.getResource();         List<String> result = jedis.hvals(key);         jedis.close();         return result;     }     @Override     public Long del(String key) {         Jedis jedis = jedisPool.getResource();         Long result = jedis.del(key);         jedis.close();         return result;     } }

集群版实现：

package cn.e3mall.common.jedis; import java.util.List; import redis.clients.jedis.JedisCluster; public class JedisClientCluster implements JedisClient {       private JedisCluster jedisCluster;     public JedisCluster getJedisCluster() {         return jedisCluster;     }     public void setJedisCluster(JedisCluster jedisCluster) {         this.jedisCluster = jedisCluster;     }     @Override     public String set(String key, String value) {         return jedisCluster.set(key, value);     }     @Override     public String get(String key) {         return jedisCluster.get(key);     }     @Override     public Boolean exists(String key) {         return jedisCluster.exists(key);     }     @Override     public Long expire(String key, int seconds) {         return jedisCluster.expire(key, seconds);     }     @Override     public Long ttl(String key) {         return jedisCluster.ttl(key);     }     @Override     public Long incr(String key) {         return jedisCluster.incr(key);     }     @Override     public Long hset(String key, String field, String value) {         return jedisCluster.hset(key, field, value);     }     @Override     public String hget(String key, String field) {         return jedisCluster.hget(key, field);     }     @Override     public Long hdel(String key, String... field) {         return jedisCluster.hdel(key, field);     }     @Override     public Boolean hexists(String key, String field) {         return jedisCluster.hexists(key, field);     }     @Override     public List<String> hvals(String key) {         return jedisCluster.hvals(key);     }     @Override     public Long del(String key) {         return jedisCluster.del(key);     } }

单机版applicationContext-redis.xml

<bean id="jedisClientPool" class="cn.e3mall.common.jedis.JedisClientPool">        <property name="jedisPool" ref="jedisPool">property>     bean>     <bean id="jedisPool" class="redis.clients.jedis.JedisPool">        <constructor-arg name="host" value="192.168.113.131"/>        <constructor-arg name="port" value="6379"/>     bean>

集群版applicationContext-redis.xml

<bean id="jedisClientCluster" class="cn.e3mall.common.jedis.JedisClientCluster">     <property name="jedisCluster" ref="jedisCluster"/> bean> <bean id="jedisCluster" class="redis.clients.jedis.JedisCluster">     <constructor-arg name="nodes">         <set>             <bean class="redis.clients.jedis.HostAndPort">                  <constructor-arg name="host" value="192.168.25.162"> constructor-arg>                  <constructor-arg name="port" value="7001">constructor-arg>             bean>             <bean class="redis.clients.jedis.HostAndPort">                 <constructor-arg name="host" value="192.168.25.162"> constructor-arg>                 <constructor-arg name="port" value="7002">constructor-arg>             bean>             <bean class="redis.clients.jedis.HostAndPort">                 <constructor-arg name="host" value="192.168.25.162"> constructor-arg>                 <constructor-arg name="port" value="7003">constructor-arg>             bean>             <bean class="redis.clients.jedis.HostAndPort">                 <constructor-arg name="host" value="192.168.25.162"> constructor-arg>                 <constructor-arg name="port" value="7004">constructor-arg>             bean>             <bean class="redis.clients.jedis.HostAndPort">                 <constructor-arg name="host" value="192.168.25.162"> constructor-arg>                 <constructor-arg name="port" value="7005">constructor-arg>             bean>             <bean class="redis.clients.jedis.HostAndPort">                 <constructor-arg name="host" value="192.168.25.162"> constructor-arg>                 <constructor-arg name="port" value="7006">constructor-arg>             bean>         set>     constructor-arg> bean>

 

5.Redis缓存实例

程序中使用缓存

/** * 根据内容分类Id查询内容列表 */ @Override public List<TbContent> getContentListByCid(long cid) {     //查询 缓存     try {         String json=jedisClient.hget(CONTENT_LIST, cid+"");         if(StringUtils.isNotBlank(json)) {//判断json是否为空             List<TbContent> list = JsonUtils.jsonToList(json, TbContent.class);             return list;         }     }catch (Exception e) {             e.printStackTrace();     }     //如果缓存中有直接相应结果     //没有查询数据库     TbContentExample example=new TbContentExample();     Criteria criteria=example.createCriteria();     //设置查询条件     criteria.andCategoryIdEqualTo(cid);     List<TbContent> list = contentMapper.selectByExampleWithBLOBs(example);     //把结果添加到缓存     try {        jedisClient.hset(CONTENT_LIST, cid + "", JsonUtils.objectToJson(list));     }catch (Exception e) {         e.printStackTrace();     }     return list;     }

注：对数据库进行操作时，要同时对缓存进行同歩