Nicht relationale NoSQL-Datenbank
NoSQL-Konzept
Nicht nur SQL: Nicht nur SQL, es bezieht sich auf nicht relationale Datenbanken, es ist eine nützliche Ergänzung zu relationalen Datenbanken. Die endgültigen Daten werden weiterhin in einer relationalen Datenbank gespeichert. Nicht relationale Datenbanken werden hauptsächlich zur Verbesserung der Abfragegeschwindigkeit der Datenbank verwendet und im Allgemeinen als Datencache verwendet.
Nicht relationale Datenbank
Eine nicht relationale Datenbank ist nicht ausschließlich eine Datenbank, sondern sollte eine Sammlung von datenstrukturierten Speichermethoden sein, bei denen es sich um Dokumente oder Schlüssel-Wert-Paare handeln kann.
Vorteil
- Flexibles Format: Das Format der gespeicherten Daten kann Schlüssel, Wert, Dokument, Bild usw. sein. Es ist flexibel zu verwenden und bietet eine Vielzahl von Anwendungsszenarien, während relationale Datenbanken nur Basistypen unterstützen.
- Schnelle Geschwindigkeit: Nosql kann Festplatte oder RAM als Träger verwenden, während relationale Datenbanken nur Festplatte verwenden können.
- Niedrige Kosten: Die nosql-Datenbank ist einfach bereitzustellen und im Grunde Open Source-Software.
Nachteil
- Bietet keine SQL-Unterstützung, die Lern- und Nutzungskosten sind hoch.
- Die Datenstruktur ist relativ komplex und für komplexe Abfragen unpraktisch.
Warum NOSQL verwenden?
Die spezifische Leistung ist die Lösung für die folgenden drei Hauptprobleme:
Hohe Leistung - Hoher gleichzeitiger Datenbankzugriff
Gleichzeitig kann eine große Anzahl von Benutzern gleichzeitig darauf zugreifen. Oft werden Zehntausende von Lese- und Schreibanforderungen pro Sekunde erreicht. Relationale Datenbanken können kaum Zehntausende von SQL-Abfragen verarbeiten, Festplatten-E / A können jedoch nicht mehr Zehntausende von SQL-Schreibdatenanforderungen verarbeiten.
-
Zum Beispiel hat Tmalls Double 11 von 0 bis 2 Uhr morgens zig Millionen Besuche pro Sekunde erreicht.
-
Während des Frühlingsfestes 12306 überprüften die Benutzer immer wieder, ob noch Tickets vorhanden waren, als sie nach Hause gingen, um während des neuen Jahres Bahntickets zu kaufen.
Riesiger Speicher - Riesiger Datenspeicher
Die Datenmenge in der Datenbank ist extrem groß, und in den Datenbanktabellen werden täglich riesige Datenmengen generiert.
Ähnlich wie bei QQ, WeChat und Weibo erzeugen Benutzer jeden Tag eine massive Benutzerdynamik, die jeden Tag zig Millionen Datensätze generiert. Bei relationalen Datenbanken ist das Ausführen von SQL-Abfragen in einer Tabelle mit Hunderten von Millionen Datensätzen äußerst ineffizient und sogar unerträglich.
Hohe Skalierbarkeit && Hochverfügbarkeit - Hohe Skalierbarkeit und hohe Verfügbarkeitsanforderungen
Das Erweitern und Aktualisieren relationaler Datenbanken ist problematisch. Für viele Websites, die einen unterbrechungsfreien 24-Stunden-Service benötigen, ist das Aktualisieren und Erweitern des Datenbanksystems sehr schmerzhaft, was häufig Ausfallzeiten für Wartung und Datenmigration erfordert.
Nicht relationale Datenbanken können durch ständiges Hinzufügen von Serverknoten erweitert werden, ohne dass die ursprüngliche Datenbank verwaltet werden muss.
Redis Katalogdatei
| Verzeichnis oder Datei | bewirken |
|---|---|
| redis-Benchmark.exe | Ein Toolbefehl zum Testen der Leistung |
| redis-check-aof.exe | AOF-Tool zur Überprüfung und Reparatur von Dateien (AOF ist eines seiner Dateispeicherformate) |
| redis-check-dump.exe | Tool zur Überprüfung und Änderung von RDB-Dateien (RDB ist eines seiner Dateispeicherformate) |
| redis-cli.exe | Client Launcher |
| redis-server.exe | Serverseitiges Startprogramm (wird nicht automatisch gestartet, standardmäßig muss es jedes Mal manuell gestartet werden) |
| redis.window.conf | Serverkonfigurationsdatei |
Operationsbefehl vom Typ String
5 Datentypen von Redis
Redis ist ein erweitertes Schlüsselwertspeichersystem, bei dem value fünf Datentypen unterstützt, die sich auf den Typ seines Werts beziehen, und der Schlüssel als Zeichenfolgentyp betrachtet werden kann. Redis ist nicht in Java geschrieben, sondern in C-Sprache.
| Der Datentyp des Werts | Beschreibung |
|---|---|
| Zeichenfolgentyp | String |
| Listentyp | Liste: Elemente können wiederholt werden, und die Elemente werden indiziert und geordnet |
| Typ einstellen | Sammlung: Die Elemente sind nicht wiederholbar, die Elemente haben keine Indexnummer und keine Reihenfolge |
| Hash-Typ | Der Wert besteht aus mehreren Schlüssel-Wert-Paaren |
| zset Typ | Sammlung: Die Elemente sind nicht wiederholbar, jedes Element hat eine Indexnummer und einen Bewertungswert, der nach der Bewertung sortiert werden kann |
Zeichenfolge Typ Zeichenfolge
In Redis binär gespeichert, gibt es keinen Kodierungs- und Dekodierungsprozess.
Unabhängig davon, ob es sich um eine Zeichenfolge, eine Ganzzahl oder einen Gleitkommatyp handelt, wird sie als Zeichenfolge geschrieben.
Die maximale Datendauer, die der Wert für den Zeichenfolgentyp in Redis enthalten kann, beträgt 512 MB. Dies ist der zukünftig am häufigsten verwendete Datentyp.
Allgemeine Befehle
| Befehl | Eigenschaften |
|---|---|
| Schlüsselwert einstellen | Speichern Sie den Schlüssel und den Wert des Zeichenfolgentyps. Wenn der Schlüssel nicht vorhanden ist, fügen Sie ihn hinzu. Wenn er vorhanden ist, ändern Sie ihn |
| setnx Schlüsselwert | Wenn der Schlüssel nicht vorhanden ist, fügen Sie ihn hinzu. Wenn er nicht vorhanden ist, tun Sie nichts und überschreiben Sie den vorherigen Schlüssel und Wert nicht |
| Schlüssel holen | Holen Sie sich Wert durch Schlüssel |
| del 键 | Schlüssel und Wert nach Schlüssel löschen |
Listenbefehle für Operationstypen
Überblick
In Redis ist der Listentyp eine verknüpfte Liste von Zeichenfolgen, die in der Reihenfolge des Einfügens sortiert sind. Wie bei einer normalen verknüpften Liste in einer Datenstruktur können wir links und rechts neue Elemente hinzufügen.
Wenn der Schlüssel beim Einfügen nicht vorhanden ist, erstellt Redis eine neue verknüpfte Liste für den Schlüssel.
Wenn alle Elemente in der verknüpften Liste entfernt werden, wird der Schlüssel auch aus der Datenbank gelöscht.
Die maximale Anzahl von Elementen, die in der Liste enthalten sein können, beträgt 4G (4,1 Milliarden).
Allgemeine Befehle
| Befehl | Verhalten |
|---|---|
| lpush Schlüsselelement Element | Fügen Sie 1 oder mehr Elemente von links hinzu |
| rpush Schlüsselelement Element | Fügen Sie 1 oder mehrere Elemente von rechts hinzu |
| lpop key | Löschen Sie das Element ganz links und kehren Sie zurück |
| rpop key | Löschen Sie das Element ganz rechts und kehren Sie zurück |
| Der Bereichstaste beginnt und endet | Suchen Sie die Elemente im angegebenen Indexbereich und geben Sie zurück, jedes Element hat 2 Indexnummern, Indexnummern von links nach rechts: 0 ~ Länge-1 Indexnummern von rechts nach links: -1 ~ -Länge Wenn Sie alle Elemente in der gesamten Liste erhalten möchten, Wie schreibe ich den Indexnummernbereich? 0 ~ -1 |
| llen 键 | Ermitteln Sie, wie viele Elemente in der Liste enthalten sind |
Befehlsdemonstration
Ein Redis-Server kann mehrere Datenbanken enthalten, und der Client kann nur eine Verbindung zu einer bestimmten Datenbank in Redis herstellen, genau wie das Erstellen mehrerer Datenbanken auf einem MySQL-Server. Der Client gibt an, mit welcher Datenbank beim Herstellen eine Verbindung hergestellt werden soll.
In Redis gibt es 16 Datenbanken mit den Nummern db0-db15. Wir können weder neue Datenbanken erstellen noch Datenbanken löschen. Die Datenbank enthält keine Tabellenstruktur, und der Client stellt standardmäßig eine Verbindung zur 0. Datenbank her. Aber wie viele Datenbanken können über die Konfigurationsdatei festgelegt werden.
Gängige Methoden der Jedis-Klasse
-
Jede Methode ist der Befehlsname in redis, und die Parameter der Methode sind die Parameter des Befehls.
-
Jedes Jedis-Objekt ähnelt dem Verbindungsobjekt in JDBC. Wenn Sie ein Jedis-Objekt erhalten, erhalten Sie im Wesentlichen ein Verbindungsobjekt.
| Verbinden und schließen | Eigenschaften |
|---|---|
| neue Jedis (String Host, Int Port) | Erstellen Sie ein Verbindungsobjekt Parameter 1: Hostname Parameter 2: Portnummer 6379 |
| void close () | Schließen Sie die Verbindung |
| Methoden zur Bearbeitung von Zeichenfolgen | Beschreibung |
|---|---|
| set (String key, String value) | Fügen Sie Schlüssel und Werte für Zeichenfolgentypen hinzu |
| String get (String key) | Holen Sie sich Wert durch Schlüssel |
| del (String… Schlüssel) | Löschen Sie einen oder mehrere Schlüssel und Werte |
| Methoden zur Bedienung der Liste | Beschreibung |
|---|---|
| lpush (String key, String… Werte) | Fügen Sie 1 oder mehr Elemente von links hinzu |
| List<String> lrange(String key,long start,long end) | 获取一个范围内所有的元素 |
代码
package com.itheima;
import redis.clients.jedis.Jedis;
/**
* Jedis的基本使用
*/
public class Demo1Base {
public static void main(String[] args) {
//1.创建Jedis连接对象
Jedis jedis = new Jedis("localhost", 6379);
//2.向服务器添加1个字符串类型的键和值
jedis.set("book","人鬼情喂鸟");
//3.从服务器中通过键获取值
String book = jedis.get("book");
//4.关闭连接
jedis.close();
//5.打印输出到控制台
System.out.println(book);
}
}
Jedis连接池的使用
jedis连接资源的创建与销毁是很消耗程序性能，所以jedis为我们提供了jedis的连接池技术，jedis连接池在创建时初始化一些连接对象存储到连接池中，使用jedis连接资源时不需要自己创建jedis对象，而是从连接池中获取一个资源进行redis的操作。使用完毕后，不需要销毁该jedis连接资源，而是将该资源归还给连接池，供其他请求使用。
Jedis连接池API
用于创建连接池的配置信息
| JedisPoolConfig配置类 | 功能说明 |
|---|---|
| JedisPoolConfig() | 构造方法，创建一个配置对象 |
| void setMaxTotal() | 连接池中最大连接数 |
| void setMaxWaitMillis() | 设置最长等待时间，单位是毫秒 |
| JedisPool连接池类 | 说明 |
|---|---|
| JedisPool(配置对象,服务器名,端口号) | 构造方法，创建连接池的类 参数1：上面的配置对象 参数2：服务器名 参数3：端口号 |
| Jedis getResource() | 从连接池中获取一个创建好的连接对象，返回Jedis对象 |
JedisPool的基本使用
需求：
使用连接池优化jedis操作，从连接池中得到一个创建好的Jeids对象，并且使用这个Jedis对象。向Redis数据库写入一个set集合，并且取出集合。打印到控制台，并且查看数据库中信息。
开发步骤
- 创建连接池配置对象，设置最大连接数10，设置用户最大等待时间2000毫秒
- 通过配置对象做为参数，创建连接池对象
- 从连接池里面获取jedis连接对象，执行redis命令。
- 执行redis命令写入list集合
- 执行redis命令读取list集合
- 输出读取的数据
- 关闭连接对象(通常连接池不关闭)
执行代码
package com.itheima;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.List;
/**
* Jedis连接池的基本使用
*/
public class Demo2Pool {
public static void main(String[] args) {
//1.创建连接池的配置对象
JedisPoolConfig config = new JedisPoolConfig();
//2.设置连接池的参数
config.setMaxTotal(10); //最大连接数
config.setMaxWaitMillis(2000); //最长等待时间为2秒钟
//3.创建连接池，使用上面配置对象
JedisPool pool = new JedisPool(config,"localhost", 6379);
//4.从连接池中获取连接对象
Jedis jedis = pool.getResource();
//5.使用连接对象
jedis.lpush("students", "孙悟空", "猪八戒", "白骨精");
List<String> students = jedis.lrange("students", 0, -1);
System.out.println(students);
//6.关闭连接对象
jedis.close();
}
}
小结
| JedisPool连接池类 | 作用 |
|---|---|
| JedisPool(配置对象,服务器名,端口号) | 创建连接池 参数1：配置对象 参数2：服务器名 参数3：端口号 |
| Jedis getResource() | 从连接池中获取连接对象 |
| void close() | 关闭连接池 |
ResourceBundle类的使用
代码
jedis.properties的内容
# 连接池的最大连接数
maxTotal=10
# 最长等待时间为2秒钟
maxWaitMillis=2000
# 服务器名字
host=localhost
# 端口号
port=6379
使用ResourceBundle类：
package com.itheima;
import java.util.ResourceBundle;
public class Demo3Resource {
public static void main(String[] args) {
//1. 通过静态方法读取属性文件，参数是：属性文件的主文件名，没有扩展名
ResourceBundle bundle = ResourceBundle.getBundle("jedis");
//2. 获取属性值，通过键获取值
String host = bundle.getString("host");
//3.输出值
System.out.println(host);
}
}
小结
| java.util.ResourceBundle类 | 功能 |
|---|---|
| static ResourceBundle getBundle(“配置文件基名”) | 读取配置文件，得到对象。参数是主文件名 |
| String getString(“键名”) | 通过键获取值 |
Jedis连接池工具类的实现
jedis.properties配置文件
# 主机名
host=localhost
# 端口号
port=6379
# 最大连接数
maxTotal=20
# 最长等待时间
maxWaitMillis=3000
JedisUtils.java
package com.itheima.utils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.ResourceBundle;
/**
* Jedis连接池工具类
*/
public class JedisUtils {
private static JedisPool pool;
//在静态代码块中创建连接池
static {
//读取配置文件
ResourceBundle bundle = ResourceBundle.getBundle("jedis");
//读取属性值
int maxTotal = Integer.parseInt(bundle.getString("maxTotal"));
int maxWaitMillis = Integer.parseInt(bundle.getString("maxWaitMillis"));
int port = Integer.parseInt(bundle.getString("port"));
String host = bundle.getString("host");
//创建连接池配置对象
JedisPoolConfig config = new JedisPoolConfig();
//设置连接池的参数
config.setMaxTotal(maxTotal);
config.setMaxWaitMillis(maxWaitMillis);
//创建连接池
pool = new JedisPool(config, host, port);
}
/**
* 获取连接对象
*/
public static Jedis getJedis() {
return pool.getResource();
}
}
使用工具类
package com.itheima;
import com.itheima.utils.JedisUtils;
import redis.clients.jedis.Jedis;
//使用连接池工具类
public class Demo4Use {
public static void main(String[] args) {
//从连接池中获取连接对象
Jedis jedis = JedisUtils.getJedis();
//添加键和值
jedis.set("car", "BWM");
//取出
String car = jedis.get("car");
//输出
System.out.println(car);
//关闭连接
jedis.close();
}
}
持久化
利用永久性存储介质将数据进行保存，在特定的时间将保存的数据进行恢复的工作机制称为持久化 持久化用于防止数据的意外丢失，确保数据安全性
永久化介质保存数据,存在硬盘
RDB
直接拷贝数据从内存到磁盘上
RDB优点
-
RDB是一个紧凑压缩的二进制文件，存储效率较高
-
RDB内部存储的是redis在某个时间点的数据快照，非常适合用于数据备份，全量复制等场景
-
RDB恢复数据的速度要比AOF快很多
-
应用：服务器中每X小时执行bgsave备份，并将RDB文件拷贝到远程机器中，用于灾难恢复。
RDB缺点
-
RDB方式无论是执行指令还是利用配置，无法做到实时持久化，具有较大的可能性丢失数据
-
bgsave指令每次运行要执行fork操作创建子进程，要牺牲掉一些性能
-
Redis的众多版本中未进行RDB文件格式的版本统一，有可能出现各版本服务之间数据格式无法兼容现象
AOF
-
AOF(append only file)持久化：以独立日志的方式记录每次写命令，重启时再重新执行AOF文件中命令 达到恢复数据的目的。与RDB相比可以简单理解为由记录数据改为记录数据产生的变化
-
AOF的主要作用是解决了数据持久化的实时性，目前已经是Redis持久化的主流方式
Drei Strategien zum Schreiben von AOF-Daten (appendfsync)
-
immer (jedes Mal): Jeder Schreibvorgang wird mit dem Fehler Null mit den Daten in der AOF-Datei synchronisiert, die Leistung ist gering und wird nicht empfohlen.
-
alle Sekunden (pro Sekunde): Synchronisieren Sie die Anweisungen im Puffer jede Sekunde mit der AOF-Datei. Bei plötzlichen Systemausfällen gehen die Daten innerhalb von 1 Sekunde verloren. Die Datengenauigkeit ist hoch und die Leistung ist hoch. Es wird empfohlen, sie zu verwenden, und es ist auch die Standardkonfiguration.
-
nein (Systemsteuerung): Der Gesamtprozess des Zyklus, der mit der AOF-Datei synchronisiert ist, wird nicht vom Betriebssystem gesteuert
RDB VS AOF
Die Verwechslung der Wahl zwischen RDB und AOF
-
Es wird empfohlen, das Standard-AOF-Persistenzschema zu verwenden, da es sehr empfindlich auf Daten reagiert
-
Die AOF-Persistenzstrategie verwendet jede Sekunde fsync einmal pro Sekunde. Diese Strategie kann immer noch eine gute Verarbeitungsleistung gewährleisten. Wenn ein Problem auftritt, können Daten innerhalb von 0 bis 1 Sekunden höchstens verloren gehen.
-
Hinweis: Aufgrund des großen Speichervolumens von AOF-Dateien ist die Wiederherstellungsgeschwindigkeit langsam
-
Für die Gültigkeit der Datenpräsentationsphase wird empfohlen, das RDB-Persistenzschema zu verwenden
-
Die Daten können gut sichergestellt werden, dass es keinen Verlust in der Phase gibt (die Phase wird manuell vom Entwickler oder vom Betriebs- und Wartungspersonal gewartet), und die Wiederherstellungsgeschwindigkeit ist relativ hoch. Bei der Wiederherstellung der Phasenpunktdaten wird normalerweise das RDB-Schema angewendet
-
Hinweis: Durch die Verwendung von RDB zur Erzielung einer kompakten Datenpersistenz wird Redis sehr niedrig. Fassen Sie sorgfältig zusammen:
-
Umfassender Vergleich
-
Die Wahl von RDB und AOF ist eigentlich ein Kompromiss. Jedes hat seine Vor- und Nachteile, z. B. dass es nicht möglich ist, Datenverlusten innerhalb weniger Minuten standzuhalten und sehr empfindlich auf Geschäftsdaten zu reagieren. Wählen Sie AOF.
-
Wenn Sie Datenverlust innerhalb weniger Minuten aushalten und die Wiederherstellungsgeschwindigkeit großer Datenmengen verfolgen können, wählen Sie RDB
-
RDB für Disaster Recovery
-
Doppelte Versicherungsstrategie: Öffnen Sie RDB und AOF gleichzeitig. Nach dem Neustart wird Redis der Verwendung von AOF zur Wiederherstellung von Daten und zur Reduzierung der Menge verlorener Daten Vorrang einräumen
Der obige Inhalt ist voreingenommen, bitte korrigieren Sie mich!