Sto cercando di capire il miglior design per istanziare un oggetto che richiede due chiamate separate al livello dati attraverso un DAO. L'oggetto non è utilizzabile fino a quando queste chiamate non sono state fatte (perché richiede i dati recuperati dal database). Ho trovato tre soluzioni possibili:
- Creare un metodo nello stesso DAO che ottiene i dati necessari dal database e quindi passa i dati al costruttore dell'oggetto. L'oggetto viene restituito come valore di ritorno.
- Crea un metodo nella classe che sta usando l'oggetto. Questo metodo effettua entrambe le chiamate a metodi pubblici nel DAO, quindi crea un'istanza e restituisce l'oggetto come nel passaggio 1.
- Passa il DAO come parametro al costruttore dell'oggetto. Il costruttore quindi effettuerà entrambe le chiamate necessarie al DAO, impostando le proprie variabili membro senza la necessità di setter. Il DAO non viene utilizzato diverso dal costruttore.
Esempi, se SomeObject è l'oggetto che voglio creare, e Foo è la classe che ne farà uso:
1 - DAO Contiene la logica:
public SomeObject getSomeObject(){ // this DAO method called by Foo class
data1 = getData1();
data2 = getData2();
return new SomeObject(data1,data2);
}
2 - La classe che usa l'oggetto contiene la logica:
public class Foo {
...
public void useSomeObject() {
SomeObject obj = createSomeObject();
obj.doStuff();
}
private SomeObject createSomeObject() {
data1 = dao.getData1();
data2 = dao.getData2();
SomeObject someObject = new SomeObject(data1,data2);
return someObject;
}
}
3 - SomeObject prende DAO come parametro e lo utilizza nel costruttore:
public class SomeObject {
...
public SomeObject(DAO dao) {
data1 = dao.getData1();
data2 = dao.getData2();
}
...
}
Spero che questi esempi siano sufficienti per esprimere il mio punto. Qualcuna di queste soluzioni ha un design migliore rispetto alle altre? In caso contrario, quale soluzione è considerata la migliore pratica?
Grazie.