Approccio corretto alle proprietà

Question

Sto lavorando in Java su un progetto abbastanza grande. La mia domanda è su come strutturare al meglio l'insieme di Proprietà per la mia applicazione.

Approccio 1: hanno alcuni oggetti Proprietà statici accessibili da ogni classe. (Svantaggi: quindi, alcune classi perdono la loro generalità se dovessero essere estratte dal contesto dell'applicazione; richiedono anche chiamate esplicite a un oggetto statico che si trova in una classe diversa e potrebbe in futuro scomparire; semplicemente non lo fa senti giusto, sbaglio?)

Approccio 2: fare in modo che le Proprietà siano istanziate dalla classe principale e tramandate alle altre classi di applicazione. (Svantaggi: finisci per passare un puntatore all'oggetto Proprietà a quasi tutte le classi e sembra diventare molto ridondante e ingombrante; non mi piace mi piace .

Qualche suggerimento?

Answer 1

Mi piace usare l'iniezione di dipendenza Spring per molte proprietà. È possibile trattare l'applicazione come blocchi predefiniti e iniettare le proprietà direttamente nel componente che ne ha bisogno. Ciò preserva (incoraggia) l'incapsulamento. Quindi, assembli i componenti insieme e crei la "classe principale".

Un piacevole effetto collaterale dell'iniezione di dipendenza è che il tuo codice dovrebbe essere più facilmente testabile.

Answer 2

In realtà, l'approccio 2 funziona davvero bene.

Ho provato a usare un oggetto proprietà Singleton su un progetto recente. Quindi, quando è arrivato il momento di aggiungere funzionalità, ho bisogno di rivedere Singleton e mi sono pentito di aver individuato ogni luogo in cui ho usato MySingleton.getInstance () .

L'approccio 2 di passaggio di un oggetto di informazione globale attraverso i vari costruttori è più facile da controllare.

Anche l'uso di un setter esplicito aiuta.

class MyConfig extends Properties {...}

class SomeClass {
    MyConfig theConfig;
    public void setConfi( MyConfig c ) {
        theConfig= c;
    }
    ...
}

Funziona bene e sarai felice di aver controllato con precisione quali classi hanno effettivamente bisogno delle informazioni di configurazione.

Answer 3

Se le proprietà sono necessarie per molte classi, sceglierei l'approccio 1. O forse una variante in cui si utilizza il modello di progettazione Singleton anziché tutti i metodi statici. Ciò significa che non è necessario continuare a passare alcuni oggetti proprietà in giro. D'altra parte, se solo poche classi hanno bisogno di queste proprietà, potresti scegliere l'approccio 2, per i motivi che hai citato. Potresti anche chiederti quanto è probabile che le classi che scrivi vengano effettivamente riutilizzate e, in tal caso, quanto è problematico riutilizzare anche l'oggetto proprietà. Se il riutilizzo non è probabile, non preoccuparti ora e scegli la soluzione più semplice per la situazione attuale.

Answer 4

Sembra che tu abbia bisogno di un componente di Configuration Manager. Potrebbe essere trovato tramite una sorta di localizzatore di servizi, che potrebbe essere semplice come ConfigurationManagerClass.instance () . Questo incapsulerebbe tutto quel divertimento. Oppure potresti usare un framework di iniezione di dipendenza come Spring.

Molto dipende da come i componenti si trovano nella tua architettura. Se gli altri componenti vengono passati come riferimenti, farlo. Sii coerente.

Answer 5

Se stai cercando qualcosa di veloce puoi usare le proprietà di Sistema, che sono disponibili per tutte le classi. È possibile memorizzare un valore String o se è necessario memorizzare un elenco di "elementi" è possibile utilizzare il metodo System.Properties (). Ciò restituisce un oggetto "Proprietà" che è una HashTable. È quindi possibile memorizzare ciò che si desidera nella tabella. Non è carino ma è un modo rapido per avere proprietà globali. YMMV

Answer 6

Di solito vado per un oggetto singleton che risiede in un progetto comune e contiene una tabella hash di se stessa codificata nello spazio dei nomi, risultante in una classe di proprietà per ciascuno.

L'iniezione di dipendenza è anche un bel modo di farlo.

Answer 7

Mi sento più a mio agio quando ho un puntatore statico alle mie proprietà in memoria. alcune volte si desidera ricaricare le proprietà in runtime o altre funzionalità più facili da implementare con un riferimento statico.

ricorda solo che nessuna classe è un'isola. una classe riutilizzabile può avere una classe client per mantenere il core libero dal riferimento singletone.

puoi anche usare le interfacce, prova solo a non esagerare.

Answer 8

L'approccio 2 è decisamente migliore.

Ad ogni modo, non dovresti permettere ad altre classi di cercare oggetti config. Dovresti inserire la configurazione presa nell'oggetto di configurazione all'esterno dell'oggetto.

Dai un'occhiata a apache commons configuration per aiuto con la configurazione Impl.

Quindi in main () potresti avere

MyObject mobj = new MyObject();
mobj.setLookupDelay(appConfig.getMyObjectLookupDelay);
mobj.setTrackerName(appConfig.getMyObjectTrackerName);

Invece di

MyObject mobj = new MyObject();
mobj.setConfig(appConfig);

dove appConfig è un wrapper attorno alla libreria di configurazione di apache che esegue tutta la ricerca della base valori sul nome del valore in un file di configurazione.

in questo modo il tuo oggetto diventa facilmente testabile.

Answer 9

Java non funziona da un po ', ma non puoi semplicemente mettere le tue proprietà nelle proprietà java.lang.System? In questo modo puoi accedere ai valori da qualsiasi luogo ed evitare di avere un " globale " classe di proprietà.