高性能的Key-Value数据库：Redis_keyvalue批量查询效率高的数据库

NoSQL概念

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

优点

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

缺点

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

比较

非关系型数据库优势

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

关系型数据库的优势

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

总结

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

主流的NOSQL产品

键值(Key-Value)存储数据库

相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
典型应用： 内容缓存，主要用于处理大量数据的高访问负载。
数据模型： 一系列键值对
优势： 快速查询
劣势： 存储的数据缺少结构化

##　列存储数据库

相关产品：Cassandra, HBase, Riak
典型应用：分布式的文件系统
数据模型：以列簇式存储，将同一列数据存在一起
优势：查找速度快，可扩展性强，更容易进行分布式扩展
劣势：功能相对局限

文档型数据库

相关产品：CouchDB、MongoDB
典型应用：Web应用（与Key-Value类似，Value是结构化的）
数据模型： 一系列键值对
优势：数据结构要求不严格
劣势： 查询性能不高，而且缺乏统一的查询语法

##　图形(Graph)数据库

相关数据库：Neo4J、InfoGrid、Infinite Graph
典型应用：社交网络
数据模型：图结构
优势：利用图结构相关算法。
劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

Redis

##　概念

• Redis是一款高性能的NOSQL系列的非关系型数据库
• Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s 。
• Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的键值数据类型如下：
  • 字符串类型 string
  • 哈希类型 hash
  • 列表类型 list
  • 集合类型 set
  • 有序集合类型 sortedset

redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等）
• 聊天室的在线好友列表
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜
• 网站访问统计
• 数据过期处理（可以精确到毫秒
• 分布式集群架构中的session分离

下载安装

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

数据结构

• Redis存储：key，value格式的数据
  • key的数据类型：字符串
  • value的数据结构：
    • 字符串类型 string
    • 哈希类型 hash （map格式）
    • 列表类型 list （ Linkedlist格式，允许重复）
    • 集合类型 set （HashSet格式，不允许重复）
    • 有序集合类型 sortedset （不允许重复，且有序）

命令操作

字符串类型 string

• 存储： set key value
• 获取： get key
• 删除： del key

哈希类型 hash

• 存储： hset key field value
• 获取指定的field对应的值：hget key field:
• 获取所有的field和value：hgetall key
• 删除： hdel key field

列表类型 list

• 将元素加入列表左边： lpush key value
• 将元素加入列表右边：rpush key value
• 范围获取：lrange key start end
  • 获取所有元素：lrange key 0 -1
• 删除列表最左边的元素，并将元素返回：lpop key
• 删除列表最右边的元素，并将元素返回：rpop key

集合类型 set

• set 集合 （ 不允许重复）
  • 存储：sadd key value
  • 获取set集合中所有元素：smembers key
  • 删除set集合中的某个元素：srem key value

有序集合类型 sortedset

• sortedset集合
  • 不允许重复元素，且元素有顺序。
  • 每个元素都会关联一个double类型的分数。
  • redis正是通过分数来为集合中的成员进行从小到大的排序。
• 存储：zadd key score value
• 获取：zrange key start end [withscores]
• 删除：zrem key value

通用命令

• 查询所有的键：keys *
• 获取键对应的value的类型：type key
• 删除指定的key value：del key

持久化机制

• Redis持久化
  • Redis是一个内存数据库，当redis服务器重启，或者电脑重启，数据丢失时，我们可以将redis内存中的数据持久化，将其保存到硬盘的文件中。

RDB

• 默认持久化机制
• 在一定的间隔时间中，检测key的变化情况，然后持久化数据。
  • 修改 redis.windwos.conf 文件
    • save 900 1：after 900 sec (15 min) if at least 1 key changed
    • save 300 10：after 300 sec (5 min) if at least 10 keys changed
    • save 60 10000：after 60 sec if at least 10000 keys changed
  • 使用命令行，重新启动redis服务器，并指定配置文件名称
    • redis-server.exe redis.windows.conf

AOF

• 日志记录机制
• 记录每一条命令的操作。每一次命令操作后，持久化数据。
• 编辑 redis.windwos.conf 文件
  • 开启AOF
    • appendonly no（关闭AOF）
    • ppendonly yes （开启AOF）
  • 取值
    • appendfsync always ： 每一次操作都进行持久化
    • appendfsync everysec ： 每隔一秒进行一次持久化（默认）
    • appendfsync no： 不进行持久化
  • 使用命令行，重新启动redis服务器，并指定配置文件名称
    • redis-server.exe redis.windows.conf

Jedis（Java客户端）

• Jedis:是一款java操作redis数据库的工具.

快速入门

• 下载jedis的jar包
• 使用

// 获取连接
    Jedis jedis = new Jedis("localhost",6379);
// 操作
    jedis.set("username","zhangsan");
// 关闭连接
    jedis.close();
1
2
3
4
5
6

命令操作

字符串类型 string

• set
• get

    @Test/* 操作字符串String */
    public void test02() {
        // 获取连接
        Jedis jedis = new Jedis(); //空参构造，默认("localhost",6379)
        // 存储
        jedis.set("cat","001");
        // 获取
        String cat = jedis.get("cat");
        System.out.println(cat);

        // 存储有时限的数据
        jedis.setex("dog",10,"002"); // 时间单位：秒

        // 关闭连接
        jedis.close();

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

哈希类型 hash （ map格式 ）

• hset
• hget
• hgetAll

    @Test /* 操作Hash */
    public void test03() {
        // 获取连接
        Jedis jedis = new Jedis();
        // 存储
        jedis.hset("map","cat","111");
        jedis.hset("map","dog","222");
        jedis.hset("map","rat","333");
        // 获取
        String cat = jedis.hget("map", "cat");
        System.out.println(cat);

        // 获取hash中的map中的所有数据
        Map<String, String> map = jedis.hgetAll("map");
        // 输出
        Set<String> keySet = map.keySet();
        for (String s : keySet) {
            String value = map.get(s);
            System.out.println(s+":"+value);

        }
        // 关闭连接
        jedis.close();

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

列表类型 list （ LinkedList格式，允许重复）

• lpush / rpush
• lpop / rpop
• lrange start end

    @Test /* 操作List(允许重复) */
    public void test04() {
        // 获取连接
        Jedis jedis = new Jedis();
        // 存储
        jedis.lpush("list","A","B","C","D");
        jedis.rpush("list","A","B","C","D");
        // 打印
        List<String> list = jedis.lrange("list", 0, -1);
        System.out.println(list);
        // 弹出
        String element1 = jedis.lpop("list");
        String element2 = jedis.lpop("list");
        // 打印
        System.out.println(element1);
        System.out.println(element2);
        List<String> list2 = jedis.lrange("list", 0, -1);
        System.out.println(list2);
        // 关闭连接
        jedis.close();

    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

集合类型 set （HashSet格式， 不允许重复）

• sadd
• smembers

    @Test /* 操作Set(不允许重复) */
    public void test05() {
        // 获取连接
        Jedis jedis = new Jedis();
        // 存储
        jedis.sadd("set","A","B","C","D");
        // 获取
        Set<String> set = jedis.smembers("set");
        // 打印
        System.out.println(set);
        // 关闭连接
        jedis.close();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

有序集合类型 sortedset

• zadd
• zrange

    @Test /* 操作SortedSet(不允许重复，有序) */
    public void test06() {
        // 获取连接
        Jedis jedis = new Jedis();
        // 存储
        jedis.zadd("sortedSet",1,"cat");
        jedis.zadd("sortedSet",2,"dog");
        jedis.zadd("sortedSet",3,"rat");
        // 获取
        Set<String> sortedSet = jedis.zrange("sortedSet", 0, -1);
        // 打印
        System.out.println(sortedSet);
        // 关闭连接
        jedis.close();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

JedisPool（jedis连接池）

• 快速入门
  • 创建JedisPool连接池对象
  • 调用方法 getResource()方法获取Jedis连接

    // 创建连接池配置对象
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 设置配置
        jedisPoolConfig.setMaxTotal(50);
        jedisPoolConfig.setMaxIdle(10);
        // 创建连接池对象，并传入连接池配置对象
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, "localhost", 6379);
        // 获取连接
        Jedis resource = jedisPool.getResource();
        // 使用
        resource.set("name", "cat");
        String s = resource.get("name");
        System.out.println(s);
        // 关闭，归还到连接池中
        resource.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

JedisPoolUtil工具类

设置 JedisPoolUtil工具类

public class JedisPoolUtil {

    // 连接池对象
    private static JedisPool jedisPool;

    static {
        // 读取配置文件
        Properties properties = new Properties();
        // 创建properties对象
        InputStream resourceAsStream = JedisPoolUtil.class.getClassLoader().getResourceAsStream("jedis.properties");
        try {
            // 加载文佳
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 创建连接池配置文件对象
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置
        config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));

        // 初始化连接池对象
        jedisPool = new JedisPool(config,properties.getProperty("host"),Integer.parseInt(properties.getProperty("port")));
    }

    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

设置之后的操作，简化了很多

public class JedisPoolUtil {

    // 连接池对象
    private static JedisPool jedisPool;

    static {
        // 读取配置文件
        Properties properties = new Properties();
        // 创建properties对象
        InputStream resourceAsStream = JedisPoolUtil.class.getClassLoader().getResourceAsStream("jedis.properties");
        try {
            // 加载文佳
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 创建连接池配置文件对象
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置
        config.setMaxTotal(Integer.parseInt(properties.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(properties.getProperty("maxIdle")));

        // 初始化连接池对象
        jedisPool = new JedisPool(config,properties.getProperty("host"),Integer.parseInt(properties.getProperty("port")));
    }

    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

​