Pagina 4 di 7 primaprima ... 2 3 4 5 6 ... ultimoultimo
Visualizzazione dei risultati da 31 a 40 su 66
  1. #31
    Utente di HTML.it
    Registrato dal
    Sep 2010
    Messaggi
    570
    come ha già detto whisher cerca di favorire il decoupling, in maniera tale che il tuo codice sia facilmente riutilizzabile.

    comunque uccidete tutti quei require, utilizzate l'autoload e trasformate la classe che apre la connessione verso il db in un singleton per evitare di aprire più connessioni verso lo stesso db.

    spostate le configurazioni in un qualche file esterno (anche un xml se lo tenete fuori dalla web root) in maniera tale che se devi cambiare impostazioni varie del programma tu non sia costretto a girare per 2000 file di varie classi per cambiare dati hardcoded ma che tu non sia nemmeno costretto a passare ogni volta i parametri quando apri la connesione.

  2. #32
    Utente di HTML.it L'avatar di dottwatson
    Registrato dal
    Feb 2007
    Messaggi
    3,012
    oly1982 io posso risponderti per punti chiave riguardo alla mia esperienza:

    ti sono stati fatte diverse citazioni e esempi di strutture sa poter adottare in progetto come MVC (pattern design) e ADO e tutte sono legate alla programmazione OOP, il tema del thread.

    Credo che la cosa fondamentale da chiarire, quando si stila un progetto o comunque si crea un set di classi per un progetto, sia aver bene chiara in testa
    COSA FA LA CLASSE, CHE INFORMAZIONI TRATTA E COME METTERLA IN CONDIZIONE DI INTERAGIRE CON LE ATRE CLASSI.

    fondamentalmente io tendo a suddividere le classi per 'scopo' e unicità del dato trattato, così da rendere uniche le risorse che devono essere condivise oppure no.

    in un esempio di sistema base mi ritrovo 4 classi che gestiscono in maniera UNICA le risorse a loro assegnate, e devono rimanere uniche fino alla fine:

    RISORSE UNICHE AL PROGETTO
    sessione : class session statica che gestisce i dati in sessione
    mysql: classe mysql statica che gestisce le richieste al DB
    request: classe request statica che gestisce gli input GET,POST,FILE
    disco: class disk che mi gestisce in maniera unica il disco

    nessuna di queste classi viene estesa

    se voglio accedere alle risorse da altre classi del progetto lo possono fare tranquillamente in quanto statiche

    se devo gestire delle news invece avrò altre tipologie di classi, in quanto i dati gestiti non sono più unici.

    in un contesto come quello delle news avrò

    news entry: classe che definisce anche il MODELLO di news
    news_category: classe che definisce anche il MODELLO della categoria news
    new_tree: classe che gestisce i filtri tra news e categorie e restituisce in base alle richieste un elenco di news, di categorie di news, di news per categoria eccc...

    estendere e implementare è bello perchè le ereditarietà dei metodi e proprietà delle classi si portano dietro con semplicità, ma ti voglio vedere quando in progetto corposo ti devi studiare l' ereditarietà di 15 o 20 classi che si estendono a cascata ....


    in nuna cosa come quella di las
    Codice PHP:
    class connessione {
    .... 
    metodi per connessione e query
    }

    class 
    fattura extends connessione {
    ... 
    metodi principali per la gestione delle fatture

    }

    class 
    fatturaProvvigionale extends fattura {
    ..... 
    metodi specifici per la fattura provvigionale


    MAI mi sarei sognato di estendere connessione da fattura.... 2 cose concettualmente diverse!!!

    al massimo in fattura avrei chiamato dove serviva la classe statica mysql

    Codice PHP:
    $fatt= new fattura('af/1421');

    class 
    fattura{
        public function 
    __construct($doc_num=0){
            if(
    $id !== 0){
                
    mysql::query("select * from fatture where doc_num='$doc_num'");
                
    //codice....
                
    }
            }
        } 
    Non sempre essere l'ultimo è un male... almeno non devi guardarti le spalle

    il mio profilo su PHPClasses e il mio blog laboweb

  3. #33
    Una cosa sacrosanta l'ha scritta "whisher". Quando si parla, pensa e programma Object Oriented le due cose da tenere sempre presente sono:

    1) basso accoppiamento (la minima inter-dipendenza tra classi/oggetti)
    2) alta coesione (una classe deve essere in grado di esaudire quanto più possibile le operazioni sull'oggetto che rappresenta)

    Se una "classe" deve (detto brutalmente e banalmente) rappresentare un oggetto non ha alcun senso che:
    1) la classe "News" (ad esempio) estenda la classe di gestione del database: una news non è un database mysql;
    2) la classe "News" non deve avere conoscenza del mondo esterno o comunque il meno possibile. Quindi come come la validità o meno di un carattere/stringa/testo non le interessa, la provenienza non le interessa, la destinazione e/o la memorizzazione non le interessa.

    Questo per dire che non sempre il concetto procedurale di "gestione news" si traduce in OOP con una sola classe chiamata "News". Un esempio di questo modo di vedere le cose è il pattern "MVC" (che personalmente non trovo molto indicato al web visto che la logica alla base di MVC è una comunicazione bidirezionale, interattiva cosa che al momento non è propria di PHP...anche se ci si mette una pezza con Ajax [e volendo con il salvare lo stato di un oggetto in sessione]).

    In MVC la gestione di un qualcosa è affidata per lo meno a 3 elementi:
    - Il modello (M) che gestisce l'informazione in se (lettura, scrittura, modifica su db...un banale esempio)
    - La view (V) la rappresentazione del dato (banalmente l'html ed il resto)
    - Il controller (C) quello che gestisce le operazioni sull'elemento utilizzando oppportunamente il modello, la view e gli input provenienti dall'esterno (gli eventi)

    PS. ci sono varie inesattenze in quello che ho scritto, ma servono a rendere il tutto più semplice e banale possibile.
    Administrator of NAMDesign.Net

  4. #34
    Dalle info che mi avete fornito ho preso alcuni imput e ho elaborato qualcosa.
    In particolare ho preso spunto da alcuni consigli disseminati su questo topic e ho googlato un pò:
    • evitare di estendere la classe mysql e passarla come parametro di una funzione (whisher)
    • il concetto di DAO (anche se dovrei fare qualche domandina...) e di Entities (Santino)


    Il seguente script da un punto di vista strettamente funzionale và (con error_reportig E_ALL).
    Sapete dirmi se sono sulla strada giusta o se sono andato ulteriormente fuori strada?
    MySqlClass.php
    Codice PHP:
    <?php

    Class Utilizza_Mysql
        
    {
        
    /*
        classe mooooolto banale... giusto il minimo indispensabile
        - connessione
        - esecuzione query
        - fetch dei record estratti con select
        ... ovviamente implementabile ulteriormente per:
        num_rows,affected_rows,gestione degli errori
    ,escape delle stringhe
    ,etc etc)
        */    
        
    private $host         'localhost';
        private 
    $user         'root';
        private 
    $pass         '';
        private 
    $name_db     'my_test';

        
        protected 
    $db_link;
        
        public function 
    __construct()
            {
            
    $this->db_link mysql_connect ($this->host$this->user$this->pass);
            
    mysql_select_db ($this->name_db$this->db_link);
            }
        
        protected function 
    esegui_query($query)
            {
            
    $result mysql_query($query$this->db_link);
            return 
    $result;
            }


        protected function 
    fetch($result)
            {
            
    $row mysql_fetch_array($result);
            return 
    $row;
            }
        }
    ?>
    ArticoliClass.php (dovrebbe essere qualla a cui santino si riferiva quando parlava di classe guscio)
    Codice PHP:
    <?php
    class Articoli {
        
    /*le proprietà coincidono coincidono con i campi del db*/
        
    protected $id_art;
        protected 
    $titolo_art;
        protected 
    $testo_art;
        protected 
    $data_inserimento;

        
    /*serie di metori set e get per impostare/ottenere il valore di tali proprietà*/
        
    public function getId_art() 
            {
            return 
    $this->id_art;
            }

     
        public function 
    setId_art($id_artIn
            {
            
    $this->id_art $id_artIn;
            }

        public function 
    getTitolo_art() 
            {
            return 
    $this->titolo_art;
            }
      
        public function 
    setTitolo_art($titolo_artIn
            {
            
    $this->titolo_art $titolo_artIn;
            }

        public function 
    getTesto_art()
            {
            return 
    $this->testo_art;
            }
     
        public function 
    setTesto_art($testo_artIn)
            {
            
    $this->testo_art $testo_artIn;
            }

        public function 
    getData_inserimento()
            {
            return 
    $this->data_inserimento;
            }

        public function 
    setData_inserimento($data_inserimentoIn
            {
            
    $this->data_inserimento $data_inserimentoIn;
            }
        }
    ?>
    ArticoliDao.php (qui viene il bello... anzi il brutto...)

    Codice PHP:
    <?php
    Class ArticoliDao
        
    {
        
    /*
        questo metodo è usato ogni qual volta occorre creare delle nuove entità.
        In pratica quando si estraggono dati da una query i valori ottenuti dovranno essere "incapsulati"
        all'interno degli oggetti id_articolo, testo_articolo, etc etc.
        pertanto dopo aver istanziato la classe Articoli potro accedere ai suoi metodi set 
        e così attribuire il valore agli oggetti.
        */
        
    protected function CreateEntities() 
            {
            return new 
    Articoli();
            }


        
    /*
        Utilizzando il metodo SET della classe Articoli potremo attribuire valori agli oggetti.
        Tali valori essendo presenti nel db occorrerà anzitutto prelevarli tramite query MySql.
        La classe che gestisce query a mysql è 'Utilizza_Mysql' che passeremo alla classe ArticoliDao come parametro
        Possono presentarsi due casi:
        - selezione di un unico record tramite id (chiave primaria): 
            creo un istanza alla classe Articoli()
            tramite metodo SET attribuisco direttamente il valore (prelevato dal db)
            dopodichè all'interno della pagina potrò accedere a tali valori con metodo GET
        - selezione di più record: 
            la logica è identica alla precedenza con la sola differenza che 
            avrò una sorta di array di istanze Articoli()
            pertanto all'interno della pagina scorrendo l'array con un foreach ciascun elemento
            sarà costituito da 
        */
        
    protected function select_single_to_object($conn$query)
            {
            
    $Valore_Entita $this->CreateEntities();
            
    $result $conn->esegui_query($query);
            if (
    $row $conn->fetch($result))
                {
                
    $Valore_Entita->setId_art($row[0]);
                
    $Valore_Entita->setTitolo_art($row[1]);
                
    $Valore_Entita->setTesto_art($row[2]);
                
    $Valore_Entita->setData_inserimento($row[3]);
                }
            else
                {
                return 
    false;
                }
            return 
    $Valore_Entita;
            }

        protected function 
    select_multiple_to_arrayobject($conn$query)
            {
            
    $Array_con_oggetti = array();
            
    $result $conn->esegui_query($query);
            
            while (
    $row $conn->fetch($result))
                {
                
    /*per ogni record estratto creiamo un'entità*/
                
    $Valore_Entita_Elemento_Array $this->CreateEntities();
                
                
    /*Con metodo SET attribuiamo un valore agli oggetti di tale entità*/
                
    $Valore_Entita_Elemento_Array->setId_art($row[0]);
                
    $Valore_Entita_Elemento_Array->setTitolo_art($row[1]);
                
    $Valore_Entita_Elemento_Array->setTesto_art($row[2]);
                
    $Valore_Entita_Elemento_Array->setData_inserimento($row[3]);

                
    /*aggiungiamo all'array l'entità appena creata*/
                
    array_push($Array_con_oggetti$Valore_Entita_Elemento_Array);
                }
            return 
    $Array_con_oggetti;
            }
            
        
    /*
        Concentrandoci solo sulle query select poniamo che 
        - in un caso vogliamo ottenere gli ultimi 5 articoli
        - in n altro vogliamo ottenere il singolo articolo
        */
        
    public function Get_Ultimi_Articoli($conn)
            {
            
    $query "SELECT * FROM articoli ORDER BY data_inserimento DESC LIMIT 5";
            
    $Array_result_object $this->select_multiple_to_arrayobject($conn$query);
            return 
    $Array_result_object;
            }
        
        public function 
    Get_Articolo_By_Id($conn$id_articolo)
            {
            
    $query "SELECT * FROM articoli WHERE id_articolo ='".$id_articolo."' LIMIT 1";
            
    $result_object $this->select_single_to_object($conn$query);
            return 
    $result_object;
            }
        }
    ?>
    Ultimi_articoli.php
    Codice PHP:
    <?php
    error_reporting
    (E_ALL);

    require_once(
    'ArticoliClass.php');
    require_once(
    'ArticoliDao.php');
    require_once(
    'MySqlClass.php');

    /*
    Istanziamo la classe per connetterci al db e poter interazire con esso
    */
    $connessione = new Utilizza_Mysql();
    /*
    Istanziamo la classe ArticoliDao per poter ottenre gli oggetti che ci occorrono
    */
    $articoli = new ArticoliDao();

    /*
    Utilizziamo il metodo GET per ottenere le ultime news
    */
    $ultimi_articoli $articoli->Get_Ultimi_Articoli($connessione);



    //echo '<pre>';
    //var_dump($ultimi_articoli);
    //exit;
    ?>

    <html>
    <body>

    <h1>Ultimi 5 articoli inseriti:</h1>
    <ul>

    <?php foreach($ultimi_articoli as $key => $object) : ?>

            [*] 
                <a href="leggi_articolo.php?id=<?php echo $object->getId_art(); ?>"> 
                    <?php echo $object->getTitolo_art(); ?>
                </a>
            
    <?php endforeach; ?>[/list]
    </body>
    </html>
    leggi_articolo.php
    Codice PHP:
    <?php
    error_reporting
    (E_ALL);

    require_once(
    'ArticoliClass.php');
    require_once(
    'ArticoliDao.php');
    require_once(
    'MySqlClass.php');

    $connessione = new Utilizza_Mysql();
    $articoli = new ArticoliDao();

    $id = (isset($_GET['id']))?  intval($_GET['id']) : 0;

    $singolo_articolo $articoli->Get_Articolo_By_Id($connessione$id);

    //echo '<pre>';
    //var_dump($singolo_articolo);
    //exit;
    ?>
    <html>
    <body>
    [url="Ultimi_articoli.php"]TORNA ALLE ULTIME NEWS[/url]

    <h1><?php echo $singolo_articolo->getTitolo_art(); ?></h1>



    <?php echo $singolo_articolo->getTesto_art(); ?></p>

    </body>
    </html>

  5. #35
    Utente di HTML.it L'avatar di Grino
    Registrato dal
    Oct 2004
    Messaggi
    739
    Direi che non ci siamo:
    1) crea la classe DAOFactory (il generatore di coloro che accedono direttamente a sorgenti dati)
    2) estendila con una MySQLDAOFactory (colui che interagisce con MySQL... è la tua classe Utilizza_Mysql. Rendi i metdi che reimplementano i comandi mysql statici.
    3) Decidi l'interfaccia ArticoliDAO
    4) Crea una classe MySQLArticoloDAO che implementa ArticoloDAO. Questa classe utilizza la classe MySQLDAO (le sue funzioni statiche) per eseguire i comandi mysql o richiama i comandi mysql direttamente
    5) Crea una classe Articolo che sarà il tuo transfer object

    una volta scritte le classi o perfezionato lo scheletro seguente, non dovrai più accedere direttamente a mysql ma sfrutterai un oggetto MySQLArticoloDAO ottenuto tramite le due righe seguenti

    $MySQLFactory = DAOFactory::getDAOFactory(DAOFactory::MYSQL);
    $artDAO = $MySQLFactory->getArticoloDAO();

    da questo momento accederai ai dati tramite $artDAO e l'interfaccia ArticoloDAO che la classe MySQLArticoloDAO implemente, ovvero sfruttando il transfer object Articolo sia per passare dati che per riceverli.

    riprendendo il codice dell'esempio come scheletro e riadeguandolo un po'

    codice:
    // Abstract class DAO Factory
    abstract class DAOFactory {
        // List of DAO types supported by the factory
        const MYSQL = 1;
    
        // There will be a method for each DAO that can be
        // created. The concrete factories will have to
        // implement these methods.
        public abstract function getArticoliDAO();
    
        public static function getDAOFactory($whichFactory) {
            switch ($whichFactory) {
                case self::MYSQL:
                    return new MYSQLDAOFactory();
                default:
                    return null;
            }
        }
    
    }
    
    class MYSQLDAOFactory extends DAOFactory {
    
        private static $conn = null;
    
        // method to create MySQL connections
        public static function createConnection($host,$user,$pass,$db) {
            if (is_null(self::$conn)) {
                if (!(self::$conn = @mysql_connect($host, $user, $pass)))
                    throw new Exception(mysql_error());
                if (!@mysql_select_db($db))
                    throw new Exception(mysql_error());
            }
            return self::$conn;
        }
    
        public function getArticoloDAO() {
            // MySQLArticoloDAO implements ArticoloDAO
            return new MySQLArticoloDAO();
        }
    }
    
    // Interface that all ArticoloDAOs must support
    interface ArticoloDAO {
        //per semplicità, tutte le funzioni richiedono un $oArticolo che è
        //un trasfer object di classe articolo. Nel caso della insert,
        //prenderai i valori e li inserirai nel DB
        public function insertArticolo($oArticolo); //ritorna un int
        //Nel caso della delete recuperi l'id del transfer object e fai la delete dal DB
        public function deleteArticolo($oArticolo); //ritorna un boolean
        //Nel caso della find nell'oggetto troverai uno o più dati compilati
        //che utilizzerai come campi di ricerca
        public function findArticolo($oArticolo); //ritorna un oggetto Articolo
        //nel caso della update utilizzerai i dati del transfer object per
        //aggiornare l'articolo
        public function updateArticolo($oArticolo); //ritorna un boolean
        //nel caso di selectRS utilizzerai l'oggetto oArticolo come per la find ma
        //restituirai un array in cui ogni riga è una riga tornata dal DB
        public function selectArticoloRS($oArticolo); //ritorna un RowSet
        public function getNextArticoloTO($RowSet); //ritorna un tranfer object
        //anche in questo caso utilizzi $oArticolo come oggetto contenente i criteri di
        //ricerca e ritorni il risultato sotto forma di array di oggetti Articolo
        public function selectArticoloTO($oArticolo); //ritorna un oggetto Collection
    }
    
    // MySQLArticoloDAO implementation of the
    // ArticoloDAO interface. This class can contain all
    // Cloudscape specific code and SQL statements.
    // The client is thus shielded from knowing
    // these implementation details.
    
    class MySQLArticoloDAO implements ArticoloDAO {
    
        public function insertArticolo($oArticolo) {
            $conn=MYSQLDAOFactory::createConnection("localhost", "user", "pass", "nomedb");
    
            //In $oArticolo hai un oggetto di classe Articolo
            //Fai la insert e ritorna un intero, magari l'id generato dalla isert
    
            return $int;
        }
    
        public function deleteArticolo($oArticolo) {
            //scrivi il codice per mysql
            return $bool;
        }
    
    
        public function findArticolo($oArticolo) {
            //scrivi il codice per mysql
            return $oArticolo;
        }
    
        public function updateArticolo($oArticolo) {
            //scrivi il codice per mysql
            // Return true on success, false on failure or
            // error
            return $bool;
        }
    
        public function selectArticoloRS($oArticolo) {
            //scrivi il codice per mysql
            // Return a RowSet ovvero il reult di mysql_query()
            return $RowSet;
        }
    
        public function  getNextArticoloTO($RowSet) {
            $oArticolo=new Articolo();
    
            //Consenti all'utente di leggere dati dal rowset senza utilizzare
            //direttamente le funzioni mysql
    
            return $oArticolo;
        }
    
        public function selectArticoloTO($oArticolo) {
            $oCollectionOfTransferObject=array();
            //esequo una query, sfoglio il resultset e per ogni riga creo un oggetto
            //$articolo per il quale $oCollectionOfTransferObject[]=$articolo;
            return $oCollectionOfTransferObject; //Il transfer object è la classe Articolo
        }
    
        //Varie ed eventuali
    }
    
    //Questo è il transfer object
    class Articolo {
    
       //Riempi la tua classe articolo
    }
    
    //Esempio di utilizzo.
    $MySQLFactory = DAOFactory::getDAOFactory(DAOFactory::MYSQL);
    
    // Create a DAO
    $artDAO = $MySQLFactory->getArticoloDAO();
    
    // create a new Articolo
    // Creare un transfer object $Custome
    $art = new Articolo();
    // Settare opportunamente l'ggetto $cust
    $newArtNo = $artDAO->insertArticolo($art);
    // Find a Articolo object. Get the Transfer Object. Ovvero un oggetto Articolo
    $art = $artDAO->findArticolo($art);//in pratica ti ritrova l'articolo appena creato
    
    // modify the values in the Transfer Object.
    $art->setData_inserimento($data);
    $art->setTesto_art($testo);
    // update the Articolo object using the DAO
    $artDAO->updateArticolo($art);
    
    // delete a Articolo object
    $artDAO->deleteArticolo($art);
    // select all Articolo in the same city
    $criteria = new Articolo();
    $criteria->setData_inserimento($data);
    $ArticoloList = $artDAO->selectArticoloTO($criteria);
    // returns ArticoloList - collection of Articolo
    // Transfer Objects. iterate through this collection to
    // get values.
    //...
    ?>

  6. #36
    grino ti ringrazio per la risposta.

    Mi hai introdotto tantissime cose nuove che sicuramente sono esattissime!

    Solo che mooolto complesso. Invece di rivoluzionare il mio lavorino-ino-ino-ino mi spieghi in che punto ho toppato??

    Inoltre (concentrando i miei sforzi solo sul select) questa parte del tuo codice "assomiglia" per logica seguita molto a quella che ho fatto io (almeno così mi è sembrato);
    Nei tuoi commenti quello che tu chiamo "oggetto Collection" io (da ignorante) l'ho chiamato "array con oggetti"; mentre il "tranfer object" io (da ignorante) l'ho chiamato "Entità" o "Valore_Entita".
    Codice PHP:
    /*
    io ho fatto 
    $result = $conn->esegui_query($query); 
    all'interno dei metodi select_single e select_multiple
    mentre per come ho capito tu dici di farlo separatamente 
    con questo metodo 
    e poi passarlo come parametro
    */
        
    public function selectArticoloRS($oArticolo) {
            
    //scrivi il codice per mysql
            // Return a RowSet ovvero il reult di mysql_query()
            
    return $RowSet;
        }

    /*
    la logica è simile a 
    select_single_to_object
    - istanzio un oggetto: $Valore_Entita = $this->CreateEntities();
    - eseguo la query (nel tuo esempio il suo result è un parametro... mentre io la eseguo al suo interno sfruttando i parametri): $result = $conn->esegui_query($query);
    - con metodo set inserisco i valori nell'oggetto creato: $Valore_Entita->setTitolo_art($row[1]);
    - return l'oggetto creato inizialmente ma che grazie ai vari set ora contiene valori che pesso leggere con i rispettivi get 
    */
        
    public function  getNextArticoloTO($RowSet) {
            
    $oArticolo=new Articolo();

            
    //Consenti all'utente di leggere dati dal rowset senza utilizzare
            //direttamente le funzioni mysql

            
    return $oArticolo;
        }

    /*
    la logica mi sembra simile a quella che io ho seguito in
    select_multiple_to_arrayobject:
    - creo un array vuoto: $Array_con_oggetti = array();
    - eseguo la query e ottengo il result ($conn era x me un parametro): $result = $conn->esegui_query($query);
    - sfoglio il result con while - fetch: while ($row = $conn->fetch($result))
    - per ogni riga creo un oggetto: $Valore_Entita_Elemento_Array = $this->CreateEntities();
    - con i metodi set inserisco il valore nell'oggetto appena creato: $Valore_Entita_Elemento_Array->setTitolo_art($row[1]);
    - l'oggetto così formato lo metto nell'array creato inizialmente: array_push($Array_con_oggetti, $Valore_Entita_Elemento_Array);
    - return l'oggetto: return $Array_con_oggetti;
    */
        
    public function selectArticoloTO($oArticolo) {
            
    $oCollectionOfTransferObject=array();
            
    //esequo una query, sfoglio il resultset e per ogni riga creo un oggetto
            //$articolo per il quale $oCollectionOfTransferObject[]=$articolo;
            
    return $oCollectionOfTransferObject//Il transfer object è la classe Articolo
        

    Non buttare tutto nel cestino quel che ho fatto... fammi capire più specificamente i punti deboli dei miei ragionamenti...
    La struttura che hai proposto io ho avuto modo di consultarla qui:
    http://phpdao.com/testdao.zip

    solo che dato tutti questi richiami incrociati mi perdevo per strada e quindi ho cercato di sintetizzare la logica in modo da comprenderla meglio...
    Fammi fare un passo per volta... che pian piano credo che ci posso arrivare.

    Ad esempio la classe DAOFactory che hai creato serve per scegliere il db e istanziare la relativa classe per il tipo di db prescelto... ma il mio lavorino dava per scontato l'impiego di mysql.

    in sintesi farò una cosa che si ispira a quella indicata nel link sopra ma prima di arrivare a quello voglio capire la struttura generale...

  7. #37
    Utente di HTML.it L'avatar di Grino
    Registrato dal
    Oct 2004
    Messaggi
    739
    Parliamo della tua classe ArticoliDAO:

    Perchè chiede come parametri un $conn ed un $query in molti metodi? ArticoliDAO dovrebbe accettare come argomento il TO o tranfer object quindi un oggetto di classe Articoli e dovrebbe permetere alla tua applicazione di accedere solo tramite le funzioni implementate nell'interfaccia che io chiamo ArticoliDAO, ma che tu salti a piè pari, che deve essere indipendente dalla sorgente dati.

    Il tuo ArticoliDAO invece dovrebbe fare affidamento su MySQLDAOFactory (che diciamo essere il tuo Utilizza_MySQL) per la connessione e le istruzioni necessarie per accedere al DB e non spettarsi che sia l'applicazione a passargliele. Volendo ArticoliDAO, che faresti bene a chiamare MySQLArticoliDAO (visto che lo dedichi a MySQL) può fare riferimento direttamente alle istruzioni mysql_*** se MySQLDAOFactory non gestisce una classe completa per mysql. Ma mai deve ricevere dall'applicazione delle $query o delle $conn ma solo TO ai cui attributi accede, con gli appositi metodi, per costruire le proprie query.

    La potenzialità sta nel fatto che se domani vuoi gestire con CSV i tuoi articoli devi solo realizzare una classe CSVDAOFactory che estenda DAOFactory, una CSVArticoliDAO (quella che tu chiami ArticoloDAO e che dovresti invece chiamare MySQLArticoloDAO) che implementi ArticoliDAO, l'interfaccia come la intendo io e che tu non formalizzi. Sistemare DAOFactory e nella tua applicazione cambierà solo

    $Factory = DAOFactory::getDAOFactory(DAOFactory::MYSQL);
    $artDAO = $Factory->getArticoloDAO();

    in

    $Factory = DAOFactory::getDAOFactory(DAOFactory::CSV);
    $artDAO = $Factory->getArticoloDAO();

    in $artDAO ti ritroverai un oggetto CSVArticoloDAO, ma a te non importa perchè a parità di chiamate effettuate con l'oggetto MySQLArticoloDAO svolge le stesse identiche funzioni ma su file CSV ovvero sei riuscito ad implementare una nuova sorgente dati senza toccare il codice dell'applicazione. Questo perchè viene implementata una interfaccia e nascosta completamente la sorgente dati che c'è dietro.

    Se invece inizi a far volare $conn e $query di qua e di là non riesci più ma mantenere indipendente l'applicazione dalla sorgente.

    Guarda i tuoi esempi leggi_articolo.php e ultimi_articoli.php. Sono strettamente legati a mysql, e l'unico modo che hai per alterare la sorgente è ricrivere la tua classe ArticoliDAO e modificare il codice delle tua pagine, codice che sarebbe rimasto intonso se avessi prodotto una reale divisione tra sorgente dati e codice dell'applicazione. E se poi vuoi permettere la scelta tra CSV e MySQL. Nel vero DAO ti basta switchare fra un DAOFactory::MySQL a un DAOFactory::CSV mentre tu dovresti apportare modifiche qua e là nell'applicazione per sostituire il tuo ArticoloDAO con un'altra classe.

    Infine molte implementazioni di DAOFactory in PHP cercano di individuare e caricare automaticamente le classi necessarie.

    Ad esempio in DAOFactory::getDAOFactory potresti chiedere il nome della sorgente ed il nome del TO ovvero MySQL e Articolo per cui ottieni che hai bisogno di una classe MySQLArticoloDAO che implementi una interfaccia ArticoloDAO e di un TO Articolo. Se la classe non è disponibile allora provi a caricare dei file con i nomi MySQLArticoloDAO.class.php (definizione della sorgente dati) e ArticoloDAO.php (in cui c'è la definizione dell'interfaccia e la definizione della classe TO)

    Sta a te stabilire le regole e caricare automaticamente i nomi oppurutni. In questo modo quando iplementi nuove sorgenti non devi nenache modificare il DAOFactory ma implementare la sorgente (SorgetneTransferObjcetDAO che implementi TransferObjectDAO interfaccia per la classe TransferObject), cambiare il nome della sorgente nell'applicazione (o in un bel file di configurazione) ed hai finito.

    L'unico consiglio che ti posso dare è, prima di continuare a scrivere codice fermati a leggere bene bene la paginetta (anche se riferita a JAVA) sul DAO che ho postato in precedenza. Cerca di afferare bene i concetti che espone, gli intenti che si prefigge e come i concetti vengono applicati per ottenere i risultati attesi. Confronta con il codice dell'esempio PHP che ho trasportato dall'esempio che lì è presentato in JAVA.

  8. #38
    Per me si sta però rendendo il tutto troppo complicato per una persona che vuole iniziare a programmare ad oggetti.

    Credo che meno oggetti ci sono con cui aver a che fare (in questa fase) e meglio è.

    Io farei, ad esempio, qualcosa del genere:
    - Una classe per gestire le richieste al database (qui poi si potrebbe in futuro adottare il Pattern Factory) che implementa le funzioni base (connessione, esecuzione query, numero di righe interessate dall'ultima query, etc..):
    Codice PHP:
    class MySQL
    {
       function 
    __construct($host$username$password$db) {}
       function 
    connect() {}
       function 
    close() {}
       function 
    prepare() {}
       function 
    query() {}
       ...

    - Una classe che gestisce il modello dell'oggetto (in questo caso le news) e che quindi legge e scrive sul db:
    Codice PHP:
    class News_Model
    {
       function 
    __construct($db) {}
       function 
    get($idnews) {}
       function 
    getAll() {}
       function 
    set(array $data) {}
       function 
    edit($idnews, array $data) {}
       function 
    delete($idnews) {}

    - Una classe che gestisca tutta la logica e la visualizzazione delle news (in futuro logica e visualizzazione possono essere separate, magari utilizzando un piccolo template engine):
    Codice PHP:
    /*
     * Includi un file di settaggi generali che può istanziare il db, includere librerie necessair
     */
    require_once '/settings/global.inc.php';


    class 
    News
    {
       function 
    __construct() {
          
    // Leggi l'operazione che il cliente ha scelto
          // se non è stata scelta alcuna operazione applichi quella di default
          
    $op "show";
          if ( isset(
    $_GET['op']) && !empty($_GET['op']) )
               
    $op addslashes($_GET['op']);

          
    // In base all'operazione richiami la relativa funzione
          
    switch ( $op ) {
              case 
    'getAll'$this->getAll(); break;
              case 
    '...': ...; break;
              default: 
    $this->show(); break;
          }
          exit;
       }

       function 
    show() {
          global 
    $db;  // la classe db magari l'hai istanziata altrove, etc

          
    require_once 'model/news.model.php';
          
    $news_model = new News_Model($db);

          
    $news_list $news_model->getAll();
          foreach ( 
    $news_list AS $index => $news ) {
              
    // stampi quello che ti serve della news
          
    }
       }

    questo è una bozza al volo, però qualcosa del genere per cominciare potrebbe funzionare
    Administrator of NAMDesign.Net

  9. #39
    @ LeaderGL

    il problema è che lui ha scelto un argomento particolarmente complicato per iniziare.. se tu glielo fai vedere con meno oggetti, non vuol dire che tu gli stia dando dei consigli utili... volendo lo fai anche solo con un oggetto tutto sto papocchio, però non è lo scopo della domanda.
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  10. #40
    Originariamente inviato da Santino83_02
    @ LeaderGL

    il problema è che lui ha scelto un argomento particolarmente complicato per iniziare.. se tu glielo fai vedere con meno oggetti, non vuol dire che tu gli stia dando dei consigli utili... volendo lo fai anche solo con un oggetto tutto sto papocchio, però non è lo scopo della domanda.
    Sono daccordo, però è anche vero che una buona programmazione ad oggetti prevede l'uso di vari pattern e l'applicazione della giusta strategia per risolvere i vari problemi; questo significa che bisognerebbe fare un minimo di fase di analisi del problema, però senza conoscere niente della programmazione ad oggetti è difficile fare un ragionamento di questo tipo.

    Credo possa essere più utile in questa fase prendere dimestichezza con gli elementi fondamentali della programmazione ad oggetti: le classi, i vari modificatori, un po di separazione (concetti di coesione ed accoppiamento), qualche minimo pattern.

    Una volta che si prende dimestichezza allora si potrà ragionare con più consapevolezza su nuove tecniche e su quale sia la strada giusta.

    Almeno secondo me
    Administrator of NAMDesign.Net

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 © 2026 vBulletin Solutions, Inc. All rights reserved.