PHP und REDIS: So erreichen Sie eine dauerhafte Datenspeicherung-PHP-Tutorial-php.cn

PHP und REDIS: So erreichen Sie eine dauerhafte Speicherung von Daten

Einführung:
Im Prozess der Webentwicklung müssen wir häufig Daten dauerhaft speichern. Als leistungsstarkes Schlüsselwertspeichersystem kann Redis unsere Anforderungen gut erfüllen. In diesem Artikel wird erläutert, wie Sie mithilfe von PHP und Redis eine dauerhafte Datenspeicherung erreichen.

1. Redis-Installation und -Konfiguration

Redis herunterladen und installieren:
Zuerst müssen Sie Redis von der offiziellen Redis-Website herunterladen und installieren. Die spezifischen Installationsschritte werden hier nicht beschrieben.
Redis konfigurieren:
Nach Abschluss der Installation müssen Sie die Redis-Konfigurationsdatei (redis.conf) eingeben, um einige grundlegende Konfigurationen durchzuführen.

a) Öffnen Sie die redis.conf-Datei
```
vim /etc/redis/redis.conf
```
Nach dem Login kopieren
b) Konfigurieren Sie das Redis-Passwort
Suchen und ändern Sie den Parameter „requirepass“ und stellen Sie ihn auf das gewünschte Passwort ein:
```
requirepass your_password
```
Nach dem Login kopieren
c) Speichern Sie die Änderungen und schließen Sie die Datei.
Redis starten:
Geben Sie den folgenden Befehl in das Terminal ein, um Redis zu starten:
```
redis-server
```
Nach dem Login kopieren

2. Verwenden Sie PHP, um eine Verbindung zum Redis-Server herzustellen.
Als nächstes müssen Sie PHP verwenden, um eine Verbindung zum Redis-Server herzustellen und zu implementieren Lesen und Verarbeiten der Daten im Codespeicher.

Installieren Sie die Redis-Erweiterung:
Um Redis in PHP verwenden zu können, müssen Sie zuerst die Redis-Erweiterung installieren. Es kann über PECL oder Quellcode-Kompilierung installiert werden.
Mit dem Redis-Server verbinden:
Zuerst müssen Sie die Klasse Redis im Code verwenden, um das Redis-Objekt zu instanziieren und eine Verbindung mit dem Redis-Server herzustellen: Redis类来实例化Redis对象，并连接到Redis服务器：
```
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->auth('your_password'); // 如果设置了Redis密码，需要进行身份验证
```
Nach dem Login kopieren
存储数据到Redis：
在Redis中，我们可以使用set方法将数据存储到指定的key中。以下是一个示例代码：
```
$redis->set('my_key', 'my_value');
```
Nach dem Login kopieren
从Redis中读取数据：
可以使用get方法从Redis中读取指定的key的值。以下是一个示例代码：
```
$value = $redis->get('my_key');
echo $value; // 输出：my_value
```
Nach dem Login kopieren
存储复杂数据类型：
Redis不仅可以存储简单的字符串值，还可以存储复杂的数据类型，比如数组、对象等。我们可以使用serialize函数将复杂数据类型序列化成字符串，然后再存储到Redis中。示例代码如下：
```
$data = ['name' => 'John', 'age' => 25];
$redis->set('my_data', serialize($data));
```
Nach dem Login kopieren
在需要取回数据时，可以使用unserialize函数将存储的字符串反序列化为原始数据类型。示例代码如下：
```
$data = unserialize($redis->get('my_data'));
print_r($data); // 输出：Array ( [name] => John [age] => 25 )
```
Nach dem Login kopieren

三、实现数据的持久化存储
上面介绍的是将数据存储到Redis中，并在代码中读取出来。但是当Redis服务器关闭或重启后，数据将会丢失。为了实现数据的持久化存储，我们可以使用Redis的RDB和AOF两种机制。

RDB持久化（快照持久化）：
RDB持久化是Redis默认的持久化机制。它会根据一定的时间间隔生成快照文件，将数据以二进制格式保存到磁盘上。在Redis重新启动时，可以从快照文件中还原数据。
a) 配置RDB持久化：
打开redis.conf文件并找到以下配置：
```
save 900 1
save 300 10
save 60 10000
```
Nach dem Login kopieren
Nach dem Login kopieren
这些配置表示：在900秒之后，如果至少有1个key发生了变化，则生成一个RDB文件；在300秒之后，如果至少有10个key发生了变化，则生成一个RDB文件；在60秒之后，如果至少有10000个key发生了变化，则生成一个RDB文件。
b) 启用RDB持久化：
将以下配置项的注释符号去掉，即可启用RDB持久化：
```
save 900 1
save 300 10
save 60 10000
```
Nach dem Login kopieren
Nach dem Login kopieren
c) 保存并关闭配置文件。
d) 重启Redis服务器。
RDB持久化可以将Redis的内存数据保存到磁盘上，但是在Redis重启后，只能恢复到最后一次生成的RDB文件时的状态。
AOF持久化（追加文件持久化）：
AOF持久化会将Redis服务器收到的每个写命令追加到AOF文件的末尾。当Redis服务器重新启动时，它会重新执行AOF文件中的所有写命令，从而还原数据。
a) 配置AOF持久化：
打开redis.conf文件并找到以下配置：
```
appendonly no
appendfilename "appendonly.aof"
```
Nach dem Login kopieren
将appendonly配置项的值修改为yesrrreee

Daten in Redis speichern :
In Redis können wir die Methode set verwenden, um Daten im angegebenen Schlüssel zu speichern. Das Folgende ist ein Beispielcode:
rrreee

Daten aus Redis lesen:
Sie können die Methode get verwenden, um den Wert eines angegebenen Schlüssels aus Redis zu lesen. Das Folgende ist ein Beispielcode:

rrreee

Redis kann nicht nur einfache Zeichenfolgenwerte speichern, sondern auch komplexe Datentypen wie Arrays, Objekte usw. Mit der Funktion serialize können wir komplexe Datentypen in Strings serialisieren und diese dann in Redis speichern. Der Beispielcode lautet wie folgt:
Wenn Sie Daten abrufen müssen, können Sie die Funktion unserialize verwenden, um die gespeicherte Zeichenfolge in den ursprünglichen Datentyp zu deserialisieren. Der Beispielcode lautet wie folgt:

🎜🎜 3. Implementieren Sie die dauerhafte Speicherung von Daten 🎜Die obige Beschreibung besteht darin, Daten in Redis zu speichern und im Code auszulesen. Wenn der Redis-Server jedoch heruntergefahren oder neu gestartet wird, gehen die Daten verloren. Um eine dauerhafte Datenspeicherung zu erreichen, können wir die RDB- und AOF-Mechanismen von Redis verwenden. 🎜🎜🎜🎜RDB-Persistenz (Snapshot-Persistenz): 🎜RDB-Persistenz ist der Standard-Persistenzmechanismus von Redis. Es generiert Snapshot-Dateien basierend auf bestimmten Zeitintervallen und speichert die Daten im Binärformat auf der Festplatte. Bei einem Redis-Neustart können Daten aus der Snapshot-Datei wiederhergestellt werden. 🎜🎜a) Konfigurieren Sie die RDB-Persistenz: 🎜 Öffnen Sie die Datei redis.conf und finden Sie die folgende Konfiguration: 🎜rrreee🎜Diese Konfigurationen bedeuten: Wenn sich nach 900 Sekunden mindestens 1 Schlüssel ändert, wird nach 300 Sekunden eine RDB-Datei generiert , wenn sich mindestens 10 Schlüssel geändert haben, wird eine RDB-Datei generiert; nach 60 Sekunden wird, wenn sich mindestens 10.000 Schlüssel geändert haben, eine RDB-Datei generiert. 🎜🎜b) RDB-Persistenz aktivieren: 🎜 Entfernen Sie die Kommentarsymbole aus den folgenden Konfigurationselementen, um die RDB-Persistenz zu aktivieren: 🎜rrreee🎜c) Speichern und schließen Sie die Konfigurationsdatei. 🎜🎜d) Starten Sie den Redis-Server neu. 🎜🎜RDB-Persistenz kann Redis-Speicherdaten auf der Festplatte speichern, aber nach dem Neustart von Redis kann nur der Status der zuletzt generierten RDB-Datei wiederhergestellt werden. 🎜🎜🎜🎜AOF-Persistenz (Dateipersistenz anhängen): 🎜AOF-Persistenz hängt jeden vom Redis-Server empfangenen Schreibbefehl an das Ende der AOF-Datei an. Wenn der Redis-Server neu startet, führt er alle Schreibbefehle in der AOF-Datei erneut aus und stellt dadurch die Daten wieder her. 🎜🎜a) Konfigurieren Sie die AOF-Persistenz: 🎜 Öffnen Sie die Datei redis.conf und suchen Sie die folgende Konfiguration: 🎜rrreee🎜 Ändern Sie den Wert des Konfigurationselements appendonly zum Aktivieren in yes Es ist AOF-Persistenz. 🎜🎜b) Speichern und schließen Sie die Konfigurationsdatei. 🎜🎜c) Starten Sie den Redis-Server neu. 🎜🎜🎜🎜Fazit: 🎜In diesem Artikel wird erläutert, wie Sie mithilfe von PHP und Redis eine dauerhafte Speicherung von Daten erreichen. Durch die Konfiguration der RDB- und AOF-Persistenzmechanismen von Redis können Sie sicherstellen, dass die Daten auch nach dem Neustart des Redis-Servers weiterhin verfügbar sind. Gleichzeitig können Leser durch die Erläuterung des Beispielcodes ein klareres Verständnis für die Verwendung von PHP und Redis zur Datenspeicherung in tatsächlichen Projekten erlangen. 🎜🎜Referenzen: 🎜🎜🎜Offizielle Redis-Website: https://redis.io/🎜🎜Redis-Quellcode: https://github.com/redis/redis🎜🎜

Das obige ist der detaillierte Inhalt vonPHP und REDIS: So erreichen Sie eine dauerhafte Datenspeicherung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!