Costanti e proprietà in java

Question

Le best practice Java consigliano le proprietà di lettura come costanti. Quindi, quale pensi che sia l'approccio migliore per raggiungerlo? Il mio approccio è: Una classe Configuration per leggere il file delle proprietà solo una volta (pattern singleton) e utilizzare questa classe per leggere le proprietà quando necessario come costanti. E una classe Constants da memorizzare:

• Il nome delle proprietà per trovarle nel file delle proprietà (ad es. App.database.url).
• Costanti statiche (quelle che non desidero che l'utente configuri, ad esempio CONSTANT_URL = "myurl.com").

public final class Configurations { 

private Properties properties = null; 
private static Configurations instance = null; 

/** Private constructor */ 
private Configurations(){ 
    this.properties = new Properties(); 
    try{ 
     properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream(Constants.PATH_CONFFILE)); 
    }catch(Exception ex){ 
     ex.printStackTrace(); 
    } 
} 

/** Creates the instance is synchronized to avoid multithreads problems */ 
private synchronized static void createInstance() { 
    if (instance == null) { 
     instance = new Configurations(); 
    } 
} 

/** Get the properties instance. Uses singleton pattern */ 
public static Configurations getInstance(){ 
    // Uses singleton pattern to guarantee the creation of only one instance 
    if(instance == null) { 
     createInstance(); 
    } 
    return instance; 
} 

/** Get a property of the property file */ 
public String getProperty(String key){ 
    String result = null; 
    if(key !=null && !key.trim().isEmpty()){ 
     result = this.properties.getProperty(key); 
    } 
    return result; 
} 

/** Override the clone method to ensure the "unique instance" requeriment of this class */ 
public Object clone() throws CloneNotSupportedException { 
    throw new CloneNotSupportedException(); 
}} 

La classe costante contiene i riferimenti alle proprietà e alle costanti.

public class Constants { 
// Properties (user configurable) 
public static final String DB_URL = "db.url"; 
public static final String DB_DRIVER = "db.driver"; 

// Constants (not user configurable) 
public static final String PATH_CONFFILE = "config/config.properties"; 
public static final int MYCONSTANT_ONE = 1; 
} 

E i file di proprietà sarebbero:

db.url=www.myurl.com 
db.driver=mysql 

per leggere le proprietà e costanti sarebbero:

// Constants 
int i = Constants.MYCONSTANT_ONE; 
// Properties 
String url = Configurations.getInstance().getProperty(Constants.DB_URL); 

Pensi che questo è un buon approccio? Qual è il tuo modo di leggere proprietà e costanti in Java?

Grazie in anticipo.

Answer 1

ho trovato una soluzione migliore per omogeneizzare il codice e ha tutto come costanti. Con la stessa classe Configurations e il file .properties: Poiché il metodo getInstance() è statico, è possibile inizializzare le costanti nella classe Costanti.

Una classe per memorizzare il nome alla proprietà nel file .properties:

public class Properties { 
// Properties (user configurable) 
public static final String DB_URL = "db.url"; 
public static final String DB_DRIVER = "db.driver"; 
} 

E allora la classe Costante sarà:

public class Constants { 
// Properties (user configurable) 
public static final String DB_URL = Configurations.getInstance().getProperty(Properties.DB_URL); 
public static final String DB_DRIVER = Configurations.getInstance().getProperty(Properties.DB_DRIVER); 

// Constants (not user configurable) 
public static final String PATH_CONFFILE = "config/config.properties"; 
public static final int MYCONSTANT_ONE = 1; 
} 

E infine usarli:

// Constants 
int i = Constants.MYCONSTANT_ONE; 
// Properties 
String url = Constants.DB_URL; 

Penso che sia una soluzione pulita ed elegante che risolve costanti e problemi di proprietà nei test.

Answer 2

Penso che dovresti dare un'occhiata a Apache Commons Configuration, potresti trovarlo utile. Puoi fare un sacco di cose come avere una gerarchia per i tuoi file di configurazione, specificare più fonti.

per le costanti sembra buona :)