Redis安装

• 官方下载地址：https://redis.io/
• 下载获得redis-6.0.7.tar.gz，将其放到/opt目录下
• 解压redis压缩包
• 进入解压后的redis目录
• 在redis目录下执行make指令，出现错误：这是因为环境中缺少gcc编译器
• 安装gcc：yum install gcc-c++
• 重新执行make指令，再次出现错误：
• 执行make distclean指令清除残存的文件
• 再次执行make指令，仍然出现错误：这是因为从redis6.0.0开始，编译redis需要支持C11特性，前面下载的gcc编译器版本是4.8.5，而C11特性从4.9版本才开始引入，所以需要升级一下gcc的版本。
• 安装 Developer Toolset 7：yum install centos-release-scl devtoolset-7，yum install devtoolset-7
• 切换至devtoolset-7环境：scl enable devtoolset-7 bash，此时即可使用gcc 7进行编译
• 现在可以执行make指令完成安装了
• 修改redis目录下的redis.conf文件：设置daemonize值为yes
• 来到/usr/local/bin目录下，执行redis-server /opt/redis-6.0.7/myredis/redis.conf指令启动redis服务，然后执行redis-cli -p 6379启动redis，之后就可以使用了：

五大数据结构

redis中有五大数据类型：

0. String：字符串
1. Hash：哈希
2. List：列表
3. Set：集合
4. Zset：有序集合

Key关键字

先来看看关于Key的相关语法：

• keys *：查找所有的 key
• exists key：判断某个key是否存在
• move key db：将某个key剪切至指定的库，如：move k1 2，表示将k1剪切到了2号库
• select db：切换至某个库 ——redis默认有16个库，序号为0~15
• ttl key：查看某个key还有多久过期，-1表示永不过期，-2表示已过期
• expire key 秒数：为某个key设置过期时间，当某个key过期后，会被自动删除
• type key：查看某个key的类型
• del key：删除某个key

String

• strlen key：查看某个key 的长度
• Incr key：递增某个key的值
• incrby key value：按给定的value值递增某个key的值，比如：incrby k 5，表示以5为区间递增k的值
• decr：递减某个key 的值
• decrby key value：按给定的value值递减某个key的值上述四个指令都要求key的值必须为数字，否则会报错
• getrange：获取指定区间范围内的值，比如：getrange k 0 5，表示获取k值从0到5位置的字符
• setrange：设置指定区间范围内的值，比如：setrange k 0 abc，表示从0位置开始设置k的字符为abc，注意该操作会覆盖原有的字符，若k的值为helloworld，则执行此操作后，k的值变为abcloworld
• setex k 秒数 value：设置某个k的过期时间，当该k已存在时，会用value值覆盖原来的key值
• setnx key value：设置某个key的值，与set key value不同，setnx会先去判断当前key是否已经存在，若存在则会报错，不存在才能设置成功，避免了key值的覆盖
• mset：批量设置key值，比如：mset k1 aaa k2 bbb k3 ccc
• mget：批量获取key值，比如：mget k1 k2 k3
• msetnx：批量设置key值，用法与mset相同，但不同的是，当msetnx设置的key中有某个key已经存在，则当前设置的所有key值都将失败

List

• lpush key：设置key的值为一个list，比如：lpush list01 1 2 3 4 5
• rpush key：设置key的值为一个list，它与lpush的区别在于，lpush是从左往右设置值，rpush是从右往左设置值
• lrange key 0 -1：获取值为list的key值
• lpop key：从左边出栈一个值
• rpop key：从右边出栈一个值
• lindex 索引值：按照索引下标获取元素
• llen key：获取list的长度
• lrem key：删除多个值，比如：lrem list01 2 3，表示删除list01中的两个元素3
• ltrim key：截取指定范围的值后重新赋值给key，比如ltrim list01 0 4，若list01原来的值为lpush list01 1 2 3 4 5 6 7 8 9，则执行此操作后，list01的值变为9 8 7 6 5
• rpoplpush key1 key2：将key1底部的元素弹出再压入key2顶部，比如：rpoplpush list01 list02，若list01的值为9 8 7 6 5，list02的值为4 3 2 1，则执行此操作后，list01的值变为9 8 7 6，list02的值变为5 4 3 2 1
• lset key index value：设置某个key的指定下标位置为value值
• linsert key before value1 value2：在值value1的前面插入值value2
• linsert key after value1 value2：在值value1的后面插入值value2

Set

• sadd key：设置key的值为一个set，比如：sadd set01 1 1 2 2 3 3，它会去除重复元素，所以set01的值为1 2 3
• smembers key：获取值为set的key值
• sismember key value：判断set中是否有指定的value值
• scard key：获取set中的元素个数
• srem key value：删除set中的value元素
• srandmember key count：随机获取set中的若干个值，比如：srandmember set01 5，表示随机获取set01中的五个元素
• spop key：随机出栈一个set中的元素
• smove key1 key2 value：将key1集合中的指定值剪切到key2，比如：smove set01 set02 5，表示将set01集合中的元素5剪切到set02中
• sdiff key1 key2：(差集)——获取在第一个set中而不在后面任何一个set中的元素值
• sinter key1 key2：(交集)——获取两个set中都具有的元素
• sunion key1 key2：(并集)——将两个set进行合并

Hash

• hset key：设置key 的值为一个hash，比如：hset user id 01，表示user的值为一个键值对
• hget key field：获取hash中的某个key值，比如：hget user id
• hmset key：批量设置，比如：hmset user id 01 name zs
• hmget ket：批量获取，比如：hmget user id name
• hgetall key：获取hash中的所有键值对
• hdel key：删除hash中的某个键值对，比如：hdel user id
• hlen key：获取hash的键值对数
• hexists key：判断hash中是否存在某个key值，比如：hexists user name
• hkeys key：获取hash中的所有键
• hvals key：获取hash中的所有值
• hincrby key field count：递增某个key值，比如：hincrby user age 2
• hincrbyfloat key field count：递增某个key值(可以用小数)，比如：hincrby user age 0.5
• hsetnx key：设置key的值为一个hash，与hset key的区别是hsetnx不允许当前设置的key存在

ZSet

zset与set的区别在于，zset会在set的基础上加上一个score值，比如之前的set是这样的：set01 a b c；

那么zset的值为：zset01 score01 a score02 b score03 c。

• zadd key：设置key的值为一个zset，比如：zadd zset01 60 a 70 b 80 c 90 d 100 e
• zrange key 0 -1 withscores：获取值为zset的key值，若使用withscores，则获取的是带score的值
• zrangebyscore key score1 score2：获取score比score1大比score2小的值(：该符号表示不包含，比如 zrangebyscore zset01 60 (90，表示获取score在60到90之间但不包含90的值limit：返回限制，比如：zrangebyscore zset01 60 90 limit 2 2，表示获取score在60到90之间，并从下标2开始截取两个元素值
• zrem key：删除zset中的某个值，比如：zrem zset01 a
• zcard key：获取zset的元素个数
• zcount key score区间：获取在socre区间内的元素个数，比如：zcount zset01 60 80
• zrank key value：获取某个值在zset中的下标
• zscore key value：获取某个值在zset中对应的score
• zrevrank key value：获取某个值在zset中的逆序下标
• zrevrange key 0 -1：获取zset逆序后的值
• zrevrangebyscore key score1 score2：获取score比score2大比score1小的值，与zrangebyscore正好相反

配置文件

参数说明 redis.conf 配置项说明如下：

0. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程 daemonize no
1. 当Redis以守护进程方式运行时，Redis默认会把pid写入/var/run/redis.pid文件，可以通过pidfile指定 pidfile /var/run/redis.pid
2. 指定Redis监听端口，默认端口为6379，作者在自己的一篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字 port 6379
3. 绑定的主机地址 bind 127.0.0.1
4. 当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能 timeout 300
5. 指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为verbose loglevel verbose
6. 日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null logfile stdout
7. 设置数据库的数量，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id databases 16
8. 指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合 save <seconds> <changes> Redis默认配置文件中提供了三个条件： save 900 1 save 300 10 save 60 10000 分别表示900秒（15分钟）内有1个更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改。
9. 指定存储至本地数据库时是否压缩数据，默认为yes，Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大 rdbcompression yes
10. 指定本地数据库文件名，默认值为dump.rdb dbfilename dump.rdb
11. 指定本地数据库存放目录 dir ./
12. 设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步 slaveof <masterip> <masterport>
13. 当master服务设置了密码保护时，slav服务连接master的密码 masterauth <master-password>
14. 设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH <password>命令提供密码，默认关闭 requirepass foobare
15. 设置同一时间最大客户端连接数，默认无限制，Redis可以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置 maxclients 0，表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息 maxclients 128
16. 指定Redis最大内存限制，Redis在启动时会把数据加载到内存中，达到最大内存后，Redis会先尝试清除已到期或即将到期的Key，当此方法处理 后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区 maxmemory <bytes>
17. 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为 redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no appendonly no
18. 指定更新日志文件名，默认为appendonly.aof appendfilename appendonly.aof
19. 指定更新日志条件，共有3个可选值： no：表示等操作系统进行数据缓存同步到磁盘（快） always：表示每次更新操作后手动调用fsync()将数据写到磁盘（慢，安全） everysec：表示每秒同步一次（折衷，默认值） appendfsync everysec
20. 指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中（在后面的文章我会仔细分析Redis的VM机制） vm-enabled no
21. 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享 vm-swap-file /tmp/redis.swap
22. 将所有大于vm-max-memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据 就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0 vm-max-memory 0
23. Redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page上不能被多个对象共享，vm-page-size是要根据存储的 数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes；如果存储很大大对象，则可以使用更大的page，如果不 确定，就使用默认值 vm-page-size 32
24. 设置swap文件中的page数量，由于页表（一种表示页面空闲或使用的bitmap）是在放在内存中的，，在磁盘上每8个pages将消耗1byte的内存。 vm-pages 134217728
25. 设置访问swap文件的线程数,最好不要超过机器的核数,如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4 vm-max-threads 4
26. 设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启 glueoutputbuf yes
27. 指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法 hash-max-zipmap-entries 64 hash-max-zipmap-value 512
28. 指定是否激活重置哈希，默认为开启（后面在介绍Redis的哈希算法时具体介绍） activerehashing yes
29. 指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一份配置文件，而同时各个实例又拥有自己的特定配置文件 include /path/to/local.conf

jedis

这里采用的是centos7操作系统，jedis版本为2.9.0

遇到的问题是：redis.clients.jedis.exceptions.JedisConnectionException: java.net.SocketTimeoutException

如何解决？

首先开放redis的6379端口，然后修改redis的配置文件：

将bind注释掉，就可以让任意ip访问redis，并关闭redis的保护机制，将protected-mode属性改为no。

最后连接成功：

常用API

public static void main(String[] args) {
    Jedis jedis = new Jedis("192.168.190.134",6379);
    jedis.set("k1","v1");
    jedis.set("k2","v2");
    jedis.set("k3","v3");

}

执行这段代码，查询redis：

127.0.0.1:6379> FLUSHALL
OK
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> keys *
1) "k3"
2) "k1"
3) "k2"

jedis中的API和redis指令没有区别：

public static void main(String[] args) {
    Jedis jedis = new Jedis("127.0.0.1",6379);
    //key
    Set<String> keys = jedis.keys("*");
    for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
        String key = (String) iterator.next();
        System.out.println(key);
    }
    System.out.println("jedis.exists====>"+jedis.exists("k2"));
    System.out.println(jedis.ttl("k1"));
    //String
    //jedis.append("k1","myreids");
    System.out.println(jedis.get("k1"));
    jedis.set("k4","k4_redis");
    System.out.println("----------------------------------------");
    jedis.mset("str1","v1","str2","v2","str3","v3");
    System.out.println(jedis.mget("str1","str2","str3"));
    //list
    System.out.println("----------------------------------------");
    //jedis.lpush("mylist","v1","v2","v3","v4","v5");
    List<String> list = jedis.lrange("mylist",0,-1);
    for (String element : list) {
        System.out.println(element);
    }
    //set
    jedis.sadd("orders","jd001");
    jedis.sadd("orders","jd002");
    jedis.sadd("orders","jd003");
    Set<String> set1 = jedis.smembers("orders");
    for (Iterator iterator = set1.iterator(); iterator.hasNext();) {
        String string = (String) iterator.next();
        System.out.println(string);
    }
    jedis.srem("orders","jd002");
    System.out.println(jedis.smembers("orders").size());
    //hash
    jedis.hset("hash1","userName","lisi");
    System.out.println(jedis.hget("hash1","userName"));
    Map<String,String> map = new HashMap<String,String>();
    map.put("telphone","13811814763");
    map.put("address","atguigu");
    map.put("email","abc@163.com");
    jedis.hmset("hash2",map);
    List<String> result = jedis.hmget("hash2", "telphone","email");
    for (String element : result) {
        System.out.println(element);
    }
    //zset
    jedis.zadd("zset01",60d,"v1");
    jedis.zadd("zset01",70d,"v2");
    jedis.zadd("zset01",80d,"v3");
    jedis.zadd("zset01",90d,"v4");
?
    Set<String> s1 = jedis.zrange("zset01",0,-1);
    for (Iterator iterator = s1.iterator(); iterator.hasNext();) {
        String string = (String) iterator.next();
        System.out.println(string);
    }
}

事务提交

public static void main(String[] args) {
    Jedis jedis = new Jedis("127.0.0.1",6379);
?
    //监控key，如果该动了事务就被放弃
    /*3
     jedis.watch("serialNum");
     jedis.set("serialNum","s#####################");
     jedis.unwatch();*/
?
    Transaction transaction = jedis.multi();//被当作一个命令进行执行
    Response<String> response = transaction.get("serialNum");
    transaction.set("serialNum","s002");
    response = transaction.get("serialNum");
    transaction.lpush("list3","a");
    transaction.lpush("list3","b");
    transaction.lpush("list3","c");
?
    transaction.exec();
    //2 transaction.discard();
    System.out.println("serialNum***********"+response.get());
}

加锁：

public class TestTransaction {
  public boolean transMethod() {
     Jedis jedis = new Jedis("127.0.0.1", 6379);
     int balance;// 可用余额
     int debt;// 欠额
     int amtToSubtract = 10;// 实刷额度
?
     jedis.watch("balance");
     //jedis.set("balance","5");//此句不该出现，讲课方便。模拟其他程序已经修改了该条目
     balance = Integer.parseInt(jedis.get("balance"));
     if (balance < amtToSubtract) {
       jedis.unwatch();
       System.out.println("modify");
       return false;
     } else {
       System.out.println("***********transaction");
       Transaction transaction = jedis.multi();
       transaction.decrBy("balance", amtToSubtract);
       transaction.incrBy("debt", amtToSubtract);
       transaction.exec();
       balance = Integer.parseInt(jedis.get("balance"));
       debt = Integer.parseInt(jedis.get("debt"));
?
?
       System.out.println("*******" + balance);
       System.out.println("*******" + debt);
       return true;
     }
  }
?
  /**
   * 通俗点讲，watch命令就是标记一个键，如果标记了一个键， 在提交事务前如果该键被别人修改过，那事务就会失败，这种情况通常可以在程序中
   * 重新再尝试一次。
   * 首先标记了键balance，然后检查余额是否足够，不足就取消标记，并不做扣减； 足够的话，就启动事务进行更新操作，
   * 如果在此期间键balance被其它人修改， 那在提交事务（执行exec）时就会报错， 程序中通常可以捕获这类错误再重新执行一次，直到成功。
   */
  public static void main(String[] args) {
     TestTransaction test = new TestTransaction();
     boolean retValue = test.transMethod();
     System.out.println("main retValue-------: " + retValue);
  }
}

JedisPool

public class JedisPoolUtil {
?
    private static volatile JedisPool jedisPool = null;//被volatile修饰的变量不会被本地线程缓存，对该变量的读写都是直接操作共享内存。
?
    private JedisPoolUtil() {}
?
    public static JedisPool getJedisPoolInstance(){
        if(null == jedisPool){
            synchronized (JedisPoolUtil.class){
                if(null == jedisPool){
                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    poolConfig.setMaxActive(1000);
                    poolConfig.setMaxIdle(32);
                    poolConfig.setMaxWait(100*1000);
                    poolConfig.setTestOnBorrow(true);
?
                    jedisPool = new JedisPool(poolConfig,"127.0.0.1");
                }
            }
        }
        return jedisPool;
    }
?
    public static void release(JedisPool jedisPool,Jedis jedis){
        if(null != jedis){
            jedisPool.returnResourceObject(jedis);
        }
    }
}

配置总结：

JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。
?
maxActive：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。
maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；
whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。
 WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException；
 WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException；
 WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用；
maxWait：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛JedisConnectionException；
testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的；
?
?
testOnReturn：return 一个jedis实例给pool时，是否检查连接可用性（ping()）；
?
?
testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；
?
?
timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数；
?
?
numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；
?
?
minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；
?
?
softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义；
?
?
lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；
?
?
==================================================================================================================
其中JedisPoolConfig对一些参数的默认设置如下：
testWhileIdle=true
minEvictableIdleTimeMills=60000
timeBetweenEvictionRunsMillis=30000
numTestsPerEvictionRun=-1