Estendibilità di un progetto: aggiungere estensioni della classe in automatico

[Alethesnake]

Ciao,

Ho una domanda relativamente all'estensione di classi. Vi faccio l'esempio del progetto su cui sto lavorando per cercare di spiegarmi:

Ho creato un'utility per l'esportazione dati in vari formati.
Per fare questo ho creato una classe astratta, DataExporter, che ha un metodo astratto dataBnd().
Ogni classe che estende DataExporter (per ora ho ExcelExporter, CsvExporter, SqlExporter) estende la classe ed implementa il metodo dataBind() secondo le esigenze del caso.

Ora, per non andare a modificare le classi che fruiscono di DataExporter, ho strutturato la classe in questo modo:

public abstract class DataExporter
{
	public enum ExportType
	{
	    EXCEL(1),
	    CSV(2),
	    SQL(3);
	    
	    private int value;
	    
	    private ExportType(int value)
	    {
	    	this.value = value;
	    }
	    
	    public int getValue()
	    {
	    	return value;
	    }
	}

	[...]

	public static Set<ExportSet> exportTypes()
        {
            Set<ExportSet> set = new TreeSet<ExportSet>();
        
            set.add(new ExportSet(ExportType.EXCEL, "Excel filesheet"));
            set.add(new ExportSet(ExportType.SQL, "SQL insert statement"));
            set.add(new ExportSet(ExportType.CSV, "CSV file ( ; )"));
        
            return set;
        }
    
        public static DataExporter getExporter(ExportSet eType) throws DataExporterException
        {
            DataExporter de = null;

            switch (eType.getExportType())
            {
                case CSV:

                    de = new CsvExporter();
                    break;

                case EXCEL:

                    de = new ExcelExporter();
                    break;

                case SQL:

                    de = new SqlExporter();
                    break;

                default:

                    throw new DataExporterException("Export type unknown.");
            }

            return de;
        }
...

Praticamente ho due metodi statici nella classe, uno che mi ritorna i "tipi" di export possibili, l'altro che mi ritorna un oggetto DataExporter istanziato con il costruttore del caso.

Ora, se volessi aggiungere ad esempio TxtExporter, oltre a creare la classe apposita che estende DataExporter, dovrei modificare anche DataExporter aggiungendo il nuovo tipo di esportazione ed il nuovo case nello switch che restituisce l'istanza.


Ciò che vi chiedo è se/come, secondo voi, è possibile impostare il lavoro in modo da non dover modificare, ad ogni estensione, la classe astratta.

Idee?

Ciao e grazie,

Alessandro.

[antotan]

Potresti creare un file di questo tipo:

Exporter.EXCEL=package.ExcelExporter
Exporter.TXT=package.TxtExporter
Exporter.CSV=package.CsvExporter

leggere le classi e caricarle, tramite reflection, in una mappa dove EXCEL, TXT, CSV... sono le chiavi e il valore è l'istanza della classe (o il nome della classe, se vuoi istanziarle on demand).
Puoi passare a getExporter la stringa o un oggetto che identifichi l'exporter (i dettagli implementativi li lascio a te ovviamente).
In questo modo lasci il DataExporter totalmente ignorante, quindi non avresti problemi ad aumentare il numero di exporter

Lo stesso puoi fare senza utilizzare il file comunque, l'importante è eliminare lo switch e rimpiazzalo con la singola riga di reperimento classe dalla mappa

[Alethesnake]

Ciao e grazie per le tue indicazioni.

Ho utilizzato effettivamente la reflection, ma alla fine utilizzando una directory extensions aggiunta al classpath nella quale posso trascinare tutte le classi, racchiuse in un jar, che implementano DataExporter (opportunamente modificato).

Esplorando ogni jar estraggo la classe che fa parte del package extensions e la salvo in una lista (tramite la quale popolo il il Set ritornato dal metodo exportTypes sopra).

Una volta ottenute le classi, con il ClassLoader ritorno l'istanza che mi interessa (in ExportSet ho aggiunto appunto un metodo getInstance() che all'occorrenza ritorna l'istanza della classe che mi interessa).