Analyse détaillée de l'implémentation PHP du pool de connexions à la base de données

Résumé

Dans le passé, le code PHP était toujours écrit selon un processus orienté script, donc dans une large mesure, il n'était ni standardisé, ni sûr, ni facile à maintenir. Afin de réutiliser le code, je prévois d'écrire un ensemble de ma propre bibliothèque d'outils, afin qu'elle puisse être facilement utilisée lors de l'écriture de projets à l'avenir.

Ce que nous allons implémenter aujourd'hui est un pool de connexions à une base de données, implémenté sous la forme d'un fichier de configuration.

xml

En tant que langage structuré hautement disponible, XML est vraiment concis et complet en tant que fichier de configuration, bien que comparé aux récents leaders de l'industrie des fichiers de configuration tels que YAML et JSON, il peut l'être. La proportion de données valides est relativement faible, mais cette redondance a sa valeur.

En gros, vous pouvez connaître ses fonctions après avoir lu les nœuds XML. C'est pourquoi les grands projets utilisent XML comme fichiers de configuration.

Le licenciement peut être toléré, mais il ne peut apporter aucune ambiguïté ni difficulté de maintenance.

En PHP, utiliser des fichiers XML sera une chose agréable, même si par rapport aux programmes Java, ce n'est pas le cas. Mais comparés au traitement Python, les programmes PHP ne sont pas si élégants.

Lire le fichier de configuration

Lire le fichier de configuration signifie en fait lire le fichier puis le conditionner. Les deux méthodes suivantes sont couramment utilisées par moi.

Méthode simple

La première fois que j'ai utilisé cette méthode simple, j'étais vraiment un peu déprimée.

$content = file_get_contents("filename.xml");
echo $content;

Par conséquent, lors de l'utilisation du navigateur pour accéder au fichier php à des fins de test, seule la partie contenu du XML était affichée, mais les informations sur le nœud n'étaient pas affichées du tout.

Ensuite, j'ai vérifié la documentation d'aide et j'ai découvert que le résultat renvoyé par cette fonction est sans aucun doute une chaîne. Ensuite, vardump l'a également prouvé. Je n'y ai donc pas beaucoup réfléchi, pensant que cette méthode pourrait filtrer automatiquement les informations TAG de la balise XML.

En guise de dernier test accidentel, j'ai ouvert le code source de la page Web et j'ai constaté que cette fonction lisait toutes les informations XML, mais qu'elles étaient automatiquement analysées par le navigateur lorsqu'elles étaient affichées sur le navigateur. Ainsi, seules les parties de contenu pertinentes peuvent être vues.

Méthode conventionnelle

La méthode conventionnelle consiste à lire le fichier étape par étape. Le reste est conforme au plan ci-dessus.

// 读取配置文件内容
            $handle = fopen("filepath", "r");            
            $content = fread($handle, filesize("filepath"));

PHP analyse XML

Les deux fichiers de lecture ci-dessus sont en fait préparés pour que PHP analyse XML. Il existe de nombreux blogs sur la manière dont PHP analyse XML. Il existe de nombreuses façons, telles que simplexml, XMLReader, DOM, etc. Mais pour les fichiers de configuration XML plus petits, simplexml suffit.

Fichier de configuration

<?xml version="1.0" encoding="UTF-8" ?><mysql>
    <!-- 为防止出现意外，请按照此标准顺序书写.其实也无所谓了 -->
    <host>localhost</host>
    <user>root</user>
    <password>123456</password>
    <db>test</db>
    <port>3306</port></mysql>

Analyse

<?php/**
 * 作为解析XML配置文件必备工具
 */class XMLUtil {
    public static $dbconfigpath = "./db.config.xml";    
    public static function getDBConfiguration() {
        $dbconfig = array ();        
        try {            
        // 读取配置文件内容
            $handle = fopen(self::$dbconfigpath, "r");            
            $content = fread($handle, filesize(self::$dbconfigpath));            
            // 获取xml文档根节点，进而获取相关的数据库信息
            $mysql = simplexml_load_string($content);            
            // 将获取到的xml节点信息赋值给关联数组，方便接下来的方法调用
            $dbconfig[&#39;host&#39;] = $mysql->host;            
            $dbconfig[&#39;user&#39;] = $mysql->user;            
            $dbconfig[&#39;password&#39;] = $mysql->password;            
            $dbconfig[&#39;db&#39;] = $mysql->db;            
            $dbconfig[&#39;port&#39;] = $mysql->port;            
            // 将配置信息以关联数组的形式返回
            return $dbconfig;
        } catch ( Exception $e ) {            
        throw new RuntimeException ( "<mark>读取数据库配置文件信息出错！</mark><br />" );
        }        return $dbconfig;
    }
}

Pool de connexions à la base de données

Pour les programmes PHP, l'optimisation ne s'arrête jamais. Le pool de connexions à la base de données joue dans une certaine mesure un rôle d’optimisation. Cela élimine le besoin de demander des ressources de lien à partir de la base de données chaque fois qu'un utilisateur fait une demande. Au lieu de cela, il est renvoyé via le lien dans le pool de connexions à la base de données existant, ce qui représente une grande amélioration en termes de temps et d'efficacité.

Voici donc une simulation simple de la mise en œuvre du pool de connexions à la base de données. L'essentiel est de maintenir une « piscine ».

Sortez-le de la piscine, utilisez-le et remettez-le dans la piscine.

<?php/**x
 *  PHP中的数据库 工具类设计
 *  郭璞
 *  2016年12月23日
 *  
 **/class DbHelper {    
 private $dbconfig;    
 private $dbpool;    
 public $poolsize;    
 public function __construct($poolsize = 20) {        
 if (! file_exists ( "./utils.php" )) {            
 throw new RuntimeException ( "<mark>utils.php文件丢失，无法进行配置文件的初始化操作！</mark><br />" );
        }else {
            require &#39;./utils.php&#39;;
        }        // 初始化 配置文件信息
        $this->dbconfig = XMLUtil::getDBConfiguration ();        
        // 准备好数据库连接池“伪队列”
        $this->poolsize = $poolsize;
        $this->dbpool = array ();        
        for($index = 1; $index <= $this->poolsize; $index ++) {
            $conn = mysqli_connect ( $this->dbconfig [&#39;host&#39;], $this->dbconfig [&#39;user&#39;], $this->dbconfig [&#39;password&#39;], $this->dbconfig [&#39;db&#39;] ) 
            or die ( "<mark>连接数据库失败！</mark><br />" );
            array_push ( $this->dbpool, $conn );
        }
    }    /**
     * 从数据库连接池中获取一个数据库链接资源
     *
     * @throws ErrorException
     * @return mixed
     */
    public function getConn() {        
    if (count ( $this->dbpool ) <= 0) {            
    throw new ErrorException ( "<mark>数据库连接池中已无链接资源，请稍后重试!</mark>" );
        } else {            
        return array_pop ( $this->dbpool );
        }
    }    /**
     * 将用完的数据库链接资源放回到数据库连接池
     *
     * @param unknown $conn            
     * @throws ErrorException
     */
    public function release($conn) {        
    if (count ( $this->dbpool ) >= $this->poolsize) {            
    throw new ErrorException ( "<mark>数据库连接池已满</mark><br />" );
        } else {
            array_push ( $this->dbpool, $conn );
        }
    }
}

Tests

Lorsqu'il y a trop de candidatures, rejeter la demande

Lorsque le nombre de connexions à la base de données demandées est inférieur à 20, le programme directement l'obtient à partir du pool de connexions à la base de données.

Lorsque la ressource de lien de base de données demandée est supérieure à la limite supérieure du pool de connexions à la base de données, elle ne sera pas fournie. et demander une exception.

Refuser de mettre en place lorsqu'il est plein

Lorsque le pool de connexions à la base de données est plein, si vous souhaitez revenir à la ressource de lien de base de données personnalisée, ce n'est pas le cas pris en charge et un message d'erreur est signalé.

Résumé

Pour résumer, cette expérience a principalement conçu et implémenté un pool de connexions à une base de données simple dans une perspective orientée objet. Il joue dans une certaine mesure un rôle dans l’optimisation du code PHP.

De plus, simplexml est simplement utilisé pour analyser les fichiers XML et effectuer des opérations courantes de lecture de fichiers.

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!