Heim > Artikel > PHP-Framework > Wie führt man in ThinkPHP6 eine horizontale Unterdatenbankoperation einer Datenbank durch?
Mit der Ausweitung des Unternehmensumfangs nimmt auch die Datenmenge zu, die die Datenbank verarbeiten muss, was dazu führt, dass eine einzelne Datenbank unter Druck gerät. Zu diesem Zeitpunkt müssen wir Unterdatenbankoperationen auf Datenbankebene durchführen, um die Daten auf verschiedene Datenbanken zu verteilen und dadurch die Leistung und Skalierbarkeit des Systems zu verbessern. In diesem Artikel wird erläutert, wie Sie horizontale Datenbank-Sharding-Vorgänge in ThinkPHP6 durchführen.
1. Was ist eine horizontale Unterdatenbank?
Horizontales Datenbank-Sharding ist der Prozess der Verteilung von Daten in einer Datenbank auf mehrere Datenbanken. Wir können die Daten nach bestimmten Regeln (z. B. nach Benutzer-ID oder Zeitraum) in verschiedene Datenbanken aufteilen und so den Lastdruck auf eine einzelne Datenbank verringern. Gleichzeitig kann horizontales Sharding bei großen Datenmengen auch die Abfrageeffizienz verbessern und die Datensicherheit erhöhen.
2. Implementierung einer horizontalen Unterbibliothek in ThinkPHP6
In ThinkPHP6 können wir eine horizontale Unterbibliothek mithilfe von Datenbank-Middleware implementieren. Platzieren Sie die Datenbank-Middleware in der MySQL-Verbindung von ThinkPHP6, um die Unterdatenbank zu steuern.
In ThinkPHP6 wird Thinkswoole als Datenbank-Middleware verwendet. Wir müssen Thinkswoole im Projekt installieren.
Fügen Sie ThinkSwoole-Versionsinformationen zur Datei „composer.json“ hinzu und installieren Sie sie dann mit Composer.
Suchen Sie zunächst die Datei config/database.php und ersetzen Sie die MySQL-Verbindung durch die Swoole-Verbindung. Kommentieren Sie die ursprünglichen MySQL-Verbindungsinformationen aus:
// 'mysql' => [
// // 默认数据连接标识
// 'default' => env('database.driver', 'mysql'),
// // 数据库连接信息
// 'connections' => [
// 'mysql' => [
// // 数据库类型
// 'type' => 'mysql',
// // 主机地址
// 'host' => env('database.hostname', '127.0.0.1'),
// // 数据库名
// 'database' => env('database.database', ''),
// // 用户名
// 'username' => env('database.username', 'root'),
// // 密码
// 'password' => env('database.password', ''),
// // 端口
// 'hostport' => env('database.hostport', '3306'),
// // 数据库连接参数
// 'params' => [],
// // 数据库编码默认采用utf8
// 'charset' => 'utf8',
// // 数据库表前缀
// 'prefix' => env('database.prefix', ''),
// // 数据库调试模式
// 'debug' => env('database.debug', true),
// // 数据库部署方式:0 集中式(单一服务器),1 分布式(主从服务器)
// 'deploy' => 0,
// // 数据库读写是否分离 主从式有效
// 'rw_separate' => false,
// // 读写分离后 主服务器数量
// 'master_num' => 1,
// // 指定从服务器序号
// 'slave_no' => '',
// // 是否严格检查字段是否存在
// 'fields_strict' => true,
// // 数据集返回类型
// 'resultset_type' => 'array',
// // 自动写入时间戳字段
// 'auto_timestamp' => false,
// // 时间字段取出后的默认时间格式
// 'datetime_format' => false,
// // Builder类
// 'builder' => '',
// // Query类
// 'query' => '\think\db\Query',
// // 是否需要进行SQL性能分析
// 'sql_explain' => false,
// ],
// ],
// ],Swoole-Verbindungsinformationen hinzufügen:
// swoole
'swoole' => [
// 默认数据连接标识
'default' => 'swoole',
// 数据库连接信息
'connections' => [
'swoole' => [
// 数据库类型
'type' => 'mysql',
// 服务器地址
'hostname' => [
'127.0.0.1:3305',
'127.0.0.1:3306',
],
// 数据库名
'database' => 'test',
// 用户名
'username' => 'root',
// 密码
'password' => '',
// 端口
'hostport' => '',
// 数据库连接参数
'params' => [],
// 数据库编码默认采用utf8mb4
'charset' => 'utf8mb4',
// 数据库表前缀
'prefix' => '',
// 数据库调试模式
'debug' => true,
// 数据库部署方式:0 集中式(单一服务器),1 分布式(主从服务器)
'deploy' => 0,
// 数据库读写是否分离 主从式有效
'rw_separate' => false,
// 读写分离后 主服务器数量
'master_num' => 1,
// 指定从服务器序号
'slave_no' => '',
// 自动写入时间戳字段
'auto_timestamp' => false,
// 时间字段取出后的默认时间格式
'datetime_format' => 'Y-m-d H:i:s',
// Builder类
'builder' => '',
// Query类
'query' => '\think\db\Query',
// 是否需要进行SQL性能分析
'sql_explain' => false,
],
],
],Im obigen Code haben wir zwei Serveradressen definiert (127.0.0.1:3305 und 127.0.0.1:3306), um mehrere Daten zu erreichen Unterbibliothek des Knotens. Datenbankname, Benutzername, Passwort und andere Informationen bleiben unverändert.
Erstellen Sie die Datenbank-Middleware von Db.php im Verzeichnis app/middleware und fügen Sie den folgenden Code hinzu:
<?php
namespace appmiddleware;
use thinkRequest;
use thinkContainer;
class Db
{
public function handle(Request $request, Closure $next)
{
$serverIds = $this->getServerIds($request);
//定义一个连接池
$conns = [];
foreach($serverIds as $sid) {
$sid = $request->$sid;
if(empty($conns[$sid])) {
$conns[$sid] = Container::getInstance()
->make('db')->connect($sid);
}
}
Container::getInstance()->bind('db', function() use ($conns) {
return $conns;
});
return $next($request);
}
protected function getServerIds(Request $request)
{
return ['uid'];
}
}Hier wird eine Middleware mit dem Namen Db erstellt. Rufen Sie in der Handle-Methode zunächst das Server-ID-Array der aktuellen Anforderung ab. Vergleichen Sie dann diese Serveradressen mit den vorhandenen Adressen im Verbindungspool $cons. Wenn sie nicht vorhanden sind, fügen Sie sie dem Verbindungspool hinzu. Binden Sie abschließend den Verbindungspool $conns an die Containerinstanz. In der getServerIds-Methode können wir den Namen der Server-ID festlegen, der standardmäßig uid ist.
Fügen Sie den folgenden Code zu config/middleware.php hinzu:
return [
...
appmiddlewareDb::class,
];Dieser Code wird verwendet, um Middleware zu registrieren und unsere DB-Middleware zur Middleware-Ausführungsaktivitätsliste hinzuzufügen.
Als nächstes werden wir den horizontalen Unterbibliotheksbetrieb im Modell implementieren. Hier nehmen wir als Beispiel die Benutzer-ID, die als Grenze einer Datenbank in 100.000 und 100.000 unterteilt ist. Das bedeutet, dass Daten mit Benutzer-IDs zwischen 0 und 100.000 in einer Datenbank gespeichert werden, und so weiter, bis der Benutzer In der 10. Datenbank sind Daten zwischen 900.000 und 1 Million gespeichert.
<?php
namespace appmodel;
use thinkModel;
class User extends Model
{
protected $connection = [
1 => 'user_1',
2 => 'user_2',
3 => 'user_3',
4 => 'user_4',
5 => 'user_5',
6 => 'user_6',
7 => 'user_7',
8 => 'user_8',
9 => 'user_9',
10 => 'user_10',
];
protected $pk = 'uid';
public function getTableName(): string
{
$id = ceil($this->id / 100000);
return $this->connection[$id] . '.' . $this->table;
}
}Hier definieren wir 10 Datenbankverbindungen. Jede Verbindung stellt einen Datenbank-Shard dar und erreicht so den Zweck des horizontalen Shardings. Anschließend definieren wir die Methode getTableName, um den Datentabellennamen zu erhalten, der dem aktuellen Modell entspricht. Berechnen Sie die Datenbankverbindung, auf die zugegriffen werden muss, basierend auf dem Primärschlüssel-ID-Wert im Modell und geben Sie die Kombination aus Datenbankverbindung und Datentabellennamen zurück.
Zusammenfassung:
Dieser Artikel stellt den horizontalen Unterbibliotheksbetrieb in ThinkPHP6 vor. Da das Geschäft weiter wächst und der Datenumfang zunimmt, kann horizontales Sharding die Systemleistung und Skalierbarkeit sowie die Datensicherheit verbessern. In ThinkPHP6 können Sie Thinkswoole-Middleware und andere Methoden verwenden, um horizontale Unterbibliotheksoperationen zu implementieren.
Das obige ist der detaillierte Inhalt vonWie führt man in ThinkPHP6 eine horizontale Unterdatenbankoperation einer Datenbank durch?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!