Pagina 6 di 7 primaprima ... 4 5 6 7 ultimoultimo
Visualizzazione dei risultati da 51 a 60 su 66
  1. #51
    Leader Leader....

    di certo il pattern dao ha come scocciatura che si aggiungono una marea di classi, e in un linguaggio senza package alla Java come php potrebbe dare fastidio. Per ora, la procedura mi pare corretta eccetto, come hai sottolineato anche tu, la factory

    Codice PHP:

     
    public static function getDAOFactory($scelta_db
        { 
            switch (
    $scelta_db
            { 
                case 
    self::MYSQL
                    return new 
    MysqlDAOFactory(); 
                
    /*case self::ORACLE: 
                    return new OracleDAOFactory(); 
                case self::SYBASE: 
                    return new SybaseDAOFactory();*/ 
                
    default: 
                    return 
    null
             } 
         } 
    $scelta_db deve essere di default a null e nello switch, nel case default, si mette l'implementazione di base. Questo è un metodo, con un file delle proprietà nell'applicazione potresti scrivere direttamente lì la classe da utilizzare e poi crearla a runtime... ma vabbeh ci accontentiamo dello switch.

    il pattern dao, come hai detto te, è composto da Model + ModelDAO. PErò, al contrario di come la vedi te, il non usare il pattern Factory ti impedisce di cambiare l'implementazione del db senza dover rifare tutta l'app.

    Invece con la factory

    (I)DAOFactory ritorna ConcreteDAOFactory, dove con Conrete si sostituisce il nome del db implementato, del tipo quindi MySqlDAOFactory, PgsqlDAOFactory, etc

    DAOFactory restituisce oggetti che aderiscono all'interfaccia, quindi le classi concrete sarà ConcreteDAOFactory a sceglierle. Quindi Avrai

    (I)ModelDAO concretizzata da MysqlModelDAO,PgsqlModelDAO,etc

    ovviamente c'è un però. Ogni implementazione porterebbe a riscrivere per ogni DAO tutti i metodi e loro implementazione. Pazzesco. A tal scopo, se uno sa programmare con un pò di metodo, si può benissimo fare una classe Base per i DAO che si occupi di gestire i metodi piu comuni e la connessione al db. i ConcreteModelDAO extenderanno ConcreteBaseDAO e implementeranno ModelDAO. COsì facendo nel 99% dei casi i ConcreteModelDAO non avranno codice o quasi, e nell'1% metodi come "getAllFattureDiPippo" o "getFatturaByAmico" o cmq metodi particolari al tipo di Model utilizzato
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  2. #52
    Originariamente inviato da oly1982
    ok... se manco i guru sanno la best pactices diventa veramente difficile...
    I GURU SEguono altri guru, nel particolare il link che ti postai all'inizio 3d. Ad esempio, un'implementazione Java della Factory è:

    Codice PHP:
    public abstract class DAOFactory {

        private static 
    DAOFactory instance null;
        
        public abstract 
    AlarmDAO getAlarmDAO();
        public abstract 
    AlarmGroupDAO getAlarmGroupDAO();
        public abstract 
    AlarmStatusDAO getAlarmStatusDAO();
        public abstract 
    CustomerDAO getCustomerDAO();
        public abstract 
    CustomersRoomsDAO getCustomersRoomsDAO();
        public abstract 
    FloorDAO getFloorDAO();
        public abstract 
    PhoneDAO getPhoneDAO();
        public abstract 
    ReceptionDAO getReceptionDAO();
        public abstract 
    ReceptionPhonesDAO getReceptionPhonesDAO();
        public abstract 
    RoomDAO getRoomDAO();
        public abstract 
    RoomsGroupsDAO getRoomsGroupsDAO();
        public abstract 
    StatusDAO getStatusDAO();
        public abstract 
    TimeStrategyDAO getTimeStrategyDAO();

        public static 
    DAOFactory getDAOFactory() {

            if(
    instance!=null)
                return 
    instance;
            
            
    instance null;
            
            try {
                
    instance = (DAOFactory) Class.forName(
                        
    PropertiesBundle.getInstance().getProperty(
                                
    "dao.factory_engine")).newInstance();
            } catch (
    InstantiationException e) {
                
    LogFactory.getLogger(PropertiesBundle.class).error(
                        
    "Unable to initialize class {} : {}",
                        
    PropertiesBundle.getInstance().getProperty(
                                
    "dao.factory_engine"), e.getMessage());
            } catch (
    IllegalAccessException e) {
                
    LogFactory.getLogger(PropertiesBundle.class).error(
                        
    "Unable to access to class {} : {}",
                        
    PropertiesBundle.getInstance().getProperty(
                                
    "dao.factory_engine"), e.getMessage());
            } catch (
    ClassNotFoundException e) {
                
    LogFactory.getLogger(PropertiesBundle.class).error(
                        
    "Unable to find class {} : {}",
                        
    PropertiesBundle.getInstance().getProperty(
                                
    "dao.factory_engine"), e.getMessage());
            }

            return 
    instance;
        }


    Il concreteDaoFActory

    Codice PHP:

    public class HibernateDAOFactory extends DAOFactory {
        
        private 
    AlarmDAO alarmDAO;
        private 
    AlarmGroupDAO alarmGroupDAO;
        private 
    AlarmStatusDAO alarmStatusDAO;
        private 
    CustomerDAO customerDAO;
        private 
    CustomersRoomsDAO customersRoomsDAO;
        private 
    FloorDAO floorDAO;
        private 
    PhoneDAO phoneDAO;
        private 
    ReceptionDAO receptionDAO;
        private 
    ReceptionPhonesDAO receptionPhonesDAO;
        private 
    RoomDAO roomDAO;
        private 
    RoomsGroupsDAO roomsGroupsDAO;
        private 
    StatusDAO statusDAO;
        private 
    TimeStrategyDAO timeStrategyDAO;
        
        
        @
    Override
        
    public AlarmDAO getAlarmDAO() {
            
            if(
    alarmDAO==null)
                
    alarmDAO = new HibernateAlarmDAO();
            
            return 
    alarmDAO;
        }

        @
    Override
        
    public AlarmGroupDAO getAlarmGroupDAO() {
            
            if(
    alarmGroupDAO==null)
                
    alarmGroupDAO=new HibernateAlarmGroupDAO();
            
            return 
    alarmGroupDAO;
        }

        @
    Override
        
    public AlarmStatusDAO getAlarmStatusDAO() {
            
            if(
    alarmStatusDAO==null)
                
    alarmStatusDAO = new HibernateAlarmStatusDAO();
            
            return 
    alarmStatusDAO;
        }

    ... 
    etc ect 
    etc etc
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  3. #53
    ... ma io già faccio fatica a seguire OOP... tu mi posti roba in java... Ti ringrazio comunque... ma abbi pietà di me...

  4. #54
    tutto quel casino solo per non dover passare al normale Pattern DAO il "puntatore" (termine improprio) dell'istanza del gestore del db restituita dal Pattern Factory?

    Io sono per il separare le due cose, molto più flessibile e meno "sporco". Però ognuno ha le sue idee
    Administrator of NAMDesign.Net

  5. #55
    Originariamente inviato da oly1982
    ... ma io già faccio fatica a seguire OOP... tu mi posti roba in java... Ti ringrazio comunque... ma abbi pietà di me...
    ma che vuol dire? è uguale al php tranne la tipizzazione dei metodi e il fatto che non c'è il dollaro...

    cmq secondo me non stavi procedendo male, ad eccezione dell'appunto sul metodo statico della DAOFactory, che era limitante (o togli il parametro scegli_Db, oppure metti $scegli_db=null nella dichiarazione del metodo e poi nello switch metti nel case default self::MYSQL... che poi ho capito che stai a seguire la guida, ma non mi pare che tu dovrai implementare un db in ORACLE, quindi non vedo perchè prevederne i casi )

    continua continua ad andare avanti che ora viene la parte piu simpatica: l'implementazione delle ModelDAO con le ConcreteModelDAO.

    Come detto, la parte più comoda della cosa è definire una classe base ConcreteBaseModelDAO con l'implementazione di tutti i metodi piu comuni, e avere le ConcreteModelDAO che estendono la ConcreteBaseModelDAO, implementano la ModelDAO. un esempio:

    Codice PHP:

    abstract class MysqlDAO{

     function 
    findByID($id){ ..}
     
     function 
    findAllBy($criteria){ ... }

     function 
    save($model){ }

     function 
    delete($id){ }

     function 
    query($query){ }

     
    etc ... etc ...
     

    e, per esempio per articoli:

    Codice PHP:

    class MysqlArticoliDAO extends MysqlDAO implements ArticoliDAO{
     
     function 
    findAllByAuthor($authorID){ ... }



    etc. fatto questo, il problema sarà in MysqlDAO capire come creare dinamicamente le query di interesse. Ma questo, per ora, è un altro problema
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  6. #56
    Io farei più una cosa di questo tipo (ovviamente ci sono alcune considerazioni da fare, inoltre ho scritto il codice
    ora, al volo, quindi ci saranno sicuramente degli errori):
    Codice PHP:
    public interface IDatabase_DAO
    {
        public function 
    connect();
        public function 
    query();
        public function 
    close();
        public function 
    fetch_row();
        public function 
    get_num_rows();
        public function 
    get_affected_rows();
    }

    abstract class 
    Database_DAO implements IDatabase_DAO {
        private static 
    $_instance null;

        private function 
    __construct() {}

        public static function 
    getInstance() {
            if ( 
    selft::$_instance == null ) {
                
    $c __CLASS__;
                
    self::$_instance = new $c;
            }
            
            return 
    self::$_instance;
        }
    }

    class 
    MySQL_DAO extends Database_DAO
    {
        
    // ...implementa tutti i metodi descritti nell'interfaccia IDatabase_DAO...
    }

    class 
    DAO_Factory {
        public static function 
    getDAO($name) {
            switch ( 
    $name ) {
                case 
    'mysql':
                    return 
    MySQL_DAO::getInstance();
                    break;
                default:
                    
    trigger_error("DAO inesistente!"E_USER_ERROR);
                    break;
            }
        }

    Codice PHP:
    public class Articoli {
        private 
    $_id;
        private 
    $_titolo;
        private 
    $_testo;
        private 
    $_autore;
        
        public function 
    getTitolo() {}
        public function 
    setTitolo() {}
        public function 
    getTesto() {}
        public function 
    setTesto() {}
        public function 
    getAutore() {}
        public function 
    setAutore() {}
    }

    public interface 
    IArticoli_DAO
    {
        public function 
    insertArticolo(Articoli $articolo);
        public function 
    deleteArticolo($id); 
        public function 
    findArticolo();
        public function 
    updateArticolo(); 
    }

    class 
    MySQL_Articoli_DAO implements IArticoli_DAO {
        public function 
    insertArticolo(Articoli $articolo) {
            
    $db Database_DAO::getInstance();
            
            
    // ...esegui dei controlli di validità sui dati che andrai ad inserire a db...
            
            // Crei la query
            
    $sql sprintf("
                INSERT INTO articoli
                (titolo, testo, autore)
                VALUES
                ('%s', '%s', '%s')"
    $articolo->getTitolo$articolo->getTesto$articolo->getAutore);
                
            
    // Esegui la query sul db
            
    $db->query($sql);
            
            if ( 
    $db->get_affected_rows() > )
                return 
    true;
            else
                return 
    false;
        }
        
        
    // ...implementazione di tutti gli altri metodi...
        
    public function deleteArticolo($id) {}
        public function 
    findArticolo() {}
        public function 
    updateArticolo() {} 

    a questo va ovviamente aggiunta la pagina che gestisce tutto questo, sarà lei ovviamente a sapere se richiamare
    come oggetto di persistenza dei dati un oggetto "mysql", "oracle" o altro; allo stesso modo saprà se richiamare
    un "MySQL_Articoli_DAO" o un "Oracle_Articoli_DAO" (si possono anche prevedere gestioni più sofisticate).

    In questo modo le due componenti sono completamente separate e riutilizzabili.

    Anche se sono sempre dell'idea che non c'è bisogno di usare tutto questo per raggiungere il risultato, sopratutto se si è all'inizio.
    Administrator of NAMDesign.Net

  7. #57
    Leader, non reinventare il DAO. Stiamo quasi dicendo le stesse cose, solo che qui il dao usa, o meglio col dao si usa, una factory che ti restituisca il ModelDAO (interfaccia) in maniera da poter cambiare la sua implementazione quando ti pare.

    Sai qual'è una cosa? se uno non sa programmare ad oggetti non inizia dall'interfacciarsi con un database e la gestione delle entità nel programma. si inizia, in genere, da cose proprio stupide... tipo gli algoritmi di ordinamento di array e alberi e cavolate simili... se vuole partire da una cosa difficile, c'è poco da fare.. gli si deve dire tutto.

    Poi il dao è facile facile dai.. è il primo pattern che ti insegnano all'uni praticamente
    IP-PBX management: http://www.easypbx.it

    Old account: 2126 messages
    Oldest account: 3559 messages

  8. #58
    Originariamente inviato da Santino83_02
    [...cut...]
    Poi il dao è facile facile dai.. è il primo pattern che ti insegnano all'uni praticamente
    proprio per questo non capisco perchè gli vuoi far prendere una strada contorta, gli stai facendo mischiare due pattern (dao e strategy) in una maniera contorta; vincolando tutte le future evoluzioni del sito (o quel che è).

    Se lui domani (e lo ripeto per la centesima volta) vuole aggiungere un modulo deve cambiare anche la classe che gestisce il database...il che è assurdo (sopratutto quando si programma ad oggetti).

    Mentre nel modo che vi sto proponendo la parte che gestisce il database è assolutamente isolata dal resto del programma ed il giorno che vorrà aggiungere un nuovo componente (gestione clienti) sempre sfruttando il pattern dao non dovrà far altro che usare il pattern in maniera pura (e pulita).

    Cmq fagli seguire la strada più sbagliata, i miei appunti erano per metterlo sui binari giusti (visto che l'intendo era questo).

    P.S. Non sto re-inventando il DAO...sto solo usando il pattern Factory ed il pattern DAO in maniera corretta.
    Administrator of NAMDesign.Net

  9. #59
    Codice PHP:
    class MySQL_Articoli_DAO implements IArticoli_DAO 
        public function 
    insertArticolo(Articoli $articolo) { 
            
    $db Database_DAO::getInstance(); 
    Non mi è chiaro questo... perché si costruiscono per il database bellissime interfacce, un'ereditarietà delle classi ben strutturata e persino una factory... per poi creare una classe che si chiama Mysql_Articoli? E se ho supporto a 6 database e 200 oggetti nel sistema (Articoli, news, users, pages, prodotti, nazioni, regioni, citta, banner, immagini, manifestazioni, eventi, parametri, ecc.) mi devo costruire 1200 classi? E anche dopo averle costruite, se voglio aggiungere un misero database che nel frattempo hanno inventato mi devo scrivere altre 200 classi? Nella classe Articoli non devo vedere alcuna sintassi specifica (nemmeno una select perché il sistema di archiviazione dati scelto potrebbe non supportarlo), altrimenti è tutto vano.

  10. #60
    Originariamente inviato da LeaderGL
    Se lui domani (e lo ripeto per la centesima volta) vuole aggiungere un modulo deve cambiare anche la classe che gestisce il database...il che è assurdo (sopratutto quando si programma ad oggetti).
    se lui usasse un file di properties non dovrebbe toccare la classe del daofactory

    Originariamente inviato da LeaderGL
    Mentre nel modo che vi sto proponendo la parte che gestisce il database è assolutamente isolata dal resto del programma ed il giorno che vorrà aggiungere un nuovo componente (gestione clienti) sempre sfruttando il pattern dao non dovrà far altro che usare il pattern in maniera pura (e pulita).
    anche nella mia. L'interfaccia è trasparente, cambia solo l'implementazione di essa a seconda del db utilizzato (come anche nella tua)

    Originariamente inviato da LeaderGL
    Cmq fagli seguire la strada più sbagliata, i miei appunti erano per metterlo sui binari giusti (visto che l'intendo era questo).
    ma sai a me che frega di fargli seguire una strada o l'altra... dico solo che l'implementazione del dao suggerita in quel modo ti permette in un attimo di cambiare db senza cambiare nulla del programma. Perchè nel programma ci sarà un semplice:

    Codice PHP:

    $articoli 
    DAOFactory::getDAOFactory().getArticoliDAO().findAll(); 
    quindi non vedo dove sia la non riusabilità del codice proposto

    Originariamente inviato da LeaderGL
    P.S. Non sto re-inventando il DAO...sto solo usando il pattern Factory ed il pattern DAO in maniera corretta.
    beh, se ti leggi: http://java.sun.com/blueprints/corej...essObject.html non vedo altro che benefici dalla soluzione proposta, che è quella che sta seguendo il proprietario del 3D.. la tua pure mi pare molto simile, sei tu che ti sei fissato su un problema che non esiste. Soprattutto perchè, di classe che parla direttamente col db, qui ancora non s'è parlato, anzi gli ho anche detto che è lì che troverà i problemi maggiori.

    Dov'è che non ci capiamo allora? Purtroppo non ho nulla in php a riguardo perchè per ste menate uso i framework apposta, però ce l'ho in java, e in java ho le componenti ben separate e coese con tutta la riusabilità del caso.

    LAvorando opportunamente, si può anche pensare di ridurre i ModelDAO in maniera da non doverli ripetere a seconda dell'implementazione del db scelta (che è una cosa senza senso, perchè se poco poco i ModelDAO, per le piu svariate ragioni, effettuano query sql hardocded, effettuando il cambio di implementazione si dovrà modificare queste classi...ma potrebbe aver senso provarci cmq), però secondo me si complicherebbe di gran lunga il discorso.
    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 © 2026 vBulletin Solutions, Inc. All rights reserved.