非关系型数据库_非关系型数据库查询速度

几种常见非关系型数据库（Nosql）：redis、mongoDB、

1. redis数据库
   redis :是一个非关系型数据库（NoSQL),数据保存在内存中，由于数据从内存中读取，快于数据从硬盘中读取，所以redis 的数据查询效率高于mysql。
   特性：
   1）是一种高性能的（key/value）分布式内存数据库
   2）redis基于内存，也支持持久化（可以存到硬盘）的Nosql数据库。
   3）redis的两种持久化方案：RDB和AOF（AOP是面向切面编程，注意和AOF区别）
   RDB是 Redis 默认 的持久化方案。在指定的时间间隔内，执行指定次数的写操作，则会将内存中的数据写入到磁盘中。即在指定目
   录下生成一个dump.rdb文件(快照〉。Redis重启会通过加载dump.rdb 文件恢复数据。
   AOF : Redis 默认不开启。它的出现是为了弥补RDB的不足（数据的不一致性)，所以它采用日志的形式来记录每个写操作，并追加
   到文件中。Redis 重启的会根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。
   4）redis是单线程的，最新版本的redis是支持多线程的（redis不一定开启多线程）

五大数据类型
1 string 字符串
2 hash 散列
Redis hash 是一个 string 类型的 field 和 value 的映射表，
hash 特别适合用于存储对象,类似于java里面的Map<String, Object>

3 list 列表
Redis 列表是简单的字符串列表，按照插入顺序排序。
你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
他的底层实现是个链表，链表可以两端双向插入。

4 set 集合
Redis的Set是string类型的无序集合。
集合是通过哈希表（HashTable）实现的，所以添加，删除，查找的复杂度都是O(1)。

5 Zset（sorted set 有序集合）：
Redis zset 和 set 一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
zset的成员是唯一的,但分数(score)却可以重复。

java连接 Redis数据库配置：
流程：yml — RedisConfig配置 — RedisUseDemo（使用redis实现业务逻辑，如增删改查）— RedisController （调用RedisUseDemo方法）
1）pom.xml配置：

 <!-- redis 非关系型数据库-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- jedis连接redis数据库:   redis连接驱动-->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>3.1.0</version>
    </dependency>

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

2）application.yml文件配置：

# redis数据源
redis:
  # redis服务ip地址
  host: 127.0.0.1
  # 服务端口号
  port: 6379
  # 密码
  password:
  database: 2
  pool:
    # 连接池最大连接数（负值表示没有限制）
    max-active: 8
    # 连接池最大阻塞等待时间（负值表示没有限制）
    max-wait: 1
    # 最大空闲连接
    max-idle: 8
    # 最小空闲连接
    min-idle: 0
  # 连接超时时间（毫秒）
  timeout: 30000
  # 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
  blockWhenExhausted: false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3）RedisConfig.java配置文件
配置数据库参数，进行数据库连接，创建redis连接类。

package com.st.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
//声明是配置类，且兼具@Component的作用
@Configuration
public class RedisConfig {
    @Value("${redis.host}") //读取yml配置文件，将配置文件中的值，赋值值变量
    private String host;

    @Value("${redis.port}")
    private int port;

    @Value("${redis.timeout}")
    private int timeout;

    @Value("${redis.pool.max-idle}")
    private int maxIdle;

    @Value("${redis.pool.max-wait}")
    private int maxWaitMillis;

    @Value("${redis.blockWhenExhausted}")
    private Boolean blockWhenExhausted;

    @Value("${redis.password}")
    private String passWord;

    @Value("${redis.database}")
    private int dataBase;

    @Bean //将本方法返回的类对象，注入到ioc容器中去
    public JedisPool jedisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //加载连接池配置
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
        // 连接耗尽时是否阻塞, false报异常,true阻塞直到超时, 默认true
        jedisPoolConfig.setBlockWhenExhausted(blockWhenExhausted);

        // 是否启用pool的jmx监控，可用于监控资源使用状态 【默认值：true】
        //使用建议：开启
//        jedisPoolConfig.setJmxEnabled(JmxEnabled);
        //创建redis连接类
        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, null, dataBase);

        return jedisPool;
    }
}
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

4）RedisUseDemo.java
连接Redis实现业务逻辑

package com.st.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/*
redis操作示例:实现增、改、查
 */
@Component
public class RedisUseDemo {

    @Autowired
    private JedisPool jedisPool;

    private Jedis jedis = null;

    public void connection(){
        if(jedis == null) {
            //建立redis连接
            jedis = jedisPool.getResource();
        }
    }

    /**
     * 向Redis中存值，永久有效（没有设置过期时间）
     */
    public String set(String key, String value) {
        connection();
        try {
            //添加键指对,如果key已经存在，覆盖原来的值，成功返回OK
            String res = jedis.set(key, value);

            //只有当key的值不存在时，设置key的值,成功返回1 失败返回0
//            long res = jedis.setnx(key, value);

            //设置过期时间，单位秒（s）
//            if ("ok".equals(res.toLowerCase())) jedis.expire(key, 60);
            System.out.println(res);
            return "OK";
        } catch (Exception e) {
            return "0";
        } finally {
            //关闭连接
            jedis.close();
        }
    }

    /**
     * 根据传入Key获取指定Value
     */
    public String get(String key) {
        connection();
        String value = null;
        try {
            value = jedis.get(key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            jedis.close();
        }
        return value;
    }

    /**
     * 校验Key值是否存在
     */
    public Boolean exists(String key) {
        connection();
        try {
            return jedis.exists(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        } finally {
            jedis.close();
        }
    }

    /**
     * 删除指定Key-Value
     */
    public Long del(String key) {
        connection();
        try {
            return jedis.del(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        } finally {
            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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

5）RedisController.java Controller使用

package com.st.controller;
import com.st.config.RedisUseDemo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/redis")
public class RedisController {
    @Autowired
    private RedisUseDemo redis;
    @RequestMapping("/t")
    public String test(){
        return redis.set("name", "张三");
    }
}

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