Come gestite le connessioni del database in PHP?

Question

Quindi di recente ho iniziato a utilizzare attivamente php e ho bisogno di alcune informazioni su diversi modi per utilizzare le connessioni al database.

In un primo momento ho solo usato il semplice mysql_connect():

<?php 
    $connection = mysql_connect(DB_HOST, DB_USER, DB_PASS) or die(mysql_error()); 
    mysql_select_db(DB_DB, $connection); 
?> 

Dopo un po 'ho creato una classe base di dati che ho iniziato a includere e inizializzare in ogni file - qualcosa di simile:

<?php 
class MySQL_DB { 

var $connection; 

function MySQL_DB(){ 
    $this->connection = mysql_connect(DB_HOST, DB_USER, DB_PASS) or die(mysql_error()); 
    mysql_select_db(DB_DB, $this->connection); 
} 

function query($q){ 
    $res = mysql_query($q, $this->connection) or die(mysql_error()); 
    return $res; 
} 
} 

$database = New MySQL_DB; 
?> 

E questo è quello che sto usando in quel momento - e sta funzionando bene - ma ci sono sempre dei modi per migliorare.

Quindi la mia domanda è come gestite le connessioni del database?

• Usi le lezioni?
• Cosa contengono le classi (solo la connessione o anche le funzioni?)
• Quali pratiche consigliate?

Answer 1

L'utilizzo delle classi è la strada da percorrere per aumentare la riutilizzabilità personalizzata.

Inserire tutte le implementazioni generiche nella classe. Sei sulla strada giusta.

This website has the following clean approach .

class connection { 
    // Possible Modules are as follows: 
    // DBX_MYSQL, DBX_ODBC, DBX_PGSQL, DBX_MSSQL, DBX_FBSQL, DBX_SYBASECT, DBX_OCI8, DBX_SQLITE 
    private $module = DBX_MYSQL; 

    private $host = "localhost"; 
    private $database = "test"; 
    private $username = "testuser"; 
    private $password = "testpass"; 

    private $link; 
    private $result; 
    public $sql; 

    function __construct($database=""){ 
      if (!empty($database)){ $this->database = $database; } 
      $this->link = dbx_connect($this->module,$this->host,$this->database,$this->username,$this->password); 
      return $this->link; // returns false if connection could not be made. 
    } 

    function query($sql){ 
      if (!empty($sql)){ 
        $this->sql = $sql; 
        $this->result = dbx_query($this->link,$sql,DBX_RESULT_UNBUFFERED); 
        return $this->result; 
      }else{ 
        return false; 
      } 
    } 

    function fetch($result=""){ 
      if (empty($result)){ $result = $this->result; } 
      return dbx_fetch_row($result); 
    } 

    function __destruct(){ 
      dbx_close($this->link); 
    } 
} 

Answer 2

Si consiglia di utilizzare PDO. Non reinventare il weel. È una bella interfaccia OO per many database engines. Inoltre creo una piccola funzione che inizializza solo l'oggetto PDO. Quindi tutte le impostazioni di connessione possono essere modificate in un unico posto.

Answer 3

Il tuo attuale approccio è abbastanza standard, e funziona bene. L'ho usato per molto tempo. È vero che i moduli come PDO forniscono funzionalità di base come questa ora, che è molto bella e può farti allontanare dai problemi con il codice home-brew.

Tuttavia, ho preso la gestione della connessione un ulteriore passo avanti. Se entri in un'applicazione complessa, potresti trovarti in una situazione in cui hai più database o un uso intensivo del database. L'inclusione di un singolo file di connessione al database e la presenza di una variabile globale $database diventano ingombranti per più database e non è necessario per le richieste di applicazione che potrebbero non richiedere una connessione al database. Ricorda, la connessione al database è costosa.

Quello che ho fatto è creare una classe DatabaseManager singleton che gestisca l'oggetto database per me, e si assicura che più connessioni a un determinato DB non vengano istanziate. Invece di inizializzare un nuovo oggetto di database nella parte superiore della tua app, devi semplicemente chiamare su DatabaseManager ogni volta che ti serve l'oggetto.

$db = DatabaseManager::getDatabase(); 

Ecco un esempio di classe che avevo preparato per un progetto CodeIgniter. Puoi vedere nella funzione getDatabase() che carica semplicemente l'oggetto di database predefinito di CodeIgniter, che sostituiresti per la tua classe (ed eseguirai la routine di connessione per esso) se non stavi usando CI.Questa è una classe di gestione piuttosto semplicistica e potrebbe essere estesa per gestire più connessioni a database diversi abbastanza facilmente.

<?php 

/** 
* Implements the Singleton pattern to prevent multiple instantiations and connections 
* to the application database. 
* 
*/ 
class Database_manager 
{ 
    private static $instance; 
    public $db; 

    /** 
    * Constructor function is declared private to prevent instantiation. 
    * 
    */ 
    protected function __construct() 
    { 
     parent::__construct(); 
    } 

    /** 
    * Returns an instance of a Database_manager. 
    * 
    * @return object Database_manager object 
    */ 
    public static function getInstance() 
    { 
     if (self::$instance == null) { 
      $className = __CLASS__; 
      self::$instance = new $className(); 
     } 
     return self::$instance; 
    } 

    public static function getDatabase() 
    { 
     $instance = self::getInstance(); 
     if ($instance->db == null) { 
      //utilize CodeIgniter's database loader 
      $instance->db = $instance->load->database('',true); 
      if (! is_object($instance->db)) throw new Exception("Could not load database."); 
     } 
     return $instance->db; 
    } 
} 

Forse il vantaggio più comune esco di usare questo stile di gestione delle connessioni è quando devo prendere giù una richiesta di manutenzione del database. Non istanziando una connessione al database finché non ne ho bisogno, posso facilmente pubblicare un messaggio di "manutenzione in corso" su un sito (cortocircuitando il normale invio MVC) e non preoccuparmi delle richieste all'applicazione che aprono una connessione DB mentre è in corso la manutenzione progresso.

Answer 4

Nell'esempio del gestore database, non è stato definito un genitore per la classe. Pertanto, il richiamo di parent :: __ constructor() produce un'eccezione, e, inoltre, non è possibile utilizzare la proprietà load di Code Ignitor.

Quale classe hai utilizzato come estensione per il tuo DatabaseManager?

Poiché non so dove hai inserito il codice del tuo database, né quale classe hai usato come suo genitore, ho aggirato le eccezioni facendo in modo che il metodo getDatabase() riceva un parametro di input che ho chiamato $ loader. Normalmente, questo oggetto $ loader sarà la classe del modello che richiede l'accesso a un database.

public static function getDatabase($loader) 
{ 
    $instance = self::getInstance(); 
    if ($instance->db == null) { 
      //utilize CodeIgniter's database loader 
      $instance->db = $loader->load->database('default',true); 
      if (! is_object($instance->db)) throw new Exception("Could not load database."); 
    } 
    return $instance->db; 
} 

Cordiali saluti.