OOP structure php5

Question

J'ai essayé de faire du code OOP PHP5. Mais je pense que mes tentatives sont maladroites. Ce sont mes questions:

• Est-ce que c'est une meilleure, plus maigre façon d'inclure des informations de configuration de base de données? Puis-je d'une manière ou d'une autre avoir à déclarer $ db = new Db() dans chaque fonction que je crée?
• Devrais-je utiliser PEAR comme couche d'abstraction de base de données au lieu de Mysqli_database.php?

Mysqli_database.php

<?php 
class Db { 
    private $connection; 

    private function open_connection() { 
     if (file_exists('config.inc.php')) { 
      require('config.inc.php'); 
     } else { 
      require('../config.inc.php'); 
     } 
     try 
     { 
      $this->connection = mysqli_connect($dbhost,$dbuser,$dbpass,$dbname); 
     } 
     catch (Exception $e) 
     { 
      throw $e; 
     } 
    } 
    private function close_connection() { 
     try 
     { 
      mysqli_close($this->connection); 
     } 
     catch (Exception $e) 
     { 
      throw $e; 
     } 
    } 
    public function query($query) { 
     try 
     { 
      $this->open_connection(); 
      $result = mysqli_query($this->connection,$query); 
      return $result; 
     } 
     catch (Exception $e) 
     { 
      throw $e; 
     } 
     $this->close_connection(); 
    } 
    public function fetchArray($query) { 
     $row = mysqli_fetch_assoc($query); 
     return $row; 
    } 
    public function count_rows($query) { 
     $row = mysqli_num_rows($query); 
     return $row; 
    } 
    public function rows_affected() { 
     $row = mysqli_affected_rows($this->connection); 
     return $row; 
    } 
    public function created_id() { 
     $row = mysqli_insert_id($this->connection); 
     return $row; 
    } 
} 
?> 

Test_data.php

<?php 
class Test_data { 
    public function show_text() { 
     $db = new Db(); 
     $sql = $db->query("SELECT * FROM test_table"); 
     $row = $db->fetchArray($sql); 
     echo 'This is the output: '.$row['text']; 
    } 
} 
?> 

config.inc.php

<?php 
$dbname  = 'database_name'; 
$dbhost  = 'localhost'; 
$dbuser  = 'database_user'; 
$dbpass  = 'database_password'; 
?> 

includes.php

<?php 
require_once('config.inc.php'); 
require_once('Mysqli_database.php'); 
$db = new Db(); 
$test_data = new Test_data(); 
?> 

index.php

<?php 
require_once('includes.php'); 
$test_data->show_text(); 
?> 

Answer 1

Les informations de configuration est une question de goût. Mais il serait mieux stocké dans un objet de configuration, et récupéré de manière plus OO, y compris les variables globales d'un autre fichier.

Vous pouvez contourner la création d'un nouvel objet en utilisant le singleton pattern. Le calque le plus abstrait que vous choisissez, plus il sera facile de passer d'une base de données à l'autre. Vous pouvez également jeter un oeil à PDO.

Answer 2

Il existe des modèles très courants pour établir des connexions de base de données: Singleton, Factory et parfois Registry.

Voici comment on pourrait regarder.

<?php 

class DbConn 
{ 
    const CONN_DEV_1 = 'dev.db1'; 
    const CONN_PROD_1 = 'prod.db1'; 
    const CONN_DEV_2 = 'dev.db2'; 
    const CONN_PROD_2 = 'prod.db2'; 

    protected static $instances = array(); 

    protected $conn; 

    public static function factory($database, $env) 
    { 
    $connectionName = "$env.$database"; 
    if (!isset(self::$instances[$connectionName])) 
    { 
     switch ($connectionName) 
     { 
     case self::CONN_DEV_1: 
      $dbname = 'dev1'; 
      $dbhost = 'localhost'; 
      $dbuser = 'database_user'; 
      $dbpass = 'database_password'; 
      break; 
     case self::CONN_PROD_1: 
      $dbname = 'prod1'; 
      $dbhost = 'some.server'; 
      $dbuser = 'database_user'; 
      $dbpass = 'database_password'; 
      break; 
     case self::CONN_DEV_2: 
      $dbname = 'dev2'; 
      $dbhost = 'localhost'; 
      $dbuser = 'database_user'; 
      $dbpass = 'database_password'; 
      break; 
     case self::CONN_PROD_2: 
      $dbname = 'prod2'; 
      $dbhost = 'some.server'; 
      $dbuser = 'database_user'; 
      $dbpass = 'database_password'; 
      break; 
     default: 
      throw new Exception('Unrecognized database connection!'); 
     } 
     self::$instances[$connectionName] = new self($dbhost,$dbuser,$dbpass,$dbname); 
    } 
    return self::$instances[$connectionName]; 
    } 

    private function __construct($dbhost, $dbuser, $dbpass, $dbname) 
    { 
    $this->conn = mysqli_connect($dbhost, $dbuser, $dbpass, $dbname); 
    } 

    /* all your other methods here */ 
} 

et utilisation

$db1 = DbConn::factory('db1', 'dev'); 

Il est évident que le point est là pour tirer la valeur $env de la configuration de l'application en cours, où que viennent. Maintenant, en termes d'utilisation, généralement vous voulez passer/hand/functions/classes une connexion de base de données, et ne pas les rendre responsables de l'établissement de la connexion eux-mêmes. ceci fournit un couplage plus lâche. Pour utiliser votre exemple:

<?php 
class Test_data 
{ 
    protected $db; 

    public function __construct(DbConn $db) 
    { 
     $this->db = $db; 
    } 

    public function show_text() 
    { 
     $sql = $this->db->query("SELECT * FROM test_table"); 
     $row = $this->db->fetchArray($sql); 
     echo 'This is the output: '.$row['text']; 
    } 
} 
?> 

Answer 3

En ce qui concerne la capture d'une instance dans chaque fonction, un objet DB comme celui-ci est l'exemple de fait donné pour le modèle Singleton. Cela correspond vraiment bien ici.

Voici un exemple grossier:

class DB 
{ 

    // Private Constructor so external code cannot directly instantiate 
    private function __construct() { 

    } 

    public static function instance() { 
    static $instance = false; 

    if (!$instance) 
     $instance = new DB(); 

    return $instance; 

    } 

} 

Et une petite variation, si vous voulez avoir plusieurs connexions DB ouvert (à différentes bases de données) serait une méthode d'instance comme ceci:

public static function instance($dsn) { 
    static $instances = array(); 

    if (!isset($instances[$dsn])) 
     $instances[$dsn] = new DB($dsn); 

    return $instances[$dsn]; 

}