DB Oggetto che passa tra classi singleton, static o altro?

Singletons in PHP sono abbastanza inutili, le tue istanze vengono create quando lo script viene eseguito e muoiono quando lo script termina, indipendentemente dal fatto che siano singleton o meno. Questo è in base alla progettazione, PHP segue un non condividere l'architettura .

Continua semplicemente a fare ciò che già fai, ha persino un nome di fantasia: iniezione costruttore . Leggi l' iniezione di dipendenza e se vuoi rendere il tuo costruttore un po 'più robusto, considera tipo suggerimento :

class report {
    function __construct (array $params = array(), db $db, $user)
    {        
        ....
    }

    ...
}

Ulteriori letture:

• Quando è appropriato Singleton? (ed è dupe: The Singleton Pattern )
• Che cosa c'è di male in Singletons?
• Quando non è appropriato utilizzare il modello di iniezione dipendente?
• Quali sono i vantaggi di usando Dependency Injection e IoC Containers?
• Iniezione delle dipendenze e Singleton. Sono due concetti completamente diversi?
• Iniezione di dipendenza: come venderlo
• Differenza tra Dipendenza Iniezione (DI) e Inversione di controllo (IOC)
• Iniezione delle dipendenze: cosa appartiene al costruttore?
• SOLID, evitando domini anemici, iniezione di dipendenza?
• Metodi statici vs singleton: scegli nessuno

Vedo quello che dice Yannis Rizos, ma non è valido nel contesto dell'implementazione di un modello di progettazione in PHP. Sì, sono di breve durata e ammetto che limita l'uso di "alcuni" schemi, ma ciò non impedisce di implementarli, dopotutto sono "concetti" fatti usando un paradigma Object Oriented.

Il singleton (e altri come factory) sono utili in PHP come qualsiasi altra lingua. Singleton è in effetti uno dei più usati tra i molti modelli ed è altrettanto utile in PHP come in qualsiasi altra lingua che è ciò che mi ha confuso sulla risposta di Yannis Rizos. Quindi, per il tuo bene, ignorerei la sua ignoranza nel comprendere l'uso e lo scopo degli schemi di progettazione, specialmente in PHP, poiché ti confonderà ulteriormente.

Un singleton significa semplicemente che puoi creare sempre UNA sola istanza della classe e basta. Ha tutti i soliti benefici del modello di progettazione come in qualsiasi altra lingua (compresi quelli che vengono eseguiti per una frazione di secondo o per giorni e giorni - anche gli script PHP possono essere demonizzati e quindi possono essere eseguiti anche per giorni ).

Puoi implementarlo in questo modo (nota il costruttore privato, MOLTO importante nel prevenire più istanze e anche notare la parola chiave statica usata in tutto):

class db {

    private static $connection = null;

    /**
    * private so it can ONLY be instantiated from within itself and never created outside of the class - this gives you the control you need
    */
    private function __construct(){
        self::$connection = 'connected'; //replace with the actuall connection to the db code
    }

    /**
    * connects to db and creates instance
    */
    public static function get_instance() {

        if (self::$connection === null) {
            return new self();
        }

        return self::$connection;

    }

    /**
    * access the connection
    */
    public function query($query) {
        return mysql_query($query, self::$connection);
    }

    public function __clone() {
        trigger_error('Can not be cloned.', E_USER_ERROR);
    }

    public function __wakeup() {
        trigger_error('Can not be deserialized.', E_USER_ERROR);
    }

}

//first time used, so will create a NEW connection to the db and store it
$db = db::get_instance();
$db->query("SQL QUERY HERE");

//will NOT create a new connection, but instead use the existing one - this is the singleton pattern because you can only use a SINGLE INSTANCE of the object.
$another_connection = db::get_instance();
$db->query("fdsfdsfsd");