Question

Je joue avec AOP depuis quelques jours, je travaille sur un petit système de gestion de contenu pour apprendre à maîtriser moi-même la programmation orientée objet, mais même s'il ne s'agit que d'un petit système de gestion de contenu, je veux qu'il puisse gérer n'importe quoi le Web peut y faire face.

C’est ce que j’ai proposé jusqu’à présent. Je vais ajouter la mise en commun des connexions au constructeur pour permettre d’importantes quantités de connexions simultanées à la demande. Je suis très nouveau dans ce domaine de la programmation orientée objet, alors je voudrais un peu de conseil et de critique, sans doute que j’ai fait quelque chose de terriblement faux ici.

J'ai pris la bonne réponse à Global ou Singleton pour la connexion à la base de données? en tant que conception de base, même si j’ai ajouté un constructeur privé, car je souhaite utiliser $ this- > dbConnectionInstance dans toute la classe, afin que de nombreuses fonctions d’aide puissent être utilisées.

Merci beaucoup pour votre temps, j'apprécierai vraiment tout conseil que vous pourrez me donner,

-Risque

// Usage Example: $dbconn = dbManager::getConnection();
//                $dbconn->query("SELECT * FROM accounts WHERE id=:id", "':id' => $id");

<?php

class dbManager {
    private static $dbManagerInstance;
    private $dbConnectionInstance;
    private $stime;
    private $etime;
    public $timespent;
    public $numqueries;
    public $queries = array();

    public static function getManager(){
        if (!self::$dbManagerInstance){
            self::$dbManagerInstance = new dbManager();
        }
        return self::$dbManagerInstance;
    }

    // Server details stored in definition file
    private function __construct($db_server=DB_SERVER, $db_user=DB_USER, $db_pass=DB_PASS, $db_params=array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8")) {
        if(!$this->dbConnectionInstance)
        {
            try{
                $this->dbConnectionInstance = new PDO($db_server, $db_user, $db_pass, $db_params);
                $this->dbConnectionInstance->setAttribute(PDO::ATTR_PERSISTENT, PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            } catch (PDOException $e) {
                $this->dbConnectionInstance = null;
                die($e->getMessage());
            }
        }
        return $this->dbConnectionInstance;
    }

    private function __destruct(){
        $this->dbConnectionInstance = null;
    }

    private function query($sql, $params = array()) {
        $this->queries[] = $sql;
        $this->numqueries++;
        $this->sTime = microtime();
        $stmt = $this->dbConnectionInstance->prepare($sql);
        $stmt->execute($params);
        $this->eTime = microtime();
        $this->timespent += round($this->eTime - $this->sTime, 4);
        return $stmt;
    }

}

?>

Merci à vous deux pour vos suggestions, j'ai maintenant ajouté la restauration et la validation dans la gestion de mes exceptions, je suis en train de faire une recherche sur l'utilisation des requêtes en mémoire tampon, je ne suis pas tout à fait sûr de ce qu'elles me donneront?

Était-ce utile?

La solution

Ça a l'air bien, j'ajouterais la fonctionnalité annuler , avec les suggestions query / errorInfo mises en tampon (Si vous utilisez un SGBDR qui prend en charge les transactions):

try {
    $this->dbConnectionInstance->beginTransaction();
    $stmt = $this->dbConnectionInstance->prepare($sql);
    $stmt->execute($params);
    $this->dbConnectionInstance->commit();
}catch(PDOException $e){
    $this->dbConnectionInstance->rollback();
}

commit () , beginTransaction ()

EDIT: ajout de liens ci-dessous pour plus d'informations sur les requêtes en mémoire tampon:

Autres conseils

Le code que vous avez dosé semble trop mauvais. Cependant, si je pouvais faire quelques petites modifications (principalement la gestion des erreurs).

Les instructions prepare et execute renverront false en cas d'erreur. et vous pouvez accéder à l'erreur à partir de $ this- > dbConnectionInstance- > errorInfo () dans votre exemple ci-dessus.

également si vous envisagez d'utiliser des requêtes volumineuses, je suggère d'utiliser une requête mise en mémoire tampon: PDO :: MYSQL_ATTR_USE_BUFFERED_QUERY = > true

semble être un bon début. Bonne chance sur votre CMS.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top