Configuration de base de données MySQL dans une classe séparée

Question

Est-il possible de conserver toutes mes configurations de base de données (noms d'hôtes, noms d'utilisateur, mots de passe et bases de données) ainsi que la fonction de connexion à une classe séparée?

J'ai essayé quelque chose comme ceci:

class Database 
{ 
    var $config = array(
     'username' => 'someuser', 
     'password' => 'somepassword', 
     'hostname' => 'some_remote_host', 
     'database' => 'a_database' 
    ); 
    function __construct() { 
     $this->connect(); 
    } 
    function connect() { 
     $db = $this->config; 
     $conn = mysql_connect($db['hostname'], $db['username'], $db['password']); 
     if(!$conn) { 
      die("Cannot connect to database server"); 
     } 
     if(!mysql_select_db($db['database'])) { 
      die("Cannot select database"); 
     } 
    } 
} 

Et puis dans une autre classe je voudrais utiliser dans les classes __construct fonction:

require_once('database.php'); 
var $db_conn = new Database(); 

Mais cela ne marche pas enregistrer la connexion, il finit par défaut de la connexion db locale des serveurs. Ou dois-je faire les commandes de base de données à chaque fois avant d'exécuter certaines commandes de base de données?

Answer 1

J'ai modifié votre classe pour travailler comme vous semblez attendre à:

<?php 
class Database 
{ 
    var $conn = null; 
    var $config = array(
     'username' => 'someuser', 
     'password' => 'somepassword', 
     'hostname' => 'some_remote_host', 
     'database' => 'a_database' 
    ); 

    function __construct() { 
     $this->connect(); 
    } 

    function connect() { 
     if (is_null($this->conn)) { 
      $db = $this->config; 
      $this->conn = mysql_connect($db['hostname'], $db['username'], $db['password']); 
      if(!$this->conn) { 
       die("Cannot connect to database server"); 
      } 
      if(!mysql_select_db($db['database'])) { 
       die("Cannot select database"); 
      } 
     } 
     return $this->conn; 
    } 
} 

Utilisation:

$db = new Database(); 
$conn = $db->connect(); 

Notez que vous pouvez appeler connect() autant de fois que vous le souhaitez et utilisera la connexion actuelle, ou en créera une si elle n'existe pas. Ceci est un bonne chose.

Notez également qu'à chaque fois que vous instanciez un objet Base de données (en utilisant new), vous allez créer une nouvelle connexion à la base de données. Je vous suggère de vous intéresser à l'implémentation de votre classe Database en tant que Singleton ou de la stocker dans un Registry pour un accès global.

Vous pouvez également le faire à la manière sale et l'enfoncer dans $ GLOBALS.

Modifier

Je pris la liberté de modifier votre classe pour mettre en œuvre le modèle Singleton, et suivez les conventions POO PHP5.

<?php 
class Database 
{ 
    protected static $_instance = null; 

    protected $_conn = null; 

    protected $_config = array(
     'username' => 'someuser', 
     'password' => 'somepassword', 
     'hostname' => 'some_remote_host', 
     'database' => 'a_database' 
    ); 

    protected function __construct() { 
    } 

    public static function getInstance() 
    { 
     if (null === self::$_instance) { 
      self::$_instance = new self(); 
     } 
     return self::$_instance; 
    } 

    public function getConnection() { 
     if (is_null($this->_conn)) { 
      $db = $this->_config; 
      $this->_conn = mysql_connect($db['hostname'], $db['username'], $db['password']); 
      if(!$this->_conn) { 
       die("Cannot connect to database server"); 
      } 
      if(!mysql_select_db($db['database'])) { 
       die("Cannot select database"); 
      } 
     } 
     return $this->_conn; 
    } 

    public function query($query) { 
     $conn = $this->getConnection(); 
     return mysql_query($query, $conn); 
    } 
} 

Utilisation:

$res = Database::getInstance()->query("SELECT * FROM foo;"); 

ou

$db = Database::getInstance(); 
$db->query("UPDATE foo"); 
$db->query("DELETE FROM foo"); 

Answer 2

Vous pouvez certainement conserver vos informations de connexion dans un fichier séparé. Enregistrez simplement votre objet de connexion - $ conn dans votre fonction connect() - dans une variable de classe. Vous pourrez ensuite le réutiliser à travers les appels.

Answer 3

Dans votre méthode connect() $ conn est uniquement une variable locale qui existe uniquement dans la portée de cette méthode. Dès que la méthode retourne, il n'y aura plus de référence (autre) à la ressource de connexion et elle sera collectée/éliminée. Vous aurez besoin d'au moins

$this->conn = mysql_connect(...) 

Answer 4

Voici le singleton par exemple AOP. Merci à @hodobave

<?php 

/** 
* DB Connection class 
* Singleton pattern 
* An single instance of DB connection is created 
**/ 

class Db{ 

    protected static $_instance = null; 
    protected $_conn; 

    protected $_config = [ 
     'username' => 'root', 
     'password' => '', 
     'hostname' => 'localhost', 
     'database' => 'news', 
    ]; 
    protected function __construct(){ 

    } 

    public function getInstance(){ 
     if(null === self::$_instance){ 
      self::$_instance = new self(); 
     } 
     return self::$_instance; 
    } 

    public function getConnection(){ 
     if(is_null($this->_conn)){ 
      //connect here 
      $db = $this->_config; 
      $dsn = "mysql:host={$db['hostname']};dbname={$db['database']}"; 
      $this->_conn = new PDO($dsn, $db['username'], $db['password']); 
     } 
     return $this->_conn; 
    } 

    public function query($sql){ 
     $args = func_get_args(); 
     array_shift($args); 
     $statement = $this->getConnection()->prepare($sql); 
     $statement->execute($args); 
     return $statement->fetchAll(PDO::FETCH_OBJ); 
    } 
} 



$res = Db::getInstance(); 
$users = $res->query("SELECT * FROM `user` WHERE id=?",1); 
print_r($users); 
?>