NoSQL

一：什么是NoSQL

	Not-Only SQL，泛指 非关系型数据库，为了解决高并发、高拓展、高可用、大数据存储问题 产生的数据库解决方案。

1 NoSql数据库分类

1.1 键值 存储数据库（K-V）

​ 相关产品：Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB

​ 典型应用：内容缓存，主要用于处理大量数据的高访问负载。

​ 数据模型： 一系列键值对

​ 优势： 快速查询

​ 劣势： 存储的数据缺少结构化

1.2 列 存储数据库

​ **相关产品： **Cassandra, HBase, Riak

​ 典型应用： 分布式的文件系统

  **数据模型：**   以列簇式存储，将同一列数据存在一起

​ 优势： 查找速度快，可扩展性强，更容易进行分布式扩展

​ 劣势： 功能相对局限

1.3 文档型 数据库

​ 相关产品： CouchDB、MongoDB

​ 典型应用： Web应用（与Key-Value类似，Value是结构化的）

​ 数据模型： 一系列键值对

​ 优势： 数据结构要求不严格

​ 劣势： 查询性能不高，而且缺乏统一的查询语法

1.4 图形数据库

​ 相关产品：Neo4J、InfoGrid、Infinite Graph

​ 典型应用： 社交网络

​ 数据模型： 图结构

​ 优势： 利用图结构相关算法。

​ 劣势： 需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

---

二：Redis

1. Redis简介

​ C语言开发；

​ 支持5种键值数据类型：字符串类型, 散列类型, 列表类型, 集合类型, 有序集合类型.

​ Redis 支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。

2. Redis应用场景

2.1 缓存

​ 数据查询、短连接、新闻内容、商品内容等等。（最多使用）

2.2 分布式

​ 分布式集群架构中的session分离。

2.3 任务队列

​ （秒杀、抢购、12306等等）

2.4 其他

​ 聊天室的在线好友列表。

​ 应用排行榜。

​ 网站访问统计。

​ 数据过期处理（可以精确到毫秒）

3. Redis Server

​ 默认端口是6379

​ 远程连接redis服务，需要关闭或者修改防火墙配置。

​ 默认一共是16个数据库，每个数据库之间是相互隔离。数据库的数量是在redis.conf中配置的。

切换数据库使用命令：select 数据库编号
例如：select 1

​

4. Redis Client

4.1 Jedis

​ java客户端有 Jedis、Redisson、Jredis、JDBC-Redis等

4.1.1 单实例连接：

@Test
public void testJedis() {
	//创建一个Jedis的连接
	Jedis jedis = new Jedis("127.0.0.1", 6379);
	//执行redis命令
	jedis.set("mytest", "hello world, this is jedis client!");
	//从redis中取值
	String result = jedis.get("mytest");
	//打印结果
	System.out.println(result);
	//关闭连接
	jedis.close();
}

4.1.2 连接池连接：

@Test
public void testJedisPool() {
	//创建一连接池对象
	JedisPool jedisPool = new JedisPool("127.0.0.1", 6379);
	//从连接池中获得连接
	Jedis jedis = jedisPool.getResource();
	String result = jedis.get("mytest");
	System.out.println(result);
	//关闭连接
	jedis.close();
 	//关闭连接池
    jedisPool.close();
}

4.1.3 整合Spring

配置文件, application.xml

<!-- 连接池配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <!-- 最大连接数 -->
    <property name="maxTotal" value="30" />
    <!-- 最大空闲连接数 -->
    <property name="maxIdle" value="10" />
    <!-- 每次释放连接的最大数目 -->
    <property name="numTestsPerEvictionRun" value="1024" />
    <!-- 释放连接的扫描间隔（毫秒） -->
    <property name="timeBetweenEvictionRunsMillis" value="30000" />
    <!-- 连接最小空闲时间 -->
    <property name="minEvictableIdleTimeMillis" value="1800000" />
    <!-- 连接空闲多久后释放, 当空闲时间>该值 且 空闲连接>最大空闲连接数 时直接释放 -->
    <property name="softMinEvictableIdleTimeMillis" value="10000" />
    <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
    <property name="maxWaitMillis" value="1500" />
    <!-- 在获取连接的时候检查有效性, 默认false -->
    <property name="testOnBorrow" value="false" />
    <!-- 在空闲时检查有效性, 默认false -->
    <property name="testWhileIdle" value="true" />
    <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
    <property name="blockWhenExhausted" value="false" />
</bean>

<!-- redis单机 通过连接池 -->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool"
    destroy-method="close">
    <constructor-arg name="poolConfig" ref="jedisPoolConfig" />
    <constructor-arg name="host" value="192.168.242.130" />
    <constructor-arg name="port" value="6379" />
</bean>

测试代码：

@Test
public void testJedisPool() {
	JedisPool pool = (JedisPool) applicationContext.getBean("jedisPool");
	Jedis jedis = null;
	try {
		jedis = pool.getResource();
        jedis.set("name", "lisi");
        String name = jedis.get("name");
        System.out.println(name);
    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        if (jedis != null) {
            // 关闭连接
            jedis.close();
        }
    }
}

5. Redis 数据类型

Redis命令：http://www.redis.cn/commands.html#

注意：

• 在Redis中的命令语句中，命令是忽略大小写的，而key是不忽略大小写的。
• key的类型只能是string。？

​

5.1 String 字符串

5.1.1 赋值：

​ 单组 SET key value

​ 多组 mset k1 v1 k2 v2 k3 v3

5.1.2 取值：

​ 单组 GET key

​ 多组 mget k1 k3

5.1.3 取值并赋值：

​ getset s2 222

5.1.4 删除：

​ DEL key

5.1.4 数值增减：

1. 当存储的字符串是整数时，Redis提供了一个实用的命令INCR，其作用是让当前键值递增 1，并返回递增后的值：INCR key。 eg：incr num

2. 增加指定的整数 ：INCRBY key increment 。 eg： incrby num 2

3. 递减数值：DECR key。 eg：decr num

4. 减少指定的整数：DECRBY key decrement。 eg：decrby num 3

5.1.5 字符串追加 APPEND

​ APPEND的作用是向键值的末尾追加value。如果键不存在则将该键的值设置为value，即相当于 SET key value。返回值是追加后字符串的总长度。

语法：APPEND key value
127.0.0.1:6379> set str hello
OK
127.0.0.1:6379> append str " world!"
(integer) 12
127.0.0.1:6379> get str
"hello world!"

5.1.6 获取长度： STRLEN

​ STRLEN命令返回键值的长度，如果键不存在则返回0。

语法：STRLEN key
127.0.0.1:6379> strlen str
(integer) 0
127.0.0.1:6379> set str hello
OK
127.0.0.1:6379> strlen str
(integer) 5

5.1.7 其他

5.2 Hash 散列

假设有User对象以JSON序列化的形式存储到Redis中，User对象有id，username、password、age、name等属性，
如果在业务上只是更新age属性， 如果仍然采用上边的方法在传输、处理时会造成资源浪费，hash可以很好的解决这个问题。它提供了字段和字段值的映射。字段值只能是字符串类型，不支持散列类型、集合类型等其它类型。

5.2.1 赋值：

HSET命令不区分插入和更新操作，当执行插入操作时HSET命令返回1，当执行更新操作时返回0。返回值为行数

1. 一次只能设置一个字段值
语法：HSET key field value
127.0.0.1:6379> hset user username zhangsan
(integer) 1

2.  一次可以设置多个字段值
语法：HMSET key field value [field value ...]
127.0.0.1:6379> hmset user age 20 username lisi
OK
    

5.2.2 取值：

1.  一次只能获取一个字段值
语法：HGET key field
127.0.0.1:6379> hget user username
"zhangsan“

2.   一次可以获取多个字段值
语法：HMGET key field [field ...]
127.0.0.1:6379> hmget user age username
"20"
"lisi"

3.   获取所有字段值
语法：HGETALL key
127.0.0.1:6379> hgetall user
"age"
"20"
"username"
"lisi"

5.2.3 删除：

可以删除一个或多个字段，返回值是被删除的字段个数

语法：HDEL key field [field ...]
127.0.0.1:6379> hdel user age
(integer) 1
127.0.0.1:6379> hdel user age name
(integer) 0
127.0.0.1:6379> hdel user age username
(integer) 1

5.2.4 增加数字

语法：HINCRBY key field increment
127.0.0.1:6379> hincrby user age 2 将用户的年龄加2
(integer) 22
127.0.0.1:6379> hget user age 获取用户的年龄
"22“

5.2.5 获取字段名或值

hkeys获取字段名，即key

hvals获取字段值，即value

语法：
HKEYS key
HVALS key
127.0.0.1:6379> hmset user age 20 name lisi
OK
127.0.0.1:6379> hkeys user

"age"
"name"
127.0.0.1:6379> hvals user
"20"
"lisi"

5.2.6 获取字段数量：hlen

语法：HLEN key
127.0.0.1:6379> hlen user
(integer) 2

5.3 List 列表

ArrayList与LinkedList的区别
ArrayList使用数组方式存储数据，所以根据索引查询数据速度快，而新增或者删除元素时需要设计到位移操作，所以比较慢。
LinkedList使用双向链表方式存储数据，每个元素都记录前后元素的指针，所以插入、删除数据时只是更改前后元素的指针指向即可，速度非常快。然后通过下标查询元素时需要从头开始索引，所以比较慢，但是如果查询前几个元素或后几个元素速度比较快。

5.3.1 添加数据

左追加：lpush

语法：LPUSH key value [value ...]
127.0.0.1:6379> lpush list:1 1 2 3
(integer) 3

右追加：rpush

语法：RPUSH key value [value ...]
127.0.0.1:6379> rpush list:1 4 5 6
(integer) 3

5.3.2 弹出数据

左弹出：lpop

右弹出：rpop

语法：
LPOP key
RPOP key
127.0.0.1:6379> lpop list:1
"3“
127.0.0.1:6379> rpop list:1
"6“

5.3.3 查看列表：lrange

LRANGE命令是获取列表中的某一片段，将返回start、stop之间的所有元素（包含两端的元素即闭区间）。

索引从0开始。索引可以是负数，如：“-1”代表最后边的一个元素。

语法：LRANGE key start stop
127.0.0.1:6379> lrange list:1 0 2
"2"
"1"
"4"

5.3.4 获取列表元素的个数：llen

语法：LLEN key
127.0.0.1:6379> llen list:1
(integer) 2

5.3.5 删除列表中指定的值

语法：LREM key count value

5.3.6 使用索引的元素值

1.   获得指定索引的元素值
语法：LINDEX key index
127.0.0.1:6379> lindex l:list 2
"1"

2.   设置指定索引的元素值
语法：LSET key index value
127.0.0.1:6379> lset l:list 2 2
OK
127.0.0.1:6379> lrange l:list 0 -1
"6"
"5"
"2"
"2"

5.3.7 截取部分：ltrim

语法：LTRIM key start stop  闭区间
127.0.0.1:6379> lrange l:list 0 -1
"6"
"5"
"0"
"2"
127.0.0.1:6379> ltrim l:list 0 2
OK
127.0.0.1:6379> lrange l:list 0 -1
"6"
"5"
"0"

5.3.8 插入元素: linsert

该命令首先会在列表中从左到右查找值为pivot的元素，然后根据第二个参数是BEFORE还是AFTER来决定将value插入到该元素的前面还是后面。

语法：LINSERT key BEFORE|AFTER pivot value
127.0.0.1:6379> lrange list 0 -1
"3"
"2"
"1"
127.0.0.1:6379> linsert list after 3 4
(integer) 4
127.0.0.1:6379> lrange list 0 -1
"3"
"4"
"2"
"1"

5.3.9 元素的转移复制: rpoplpush

语法：RPOPLPUSH source destination
127.0.0.1:6379> rpoplpush list newlist
"1"
127.0.0.1:6379> lrange newlist 0 -1
"1"
127.0.0.1:6379> lrange list 0 -1
"3"
"4"
"2"

5.4 Set 集合

5.4.1 增加删除元素：

语法：SADD key member [member ...]
127.0.0.1:6379> sadd set a b c
(integer) 3
127.0.0.1:6379> sadd set a
(integer) 0
语法：SREM key member [member ...]
127.0.0.1:6379> srem set c d
(integer) 1

5.4.2 获得所有元素:

语法：SMEMBERS key
127.0.0.1:6379> smembers set
"b"
"a”

5.4.3 元素是否存在：

语法：SISMEMBER key member
127.0.0.1:6379> sismember set a
(integer) 1
127.0.0.1:6379> sismember set h
(integer) 0

5.4.4 运算命令：

差集运算 A-B [ sdiff]：属于A并且不属于B的元素构成的集合。

语法：SDIFF key [key ...]
127.0.0.1:6379> sadd setA 1 2 3
(integer) 3
127.0.0.1:6379> sadd setB 2 3 4
(integer) 3
127.0.0.1:6379> sdiff setA setB
"1"
127.0.0.1:6379> sdiff setB setA
"4"

交集运算 A ∩ B [ sinter ]：属于A且属于B的元素构成的集合。

语法：SINTER key [key ...]
127.0.0.1:6379> sinter setA setB
"2"
"3"

并集运算 A ∪ B [ sunion ]: 属于A或者属于B的元素构成的集合

语法：SUNION key [key ...]
127.0.0.1:6379> sunion setA setB
"1"
"2"
"3"
"4"

5.4.5 获得集合的元素个数：scard

语法：SCARD key
127.0.0.1:6379> smembers setA
"1"
"2"
"3"
127.0.0.1:6379> scard setA
(integer) 3

5.4.6 弹出一个元素

注意：由于集合是无序的，所有SPOP命令会从集合中随机选择一个元素弹出

语法：SPOP key
127.0.0.1:6379> spop setA
"1“

5.5 ZSet 有序集合

在集合类型的基础上，有序集合类型为集合中的每个元素都关联一个分数，这使得我们不仅可以完成插入、删除和判断元素是否存在在集合中，还能够获得分数最高或最低的前N个元素、获取指定分数范围内的元素等与分数有关的操作。但更耗内存。

5.5.1 增加元素：

向有序集合中加入一个元素和该元素的分数，如果该元素已经存在则会用新的分数替换原有的分数。返回值是新加入到集合中的元素个数，不包含之前已经存在的元素。

语法：ZADD key score member [score member ...]
127.0.0.1:6379> zadd scoreboard 80 zhangsan 89 lisi 94 wangwu
(integer) 3
127.0.0.1:6379> zadd scoreboard 97 lisi
(integer) 0

5.5.2 获取元素的分数：

语法：ZSCORE key member
127.0.0.1:6379> zscore scoreboard lisi
"97"

5.5.3 删除元素:

移除有序集key中的一个或多个成员，不存在的成员将被忽略。
当key存在但不是有序集类型时，返回一个错误。

语法：ZREM key member [member ...]
127.0.0.1:6379> zrem scoreboard lisi
(integer) 1

5.5.4 获得排名在某个范围的元素列表:

从小到大的顺序：zrange

语法：ZRANGE key start stop [WITHSCORES]
127.0.0.1:6379> zrange scoreboard 0 2
"zhangsan"
"wangwu"
"lisi“

从大到小的顺序：zrevrange

语法：ZREVRANGE key start stop [WITHSCORES]
127.0.0.1:6379> zrevrange scoreboard 0 2
" lisi "
"wangwu"
" zhangsan “

如果需要获得元素的分数的可以在命令尾部加上WITHSCORES参数

127.0.0.1:6379> zrange scoreboard 0 1 WITHSCORES
"zhangsan"
"80"
"wangwu"
"94"

5.5.5 获得集合中元素的数量: ZCARD

语法：ZCARD key
127.0.0.1:6379> ZCARD scoreboard
(integer) 3

5.5.6 获得指定分数范围内的元素个数:

语法：ZCOUNT key min max
127.0.0.1:6379> ZCOUNT scoreboard 80 90
(integer) 1

5.5.7 获取元素的排名:

   从小到大
语法：ZRANK key member
127.0.0.1:6379> ZRANK scoreboard lisi
(integer) 0
   从大到小
语法：ZREVRANK key member
127.0.0.1:6379> ZREVRANK scoreboard zhangsan
(integer) 1

5.6 其他常用命令

5.6.1 判断是否存在 exists

语法：HEXISTS key field 判断hash类型是否存在 某字段
127.0.0.1:6379> hexists user age        查看user中是否有age字段
(integer) 1
127.0.0.1:6379> hexists user name   查看user中是否有name字段
(integer) 0

5.6.2 setnx

5.6.3 key的生存时间

EXPIRE key seconds 设置key的生存时间（单位：秒）key在多少秒后会自动删除
TTL key 查看key生于的生存时间
PERSIST key 清除生存时间
PEXPIRE key milliseconds 生存时间设置单位为：毫秒

例子：
192.168.101.3:7002> set test 1      设置test的值为1
OK
192.168.101.3:7002> get test            获取test的值
"1"
192.168.101.3:7002> EXPIRE test 5   设置test的生存时间为5秒
(integer) 1
192.168.101.3:7002> TTL test            查看test的生于生成时间还有1秒删除
(integer) 1
192.168.101.3:7002> TTL test
(integer) -2
192.168.101.3:7002> get test            获取test的值，已经删除
(nil)

5.6.4 获取key列表:

返回满足给定pattern 的所有key

redis 127.0.0.1:6379> keys mylist*
"mylist"
"mylist5"
"mylist6"
"mylist7"
"mylist8"

5.6.5 重命名key: rename

5.6.6 类型：type

返回 值的类型。这个方法可以非常简单的判断出值的类型

redis 127.0.0.1:6379> type addr
string
redis 127.0.0.1:6379> type myzset2
zset
redis 127.0.0.1:6379> type mylist
list

6. Redis持久化

6.1 RDB持久化

6.1.1 RDB简介

​ RDB方式的持久化是通过快照（snapshotting）完成的，当符合一定条件时Redis会自动将内存中的数据进行快照并持久化到硬盘。RDB是Redis默认采用的持久化方式。

6.1.2 持久化条件配置

save 开头的一行就是持久化配置，可以配置多个条件（每行配置一个条件），每个条件之间是“或”的关系。
“save 900 1”表示15分钟（900秒钟）内至少1个键被更改则进行快照。
“save 300 10”表示5分钟（300秒）内至少10个键被更改则进行快照。

6.1.3 配置快照文件

• dir ./ 目录
• dbfilename dump.rdb 文件名

6.1.3 总结：

​ Redis启动后会读取RDB快照文件，将数据从硬盘载入到内存。根据数据量大小与结构和服务器性能不同，这个时间也不同。通常将记录一千万个字符串类型键、大小为1GB的快照文件载入到内存中需要花费20～30秒钟。

​ 通过RDB方式实现持久化，一旦Redis异常退出，就会丢失最后一次快照以后更改的所有数据。这就需要开发者根据具体的应用场合，通过组合设置自动快照条件的方式来将可能发生的数据损失控制在能够接受的范围。

​ 如果数据很重要以至于无法承受任何损失，则可以考虑使用AOF方式进行持久化。

6.2 AOF持久化

6.2.1 开启配置

默认情况下Redis没有开启AOF（append only file）方式的持久化.

可以通过修改redis.conf配置文件中的appendonly参数开启
appendonly yes

6.2.2 保存文件

开启AOF持久化后每执行一条会更改Redis中的数据的命令，Redis就会将该命令写入硬盘中的AOF文件。
AOF文件的保存位置和RDB文件的位置相同，都是通过dir参数设置的。

​ dir ./

​ 默认的文件名是appendonly.aof，可以通过appendfilename参数修改：
appendfilename appendonly.aof

6.2.3 追加时间

​ 使用 AOF 持久化需要设置同步选项，从而确保写命令同步到磁盘文件上的时机。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：

选项	同步频率
always	每个写命令都同步
everysec	每秒同步一次
no	让操作系统来决定何时同步

• always 选项会严重减低服务器的性能；
• everysec 选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且 Redis 每秒执行一次同步对服务器性能几乎没有任何影响；
• no 选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。

6.2.4 AOF 重写

​ 随着服务器写请求的增多，AOF 文件会越来越大。Redis 提供了一种将 AOF 重写的特性，能够去除 AOF 文件中的冗余写命令。

7. 主从复制

7.1 什么是主从复制

• 持久化保证即使redis服务重启也不会丢失数据，因为redis服务重启后会将硬盘上持久化的数据恢复到内存中，但是当redis服务器的硬盘损坏了可能会导致数据丢失，如果通过redis的主从复制机制就可以避免这种单点故障。
• 数据保持实时同步，当主redis写入数据时通过主从复制机制会复制到两个从redis服务上。
• 只有一个主redis，可以有多个从redis。但一个redis可以即是主又是从。
• 主从复制不会阻塞master，在同步数据时，master 可以继续处理client 请求

7.2 主从配置

​ 主Redis无需特殊配置；

​ 从redis配置：修改 从redis服务器上的redis.conf文件。

​ slaveof 127.0.0.1 6379 ： （slaveof ip port）

7.3 连接过程

1. 主服务器创建快照文件，发送给从服务器，并在发送期间使用缓冲区记录执行的写命令。快照文件发送完毕之后，开始向从服务器发送存储在缓冲区中的写命令；
2. 从服务器丢弃所有旧数据，载入主服务器发来的快照文件，之后从服务器开始接受主服务器发来的写命令；
3. 主服务器每执行一次写命令，就向从服务器发送相同的写命令。

7.4 主从链

​ 随着负载不断上升，主服务器可能无法很快地更新所有从服务器，或者重新连接和重新同步从服务器将导致系统超载。为了解决这个问题，可以创建一个中间层来分担主服务器的复制工作。中间层的服务器是最上层服务器的从服务器，又是最下层服务器的主服务器。

8. Redis集群

9. Jedis连接集群