gestire connessione db oop

[gaten]

Ragazzi ho i seguenti metodi per connettermi al database:

    // costruttore
    public function __construct( $db_name, $db_user, $db_host, $db_pass ) {
        if (!$this->connect( $db_host, $db_user, $db_pass ) ) {
            echo "Failed to connect to MySQL: (" . mysql_error(). ")";
        } else {
            $this->conn = $this->connect( $db_host, $db_user, $db_pass );
            mysql_select_db($db_name, $this->conn);
            echo "Connessione eseguita con successo a ".  $db_name;
        }
    }
    
    // funzione per connettersi al database
    public function connect( $db_host, $db_user, $db_pass ) {
        if ( !mysql_connect( $db_host, $db_user, $db_pass ) ) {
            return false;
        } else {
            return mysql_connect( $db_host, $db_user, $db_pass );
        }
    } 

e nella pagina dove utilizzo il tutto ho:

$db = new Database( "db_name", "db_user", "db_host", "db_pass");
... 

Il problema è che qualora necessito di utilizzare la classe database e quindi istanziare un nuovo oggetto , devo mettere i seguenti parametri all'oggetto e inoltre, fare:

$db = new Database( "db_name", "db_user", "db_host", "db_pass");

provoca l'apertura di una connessione e mi sembra una cosa dispendiosa farla sempre, in realtà basta aprirla una volta.
Come potrei risolvere ?

[gaten]

Ovviamente il problema mi sussiste nelle altre pagine.

[Al_katraz984]

cerca informazioni sul pattern singleton...

[gaten]

Ho trovato questo e credo faccia proprio al caso mio:

http://www.phpdesignpatterns.com/des...ern-singleton/

l'unica cosa che volevo capire dal seguente esempio:

class Database
{
    // A static property to hold the single instance of the class
    private static $instance;

    // The constructor is private so that outside code cannot instantiate
    private function __construct() { }

    // All code that needs to get and instance of the class should call
    // this function like so: $db = Database::getInstance();
    public function getInstance()
    {
        // If there is no instance, create one
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
        return self::$instance;
    }

    // Block the clone method
    private function __clone() {}
}

// To use, call the static method to get the only instance
$db = Database::getInstance(); 

Dove andrò a implementare il metodo per la reale connessione al database ? Cioè quello che ho postato all'inizio ? Inoltre, in realtà l'unico problema me lo dà proprio la connessione al database mentre altri metodi tipo esecuzione di una query, oppure return del numero di righe non credo diano problemi...

[Al_katraz984]

per quanto mi riguarda io faccio cosi..

    /**
    * Initialize a database connection.
    */
    private function connect() {
        $url = parse_url( parent:: DB_URL );
........
        $connection = @mysql_connect( $url['host'], $url['user'], $url['pass'], TRUE, 2);

        if ( !$connection || !mysql_select_db( substr( $url['path'], 1) ) ) {
            // Show error screen otherwise
            throw new Exception( __CLASS__ . ': ' . mysql_error() );
        }

        // Force UTF-8.
        mysql_query( 'SET NAMES "utf8"', $connection );
        return $connection;
    }

    /**
    * @return
    *    resource, TRUE, FALSE
    */
    public function dbQuery() {
        if ( !mysql_errno( $this->connect() ) ) {
            return mysql_query( $this->query, $this->connect() );
            } else {
            $error = mysql_error( $this->connect() ) . "\nquery: " . $this->query;
            throw new Exception( __CLASS__ . ': ' . $error, 1 );
        }
    }

esempio
    /*
    * @return
    *    Un array di oggetti con tutte le righe selezionate
    */
    public function fetchObjectAll() {
        $arr = array();
        $result = $this->dbQuery();
        if ( $result ) {
            while( $obj = mysql_fetch_object( $result ) ) {
                $arr[] = $obj;
            }
            return $arr;
            } else {
            return FALSE;
        }
    } 

un metodo per la connessione (mancano parti) e un metodo per l'esecuzione della query.. l'ultimo è un esempio di metodo custom per richiamare i dati..

[gaten]

Si ma così non togli il problame che potrebbe emergere qualora tu istanzi nuovamente l'oggetto Database, perchè apriresti , inutilmente, una nuova connessione al database, è questo è inutile.

[gaten]

class Database
{
    // A static property to hold the single instance of the class
    private static $instance;
    private static $db_host = "localhost";
    private static $db_user = "root";
    private static $db_pass = "";
    private static $db_name = "my_dbname";
    private $conn;
    
    
    // The constructor is private so that outside code cannot instantiate
    private function __construct() {
        $conn = $this->connect($db_host, $db_user, $db_pass);
    }

    // All code that needs to get and instance of the class should call
    // this function like so: $db = Database::getInstance();
    public function getInstance()
    {
        // If there is no instance, create one
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
        
        return self::$instance;
    }
    
    // funzione per connettersi al database
    public function connect( $db_host, $db_user, $db_pass ) {
        if ( !mysql_connect( $db_host, $db_user, $db_pass ) ) {
            throw new Exception( __CLASS__ . ': ' . mysql_error() );
        } else {
            $conn = mysql_connect( $db_host, $db_user, $db_pass );
            mysql_select_db($db_name, $conn);
            
            return $conn;
        }
    }    

    // Block the clone method
    private function __clone() {}
}

// To use, call the static method to get the only instance
$db = Database::getInstance();

?> 

va bene così?

[gaten]

Ecco, ho provato a fare così:

<?php

class Database
{
    // A static property to hold the single instance of the class
    private static $instance;
    
    // Server dove risiede il database
    private $db_host = "localhost";
    
    // Username per accedere al database
    private $db_user = "root";
    
    // Password per accedere al database
    private $db_pass = "";
    
    // Nome del database
    private $db_name = "miodatabase";
    
    // Connessione
    private $conn;
    
    
    // Il costruttore è privato e per questo non può essere istanziato
    private function __construct( $db_host='', $db_user='', $db_pass='', $db_name='' ) {
        $this->conn = self::connect( $db_host, $db_user, $db_pass, $db_name );
    }

    // All code that needs to get and instance of the class should call
    // this function like so: $db = Database::getInstance();
    public static function getInstance()
    {
        // If there is no instance, create one
        if (!isset(self::$instance)) {
            $c = __CLASS__;
            self::$instance = new $c;
        }
        return self::$instance;
    }
    
    // Funzione per connettersi al database
    public static function connect( $db_host, $db_user, $db_pass, $db_name ) {
        if ( !mysql_connect( $db_host, $db_user, $db_pass ) ) {
            throw new Exception( __CLASS__ . ': ' . mysql_error() );
        } else {
            $conn = mysql_connect( $db_host, $db_user, $db_pass );
            mysql_select_db( $db_name, $conn );
            
            return $conn;
        }
    }    
    
    public function getConn() {
        return $this->conn;
        }
    
    // Block the clone method
    private function __clone() {}
}

// To use, call the static method to get the only instance
$db = Database::getInstance();

$db::connect("localhost", "root", "", "naplesnightlife");

$sql = "select * from admin";
$result = mysql_query($sql);

$row = mysql_fetch_array($result);

echo "<pre>";
print_r($row);
echo "</pre>";

?>

Così funziona benissimo , l'unica cosa anomala è che se non faccio:

$db::connect("localhost", "root", "", "miodatabase"); 

non mi connette il database, ma a questo punto come posso connettermi al database appena faccio:
$db = Database::getInstance(); ?? Credo debba funzionare così oppure no?

[Al_katraz984]

Ciao

    // Il costruttore è privato e per questo non può essere istanziato
    private function __construct( $db_host='', $db_user='', $db_pass='', $db_name='' ) {
        $this->conn = self::connect( $db_host, $db_user, $db_pass, $db_name );
    } 

questo non ha molto senso.. se il metodo è privato non puoi istanziare la classe nel modo tradizionale e i parametri come li passi?

e il metodo di connessione perchè lo metti "static"?

[codencode]

Il costruttore è privato perchè deve poter essere istanziato solo dall'interno della classe stessa, è il principio del Design Pattern Singleton:
http://www.html.it/articoli/design-p...p-singleton-1/

Il problema è che per come è stato fatto il codice, manca il riferimento agli attributi della classe nel costruttore, infatti si potrebbe fare in questo modo:

private function __construct( ) { 
        $this->conn = self::connect( $this->db_host, $this->db_user, $this->db_pass, $this->db_name ); 
    } 

Così facendo da qualsiasi parte dell'applicazione si può richiamare

Database::getInstance() 

in tal modo non occorre passare i parametri e solo la prima volta verrà creata la connessione, dalla seconda volta in poi l'attributo $instance sarà valorizzato e quindi non verrà aperta una nuova connessione.

Ovviamente la classe può essere ampliata con altri metodi, esempio eseguiQuery()

public function eseguiQuery($sql) { 
       return mysql_query($sql,$this->conn);
} 

E' quindi semplice capire che si potrà eseguire una query in questo modo:

Database::getInstance()->eseguiQuery("SELECT bla bla bla") 

Allo stesso modo si potranno aggiungere metodi per il numero di record selezionati, eliminati, per l'ultimo id inserito e così via.

I personalmente per passare i parametri utilizzo delle costanti, ovvero ho il mio file dove specifico i parametri di connessione sotto forma di costanti, es:

define('DB_HOST,"localhost"); 

e nella classe faccio riferimento a queste;
cioè nel getInstance():

self::$instance = new $c(DB_HOST, DB_USER...); 

quindi il metodo costruttore torna ad avere i parametri:

private function __construct( $db_host='', $db_user='', $db_pass='', $db_name='' ) { 
        $this->conn = self::connect( $db_host, $db_user, $db_pass, $db_name ); 
    } 

ed ovviamente andranno tolti gli attributi dalla classe perchè non più utilizzati

 // Server dove risiede il database 
    private $db_host = "localhost"; 
     
    // Username per accedere al database 
    private $db_user = "root"; 
     
    // Password per accedere al database 
    private $db_pass = ""; 
     
    // Nome del database 
    private $db_name = "miodatabase";