redis 安装和简单使用

时间 2019-11-06

标签 redis 安装简单使用栏目 Redis 繁體版

原文原文链接

1、redis 安装 java

一、首先安装c的编译环境

yum -y install cppnode

yum -y install binutilsredis

yum -y install glibc数据库

yum -y install glibc-kernheadersapache

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);

   }

}