Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 19
  1. #1

    Design Pattern Singleton

    Buongiorno. Sono un nuovo utente e da non molto tempo mi sono avvicinato alla programmazione
    OOP in php (programmazione che non conoscevo in nessun altro linguaggio). Sto sviluppando un
    progetto didattico per la mia scuola e avrei necessità di implementare una classe Singleton
    da utilizzare come classe padre ogni volta che ne ho bisogno.

    Avrei elaborato una soluzione che, almeno in apparenza, sembra corretta ma quando vado a provarla
    semplicemente non mi visualizza niente.

    Questa soluzione utilizza un interfaccia molto semplicemente perchè sono fresco di studi e mi piace seguire
    le regole mentre la scelta di implementare la classe Singleton come astratta è dovuta al fatto che effettivamente
    non dovrà mai essere creata una sua istanza.

    file: interface.ISingleton.php
    Codice PHP:
    <?php

    // Implementazione dell'interfaccia
    interface ISingleton 
    {

        final public static function 
    getInstance();
        public function 
    destroyInstance();
        
    }

    ?>
    file: abstract.Singleton.php
    Codice PHP:
    <?
    require_once 'interface.ISingleton.php';

    abstract 
    Singleton implements ISingleton
    {

        
    /**
         * Contiene l'istanza
         *
         * @var array
         *
         */
        
    private static $_instanceOfClass;
        
        
    /**
         *
         * Costruttore protetto
         *
         */
        
    protected function __construct()
        {
        
        }
        
        
    /**
         * 
         * Impedisco la clonazione del Singleton
         *
         */
        
    public function __clone()
        {
        
            
    trigger_error 'La clonazione di un oggetto Singleton non è abilitata'E_USER_ERROR );
            
        }
        
        
    /**
         *
         * Metodo Singleton
         *
         * @return L'istanza del oggetto
         *
         */
        
    public static function getInstance()
        {
        
            if ( !isset ( 
    self::$_instanceOfClassget_called_class() ]))
            {
                    
                
    $c get_called_class();
                
    self::$_instanceOfClass = new $c;
                
            }
            
            return 
    self::$_instanceOfClass;
            
        }
        
        
    /**
         * 
         * Distruggo il Singleton quando non mi serve più
         *
         */
        
    public function destroyInstance()
        {
        
            unset ( 
    self::$instanceOfClassget_class($this) ]);
            
        } 
        
        
    /**
         *
         * Distruttore
         *
         */
        
    public function __destruct()
        {
        
            unset ( 
    self::$_instanceOfClass );
            
        }
        
    }
    ?>
    file: class.ClasseFiglia.php
    Codice PHP:
    <?

    require_once 'abstract.Singleton.php';

    // Classe fittizia di prova
    class ClasseFiglia extends Singleton
    {

        
    // Variabili membro
        /** ............................. */
        
        // Costruttore
        
    protected function __construct()
        {
        
            
    /** ... implementazione ... */
            
        

        
        
    // Metodo di prova
        
    public function sayHello()
        {
        
            echo 
    "Ciao Mondo!";
            
        }
        
    }

    // Utilizzo
    // Creo l'istanza della classe ClasseFiglia se già non esistente
    $classeFiglia ClasseFiglia::getInstance();
    // Uso il metodo della classe figlia
    $classeFiglia->sayHello();

    ?>
    Qualche suggerimento ?

    Grazie per le risposte

  2. #2
    a volte usi $_instanceOfClass come un puntatore, a volte come un array di puntatori... quindi devi intanto risolvere questo metodo

    if ( !isset ( self::$_instanceOfClass[ get_called_class() ]))
    {
    $c = get_called_class();
    self::$_instanceOfClass = new $c;
    }

    return self::$_instanceOfClass;

    in più a volte l'attributo statico $instanceOfClass è chiamato $_instanceOfClass

  3. #3
    1) a mio avviso l'uso dell'interfaccia è inutile

    2) è inutile di conseguenza la classe base astratta. Anche perchè costringi le tue classi singleton ad estendere una classe, quindi ti precludi il fatto che non possano più estenderne altre, da cui tanti problemi

    3) se è singleton è singleton, $_instanceOfClass non deve essere trattata come un array quindi scrivere _instanceOfClass[ .. ] è sbagliato, self::$_instanceOfClass[ get_called_class() ] anche è sbagliato

    Codice PHP:


    class ClasseFiglia{

    private static 
    $_instance=null;

    private function 
    __construct(){ } //col costruttore privato non può essere istanziata fuori dalla classe

    public static function getInstance(){

    if(!
    self::$_instance)
      
    self::$_instance = new self();

    return 
    self::$_instance;

    }

    public function 
    sayHello(){

    echo 
    "hello world";

    }


    da cui l'utilizzo

    Codice PHP:

    $c 
    ClasseFiglia::getInstance();

    $c->sayHello(); 
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  4. #4
    Originariamente inviato da Santino83_02
    1) a mio avviso l'uso dell'interfaccia è inutile

    2) è inutile di conseguenza la classe base astratta. Anche perchè costringi le tue classi singleton ad estendere una classe, quindi ti precludi il fatto che non possano più estenderne altre, da cui tanti problemi
    Fammi capire la relazione.

    Se ho una classe che eredita da una astratta che problema c'è ? al massimo dovrà mettere i metodi della classe astratta pur senza implementarli. Ma non viene certo preclusa la possibilità di ereditare.

    Originariamente inviato da Santino83_02
    3) se è singleton è singleton, $_instanceOfClass non deve essere trattata come un array quindi scrivere _instanceOfClass[ .. ] è sbagliato, self::$_instanceOfClass[ get_called_class() ] anche è sbagliato

    Codice PHP:


    class ClasseFiglia{

    private static 
    $_instance=null;

    private function 
    __construct(){ } //col costruttore privato non può essere istanziata fuori dalla classe

    public static function getInstance(){

    if(!
    self::$_instance)
      
    self::$_instance = new self();

    return 
    self::$_instance;

    }

    public function 
    sayHello(){

    echo 
    "hello world";

    }


    da cui l'utilizzo

    Codice PHP:

    $c 
    ClasseFiglia::getInstance();

    $c->sayHello(); 
    Ma se devi scrivere un codice come questo non fai prima ad abbandonare la programmazione OOP per tornare a quella procedurale ?
    Poniamo che ho 10 classi singleton. Cosa devo replicare il pattern 10 volte ? E se per caso devo fare una modifica cosa devo ripeterla 10 volte con il rischio di dimenticarmene una ?

    Sul serio non capisco. Se la logica della programmazione OOP è quella di avere del codice modulare e scalabile non riesco a capire il nesso nel dover codificare rigidamente delle istruzioni dentro a un metodo
    replicandolo tot volte.

  5. #5
    Originariamente inviato da GiovanniPini
    Se ho una classe che eredita da una astratta che problema c'è ? al massimo dovrà mettere i metodi della classe astratta pur senza implementarli. Ma non viene certo preclusa la possibilità di ereditare.
    Se la tua classe estende la classe astratta, allora non puo' ereditare da altre. In PHP non esiste ereditarieta' multipla.

    Originariamente inviato da GiovanniPini
    Ma se devi scrivere un codice come questo non fai prima ad abbandonare la programmazione OOP per tornare a quella procedurale ?
    Poniamo che ho 10 classi singleton. Cosa devo replicare il pattern 10 volte ? E se per caso devo fare una modifica cosa devo ripeterla 10 volte con il rischio di dimenticarmene una ?

    Sul serio non capisco. Se la logica della programmazione OOP è quella di avere del codice modulare e scalabile non riesco a capire il nesso nel dover codificare rigidamente delle istruzioni dentro a un metodo
    replicandolo tot volte.
    Non ho capito cosa intendi.

  6. #6
    Originariamente inviato da k.b
    Se la tua classe estende la classe astratta, allora non puo' ereditare da altre. In PHP non esiste ereditarieta' multipla.
    O cappero è vero ... come non detto ... mi ero scordato di questa cosa ... di conseguenza ho detto una boiata convinto di una cosa diversa.

    Pardon

  7. #7
    Originariamente inviato da GiovanniPini Ma se devi scrivere un codice come questo non fai prima ad abbandonare la programmazione OOP per tornare a quella procedurale ?
    Poniamo che ho 10 classi singleton. Cosa devo replicare il pattern 10 volte ? E se per caso devo fare una modifica cosa devo ripeterla 10 volte con il rischio di dimenticarmene una ?

    Sul serio non capisco. Se la logica della programmazione OOP è quella di avere del codice modulare e scalabile non riesco a capire il nesso nel dover codificare rigidamente delle istruzioni dentro a un metodo
    replicandolo tot volte.
    Se hai 10 singleton usa un'unica classe per ottenere l'istanza se non vuoi ripetere il codice nelle altre classi... che ne so, una Factory di qualche tipo, un classRegistry di qualche tipo...
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  8. #8
    Se hai 10 singleton simili, forse il singleton non e' il pattern piu' adatto

  9. #9
    http://webreflection.blogspot.com/20...leton-and.html
    che associa come diceva Santino factory + singleton

    Without faith, nothing is possible. With it, nothing is impossible
    http://ilwebdifabio.it

  10. #10
    quel link sinceramente mi pare un pò... boh... mi pare che l'autore contraddica se stesso...

    cioè praticamente lui presenta, un pò come l'autore di questo 3D, l'idea di richiamare qualsiasi tipo di classe come una singleton senza dover implementarne la logica nella classe stessa... piccolo problema alla logica: se la classe non ha il costruttore privato/protetto, tu puoi istanziarla dove ti pare e come ti pare, e ti va a quel paese la logica del Singleton...

    Immaginiamo di fare un framework e di creare una serie di classi singleton perchè utilizzate in maniera coordinata in molte parti di esso. Se io posso instanziare a mio piacimento le classi, posso incorrere in errori come creare una nuova istanza di quella classe e lavorare con essa (causando errori o situazioni inaspettate nell'app) invece di usare l'istanza che tutta l'applicazione usa.

    Se una classe nasce singleton, singleton dev'essere scritta. Qui non si parla di "duplicare codice inutile", che immagino sia l'obiezione delle "10 singleton" fattami prima, qui si tratta di scrivere il codice come dev'essere scritto: se la classe è singleton, và scritta come singleton; se la classe non è singleton ma sarebbe meglio che agisse come tale (che ne so, vuoi evitare di duplicare/caricare due volte uno stesso model o una stessa connection), allora si può usare una Factory astratta a metodi statici che ritorni sempre la stessa istanza senza crearne ogni volta una.
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.