Qualcuno usa i design pattern

[puntino]

come da oggetto

[Alex'87]

Ehm... scopo della discussione?

[puntino]

vorrei chiedere un consiglio sull'implementazione di una parte del codice.

[Alex'87]

Originariamente inviato da puntino
vorrei chiedere un consiglio sull'implementazione di una parte del codice.

Beh, spiega cosa devi fare e vediamo se riusciamo a darti una mano...

[puntino]

Prima di tutto grazi Alex,

Mi chiedevo se esiste un design pattern per risolvere il seguente problema:
Supponiamo di avere delle API per la gestione dei file su un file system. Ad esempio

Ci sono N produttori di queste API quindi, per semplicità ne considero solo 2

class GestioneFileProd1{
inserisciProd1( f file); //inserisce un file da qualche parte
deleteProd1(f file) //cancella il file
}

class GestioneFileProd2{
inserisciProd2( f file);
deleteProd2(f file)
}

Dal main attualmente per usare le API di questo produttore si scrive

main{


GestioneFileProd1 getore = new GestioneFileprod1();
gestore.inserisciFile(file);
}

}


se voglio passare ad un altro produttore letterlemente si cancella il
codice precedente. cioè GestioneFileProd1(f File) con GestioneFileProd2(f File)

Quello che io vorrrei realizzare è:
a)Passare da un set di API ad un altro agevolmente senza buttare via del codice, in pratica inserisciFile
della classe main non deve essere brutalmente sovrascritto
b) Avere la possibilità di usare più API allo stesso tempo. ad esempio per i file di dimensione maggiore
di 100M se ne occupa le API del produttore 1, per quelli inferiori si 100 MB se ne occupa le API del produttore 2

[manu1980]

Devi utilizzare il pattern Bridge (su internet trovi una marea di informazioni).
Per farla breve devi astrarre le operazioni spostandole in un'interfaccia, in modo che l'astrazione dipenda dall'implementazione di quell'interfaccia.

Nel tuo caso avresti:

public interface GestioneFile {

  public abstract inserisciProd(File f);
  public abstract deleteProd(File f);

}

public GestioneFileProd1 implements GestioneFile {

  public inserisciProd(File f) {
    // Implementazione per GestioneFileProd1 
  }

  public deleteProd(File f) {
    // Implementazione per GestioneFileProd1
  }

}

public GestioneFileProd2 implements GestioneFile {

  public inserisciProd(File f) {
    // Implementazione per GestioneFileProd2
  }

  public deleteProd(File f) {
    // Implementazione per GestioneFileProd2 
  }

} 

Per l'istanziazione:

GestioneFile gf1 = new GestioneFileProd1();
gf1.inserisciProd(file); 

Per andare oltre potresti non sapere che classe implementare (GestioneFileProd1 o GestioneFileProd2). In questo caso potresti implementare il pattern Factory method che permette di creare un oggetto, lasciando al codice il controllo di quale specifica classe istanziare.

[puntino]

ok fino a qui ci sono, infatti quello che io pensavo, era utulizzare un factory.
Però vorrei che il mio codice diventasse ancora più flessibile nel punto in cui si devono utilizzare gli oggetti. Con riferimento al tuo esempio, nel mio main se dovessi scegliere di usare GestioneFile1 per file in formato jpg e l'altro per formato excel
scriverei:

String extension = getExtension(file); //getMimeType è una classe di servizio che restituisce l'estensione 

GestioneFile gf1 = null ; 

if(extension.equals("xsl")){
  gfl = new GestioneFileprod1(); 
}else if(extension.equals("jpg")){
  gfl = new GestioneFileprod2(); 
 } 

Quello che io voglio rendere più "elastico" è proprio quei rami if-else.
Se suppongo di avere un Gestore di file dedicato ad ogni estensione di un file, puoi capire che si rischia di allungare la catena degli if-else all'infinito nel main.

[manu1980]

Il pattern Factory method ingloba in un unico punto l'istanziazione della corretta classe (e di conseguenza la serie di if... else if...). Se la struttura di if... else if... è destinata a crescere o a mutare dinamicamente puoi utilizzare tecniche di reflection per l'istanziazione della corretta classe.

[puntino]

grazie