一、概念：redis是一款高性能的NoSQL系列的非关系型数据库

1.1什么是NoSQL

1.1.什么是NoSQL
	NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。
	随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

1.1.1.	NoSQL和关系型数据库比较
	优点：
		1）成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。
		2）查询速度：nosql数据库将数据存储于缓存之中，关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。
		3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。
		4）扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。

	缺点：
		1）维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库十几年的技术同日而语。
		2）不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。
		3）不提供关系型数据库对事务的处理。

1.1.2.	非关系型数据库的优势：
	1）性能NoSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。
	2）可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。

1.1.3.	关系型数据库的优势：
	1）复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。
	2）事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。

1.1.4.	总结
	关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库，
	让NoSQL数据库对关系型数据库的不足进行弥补。
	一般会将数据存储在关系型数据库中，在Nosql数据库中备份存储关系型数据库的数据

1.2主流的NoSQL产品

1.2.主流的NOSQL产品
•	键值(Key-Value)存储数据库
    相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
    典型应用： 内容缓存，主要用于处理大量数据的高访问负载。 
    数据模型： 一系列键值对
    优势： 快速查询
    劣势： 存储的数据缺少结构化
•	列存储数据库
    相关产品：Cassandra, HBase, Riak
    典型应用：分布式的文件系统
    数据模型：以列簇式存储，将同一列数据存在一起
    优势：查找速度快，可扩展性强，更容易进行分布式扩展
    劣势：功能相对局限
•	文档型数据库
    相关产品：CouchDB、MongoDB
    典型应用：Web应用（与Key-Value类似，Value是结构化的）
    数据模型： 一系列键值对
    优势：数据结构要求不严格
    劣势： 查询性能不高，而且缺乏统一的查询语法
•	图形(Graph)数据库
    相关数据库：Neo4J、InfoGrid、Infinite Graph
    典型应用：社交网络
    数据模型：图结构
    优势：利用图结构相关算法。
    劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

1.3什么是Redis

1.3 什么是Redis
    Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：
    1) 字符串类型 string
    2) 哈希类型 hash
    3) 列表类型 list
    4) 集合类型 set
    5) 有序集合类型 sortedset
1.3.1 redis的应用场景
    •	缓存（数据查询、短连接、新闻内容、商品内容等等）
    •	聊天室的在线好友列表
    •	任务队列。（秒杀、抢购、12306等等）
    •	应用排行榜
    •	网站访问统计
    •	数据过期处理（可以精确到毫秒）
    •	分布式集群架构中的session分离

二、关于Redis中的一些操作

2.1下载安装

1. 官网：https://redis.io
2. 中文网：http://www.redis.net.cn/
3. 解压直接可以使用：
    * redis.windows.conf：配置文件
    * redis-cli.exe：redis的客户端
    * redis-server.exe：redis服务器端

2.2命令操作

1. redis的数据结构：
	* redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构
    * value的数据结构：
        1) 字符串类型 string
        2) 哈希类型 hash ： map格式  
        3) 列表类型 list ： linkedlist格式。支持重复元素
        4) 集合类型 set  ： 不允许重复元素
        5) 有序集合类型 sortedset：不允许重复元素，且元素有顺序
	
2. 字符串类型 string
    1. 存储： set key value
    2. 获取： get key
    3. 删除： del key
3. 哈希类型 hash
    1. 存储： hset key field value
        127.0.0.1:6379> hset myhash username lisi
        (integer) 1
        127.0.0.1:6379> hset myhash password 123
        (integer) 1
    2. 获取： 
        * hget key field: 获取指定的field对应的值
        127.0.0.1:6379> hget myhash username
        "lisi"
        * hgetall key：获取所有的field和value
        127.0.0.1:6379> hgetall myhash
        1) "username"
        2) "lisi"
        3) "password"
        4) "123"

    3. 删除： hdel key field
        127.0.0.1:6379> hdel myhash username
        (integer) 1
	
4. 列表类型 list:可以添加一个元素到列表的头部（左边）或者尾部（右边）
    1. 添加：
        1. lpush key value: 将元素加入列表左表

        2. rpush key value：将元素加入列表右边

        127.0.0.1:6379> lpush myList a
        (integer) 1
        127.0.0.1:6379> lpush myList b
        (integer) 2
        127.0.0.1:6379> rpush myList c
        (integer) 3
    2. 获取：
        * lrange key start end ：范围获取
        127.0.0.1:6379> lrange myList 0 -1
        1) "b"
        2) "a"
        3) "c"
    3. 删除：
        * lpop key： 删除列表最左边的元素，并将元素返回
        * rpop key： 删除列表最右边的元素，并将元素返回
5. 集合类型 set ： 不允许重复元素
    1. 存储：sadd key value
        127.0.0.1:6379> sadd myset a
        (integer) 1
        127.0.0.1:6379> sadd myset a
        (integer) 0
    2. 获取：smembers key:获取set集合中所有元素
        127.0.0.1:6379> smembers myset
        1) "a"
	3. 删除：srem key value:删除set集合中的某个元素	
        127.0.0.1:6379> srem myset a
        (integer) 1
6. 有序集合类型 sortedset：不允许重复元素，且元素有顺序.每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

	1. 存储：zadd key score value
        127.0.0.1:6379> zadd mysort 60 zhangsan
        (integer) 1
        127.0.0.1:6379> zadd mysort 50 lisi
        (integer) 1
        127.0.0.1:6379> zadd mysort 80 wangwu
        (integer) 1
	2. 获取：zrange key start end [withscores]
        127.0.0.1:6379> zrange mysort 0 -1
        1) "lisi"
        2) "zhangsan"
        3) "wangwu"

    	127.0.0.1:6379> zrange mysort 0 -1 withscores
        1) "zhangsan"
        2) "60"
        3) "wangwu"
        4) "80"
        5) "lisi"
        6) "500"
    3. 删除：zrem key value
        127.0.0.1:6379> zrem mysort lisi
        (integer) 1

7. 通用命令
    1. keys * : 查询所有的键
    2. type key ： 获取键对应的value的类型
    3. del key：删除指定的key value

三、Redis的持久化

1. redis是一个内存数据库，当redis服务器重启，获取电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。
2. redis持久化机制：
	1. RDB：默认方式，不需要进行配置，默认就使用这种机制
    	* 在一定的间隔时间中，检测key的变化情况，然后持久化数据
        1. 编辑redis.windwos.conf文件
        #   after 900 sec (15 min) if at least 1 key changed
        save 900 1
        #   after 300 sec (5 min) if at least 10 keys changed
        save 300 10
        #   after 60 sec if at least 10000 keys changed
        save 60 10000
				
    	2. 重新启动redis服务器，并指定配置文件名称
       	 	redis-2.8.9>redis-server.exe redis.windows.conf		
	
	2. AOF：日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据
         1. 编辑redis.windwos.conf文件
            appendonly no（关闭aof） --> appendonly yes （开启aof）

            appendfsync always ：    每一次操作都进行持久化
            appendfsync everysec ：  每隔一秒进行一次持久化
            appendfsync no ： 		不进行持久化

四、jedis中连接池：jedisPool的使用

1. Java客户端 Jedis
	* Jedis: 一款java操作redis数据库的工具.
	* 使用步骤：
		1. 下载jedis的jar包，并导入工程中
		2. 使用
			//1. 获取连接
    		Jedis jedis = new Jedis("localhost",6379);
   			//2. 操作
   			jedis.set("username","zhangsan");
    		//3. 关闭连接
    		jedis.close();
2. 创建JedisPool连接池对象
    2. 调用方法 getResource()方法获取Jedis连接
    //0.创建一个配置对象
    JedisPoolConfig config = new JedisPoolConfig();
    config.setMaxTotal(50);
    config.setMaxIdle(10);

    //1.创建Jedis连接池对象
    JedisPool jedisPool = new JedisPool(config,"localhost",6379);

    //2.获取连接
    Jedis jedis = jedisPool.getResource();
    //3. 使用
    jedis.set("hehe","heihei");
    //4. 关闭 归还到连接池中
    jedis.close();

五、注意

* 注意：使用redis，缓存一些不经常发生变化的数据。
	* 数据库的数据一旦发生改变，则需要更新缓存。
		* 数据库的表执行 增删改的相关操作，需要将redis缓存数据情况，再次存入
		* 在service对应的增删改方法中，将redis数据删除。

六、面试中的Redis相关知识

6.1 redis 和 memcached 的区别

redis支持更丰富的数据类型（支持更复杂的应用场景）：Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。memcache支持简单的数据类型，String。
Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用,而
Memecache把数据全部存在内存之中。
集群模式：memcached没有原生的集群模式，需要依靠客户端来实现往集群中分片写入数据；但是 redis 目前是原生支持 cluster 模式的.
Memcached是多线程，非阻塞IO复用的网络模型；Redis使用单线程的多路 IO 复用模型。

6.2 redis 设置过期时间

定期删除：redis默认是每隔 100ms 就随机抽取一些设置了过期时间的key，检查其是否过期，如果过期就删
除。注意这里是随机抽取的。为什么要随机呢？你想一想假如 redis 存了几十万个 key ，每隔100ms就遍历所
有的设置过期时间的 key 的话，就会给 CPU 带来很大的负载！

惰性删除 ：定期删除可能会导致很多过期 key 到了时间并没有被删除掉。所以就有了惰性删除。假如你的过期
key，靠定期删除没有被删除掉，还停留在内存里，除非你的系统去查一下那个 key，才会被redis给删除掉。这
就是所谓的惰性删除，也是够懒的哈！

但是仅仅通过设置过期时间还是有问题的。我们想一下：如果定期删除漏掉了很多过期 key，然后你也没及时去查，也就没走惰性删除，此时会怎么样？如果大量过期key堆积在内存里，导致redis内存块耗尽了。怎么解决这个问题呢？
redis 内存淘汰机制。

6.3 redis 内存淘汰机制（MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据？）

redis 提供 6种数据淘汰策略：

volatile-lru：从已设置过期时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰
volatile-ttl：从已设置过期时间的数据集（server.db[i].expires）中挑选将要过期的数据淘汰
volatile-random：从已设置过期时间的数据集（server.db[i].expires）中任意选择数据淘汰
allkeys-lru：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key（这个是最常用的）.
allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰
no-eviction：禁止驱逐数据，也就是说当内存不足以容纳新写入数据时，新写入操作会报错。这个应该没人使用吧！

6.4 redis 持久化机制（怎么保证 redis 挂掉之后再重启数据可以进行恢复？）

Redis的一种持久化方式叫快照（snapshotting，RDB）,另一种方式是只追加文件（append-only file,AOF）

① 快照（snapshotting）持久化（RDB）：

Redis可以通过创建快照来获得存储在内存里面的数据在某个时间点上的副本。Redis创建快照之后，可以对快照进行备份，可以将快照复制到其他服务器从而创建具有相同数据的服务器副本（Redis主从结构，主要用来提高Redis性能），还可以将快照留在原地以便重启服务器的时候使用。
快照持久化是Redis默认采用的持久化方式

② AOF（append-only file）持久化：
与快照持久化相比，AOF持久化的实时性更好，因此已成为主流的持久化方案。默认情况下Redis没有开启
AOF（append only file）方式的持久化，可以通过appendonly参数开启：

appendonly yes

开启AOF持久化后每执行一条会更改Redis中的数据的命令，Redis就会将该命令写入硬盘中的AOF文件。AOF文件的保存位置和RDB文件的位置相同，都是通过dir参数设置的，默认的文件名是appendonly.aof。
在Redis的配置文件中存在三种不同的 AOF 持久化方式，它们分别是：

appendfsync always #每次有数据修改发生时都会写入AOF文件,这样会严重降低Redis的速度
appendfsync everysec #每秒钟同步一次，显示地将多个写命令同步到硬盘
appendfsync no #让操作系统决定何时进行同步

为了兼顾数据和写入性能，用户可以考虑 appendfsync everysec选项，让Redis每秒同步一次AOF文件，Redis性能几乎没受到任何影响。而且这样即使出现系统崩溃，用户最多只会丢失一秒之内产生的数据。当硬盘忙于执行写入操作的时候，Redis还会优雅的放慢自己的速度以便适应硬盘的最大写入速度。

Redis 4.0 对于持久化机制的优化
Redis 4.0 开始支持 RDB 和 AOF 的混合持久化（默认关闭，可以通过配置项 aof-use-rdb-preamble 开启）。
如果把混合持久化打开，AOF 重写的时候就直接把 RDB 的内容写到 AOF 文件开头。这样做的好处是可以结合 RDB和 AOF 的优点, 快速加载同时避免丢失过多的数据。当然缺点也是有的， AOF 里面的 RDB 部分是压缩格式不再是AOF 格式，可读性较差。

6.5 缓存雪崩和缓存穿透问题解决方案

缓存雪崩
简介：缓存同一时间大面积的失效，所以，后面的请求都会落到数据库上，造成数据库短时间内承受大量请求而崩
掉。
解决办法：
事前：尽量保证整个 redis 集群的高可用性，发现机器宕机尽快补上。选择合适的内存淘汰策略。
事中：本地ehcache缓存 + hystrix限流&降级，避免MySQL崩掉
事后：利用 redis 持久化机制保存的数据尽快恢复缓存

缓存穿透
简介：一般是黑客故意去请求缓存中不存在的数据，导致所有的请求都落到数据库上，造成数据库短时间内承受大量请求而崩掉。

解决办法：

有很多种方法可以有效地解决缓存穿透问题，最常见的则是采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的bitmap中，一个一定不存在的数据会被这个bitmap拦截掉，从而避免了对底层存储系统的查询压力。另外也有一个更为简单粗暴的方法（我们采用的就是这种），如果一个查询返回的数据为空（不管是数据不存在，还是系统故障），我们仍然把这个空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。

6.6 如何保证缓存与数据库双写时的数据一致性？

你只要用缓存，就可能会涉及到缓存与数据库双存储双写，你只要是双写，就一定会有数据一致性的问题，那么你如何解决一致性问题？
一般来说，就是如果你的系统不是严格要求缓存+数据库必须一致性的话，缓存可以稍微的跟数据库偶尔有不一致的情况，最好不要做这个方案，读请求和写请求串行化，串到一个内存队列里去，这样就可以保证一定不会出现不一致的情况。
串行化之后，就会导致系统的吞吐量会大幅度的降低，用比正常情况下多几倍的机器去支撑线上的一个请求。

6.7 Redis的主从复制如何实现？

主节点将自己内存中的数据做一份快照，将快照发给从节点，从节点将数据恢复到内存中

在每次增加新数据的时候，主节点以类似于MySQL的二进制日志方式将语句发送给从节点，从节点拿到主节点发送过来的语句进行重放

6.8 Redis的单线程模型? 为什么redis单线程还能支撑高并发?

客户端发出 socket 请求—–>连接到 redis 的 server socket —–>通过 AE_READABLE 发送到IO多路复用器—–>将请求压入任务队列中—–>通过文件事件分派器分配到相应的事件处理器

核心是基于非阻塞的IO多路复用模型

纯内存操作，处理请求非常快