Avec l'expansion de l'échelle de l'entreprise, la quantité de données que la base de données doit traiter augmente également, ce qui met une seule base de données sous pression. À ce stade, nous devons effectuer des opérations de sous-base de données au niveau de la base de données pour disperser les données dans différentes bases de données, améliorant ainsi les performances et l'évolutivité du système. Cet article explique comment effectuer des opérations de partitionnement horizontal de base de données dans ThinkPHP6.
1. Qu'est-ce qu'une sous-base de données horizontale de base de données ?
Le partitionnement horizontal de base de données est le processus de dispersion des données d'une base de données dans plusieurs bases de données. Nous pouvons diviser les données en différentes bases de données selon certaines règles (telles que selon l'ID utilisateur ou la période de temps), réduisant ainsi la pression de charge sur une seule base de données. Dans le même temps, lorsque la quantité de données est importante, le partitionnement horizontal peut également améliorer l’efficacité des requêtes et renforcer la sécurité des données.
2. Implémentation d'une sous-bibliothèque horizontale dans ThinkPHP6
Dans ThinkPHP6, nous pouvons implémenter une sous-bibliothèque horizontale en utilisant un middleware de base de données. Placez le middleware de base de données dans la connexion MySQL de ThinkPHP6 pour contrôler la sous-base de données.
Dans ThinkPHP6, Thinkswoole est utilisé comme middleware de base de données. Nous devons installer Thinkswoole dans le projet.
Ajoutez les informations de version de ThinkSwoole au fichier composer.json, puis utilisez composer pour l'installer.
Recherchez d'abord le fichier config/database.php et remplacez la connexion MySQL par la connexion Swoole. Commentez les informations de connexion MySQL d'origine :
// '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,
// ],
// ],
// ],Ajoutez les informations de connexion Swoole :
// 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,
],
],
],Dans le code ci-dessus, nous avons défini deux adresses de serveur (127.0.0.1:3305 et 127.0.0.1:3306), ce qui permet d'obtenir des données multiples. La sous-bibliothèque de Node. Le nom de la base de données, le nom d'utilisateur, le mot de passe et d'autres informations restent inchangés.
Créez le middleware de base de données de Db.php dans le répertoire app/middleware et ajoutez le code suivant :
<?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'];
}
}Un middleware nommé Db est créé ici. Dans la méthode handle, obtenez d’abord le tableau d’ID de serveur de la requête en cours. Comparez ensuite ces adresses de serveur avec les adresses existantes dans le pool de connexions $cons. Si elles n'existent pas, ajoutez-les au pool de connexions. Enfin, liez le pool de connexions $conns à l'instance de conteneur. Dans la méthode getServerIds, nous pouvons définir le nom de l'ID du serveur, qui est par défaut uid.
Ajoutez le code suivant à config/middleware.php :
return [
...
appmiddlewareDb::class,
];Ce code est utilisé pour enregistrer le middleware et ajouter notre middleware Db à la liste des activités d'exécution du middleware.
Ensuite, nous implémenterons l'opération de sous-bibliothèque horizontale dans le modèle. Ici, nous prenons la table utilisateur comme exemple. L'ID utilisateur est divisé en 100 000 et 100 000 comme limite d'une base de données. Cela signifie que les données avec des ID utilisateur compris entre 0 et 100 000 sont stockées dans une base de données, et ainsi de suite, jusqu'à ce que l'ID utilisateur soit divisé en 100 000 et 100 000. L'ID utilisateur est compris entre 0 et 100 000. Les données entre 900 000 et 1 million sont stockées dans la 10ème base de données.
<?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;
}
}Ici, nous définissons 10 connexions de base de données, chaque connexion représente une partition de base de données, atteignant ainsi l'objectif de partitionnement horizontal. Ensuite, nous définissons la méthode getTableName pour obtenir le nom de la table de données correspondant au modèle actuel. Calculez la connexion à la base de données à laquelle il faut accéder en fonction de la valeur de l'ID de clé primaire dans le modèle et renvoyez la combinaison de la connexion à la base de données et du nom de la table de données.
Résumé :
Cet article présente le fonctionnement de la sous-bibliothèque horizontale dans ThinkPHP6. À mesure que l’activité continue de se développer et que l’échelle des données augmente, le partitionnement horizontal peut améliorer les performances et l’évolutivité du système, ainsi que la sécurité des données. Dans ThinkPHP6, vous pouvez utiliser le middleware Thinkswoole et d'autres méthodes pour implémenter des opérations horizontales de sous-bibliothèque.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!