archivo de propiedades java como enum

Question

¿Es posible convertir un archivo de propiedades en una enumeración?

Tengo un archivo propoerty con gran cantidad de ajustes. por ejemplo

equipment.height 
equipment.widht 
equipment.depth 
and many more like this and not all are as simple as the example 

El desarrollador debe conocer la clave para obtener el valor de la propiedad. en su lugar, es posible hacer algo, donde el desarrollador debe escribir MyPropertyEnum. y la lista de claves se mostrará en el IDE, como se muestra arriba para una enumeración

MyPropertyEnum.height 

Answer 1

que a menudo utilizan archivo de propiedades + combinación de enumeración. Aquí está un ejemplo:

public enum Constants { 
    PROP1, 
    PROP2; 

    private static final String PATH   = "/constants.properties"; 

    private static final Logger logger   = LoggerFactory.getLogger(Constants.class); 

    private static Properties properties; 

    private String   value; 

    private void init() { 
     if (properties == null) { 
      properties = new Properties(); 
      try { 
       properties.load(Constants.class.getResourceAsStream(PATH)); 
      } 
      catch (Exception e) { 
       logger.error("Unable to load " + PATH + " file from classpath.", e); 
       System.exit(1); 
      } 
     } 
     value = (String) properties.get(this.toString()); 
    } 

    public String getValue() { 
     if (value == null) { 
      init(); 
     } 
     return value; 
    } 

} 

Ahora también necesita un archivo de propiedades (I ofter coloco en src, por lo que se empaqueta en JAR), con propiedades tal como lo hacía en la enumeración. Por ejemplo:

constants.properties:

#This is property file... 
PROP1=some text 
PROP2=some other text 

Ahora utilizo muy a menudo importación estática en las clases donde quiero utilizar mis constantes:

import static com.some.package.Constants.*; 

Y un ejemplo de uso de

System.out.println(PROP1); 

Answer 2

no, yo no lo creo. Los mensajes se crean en tiempo de compilación y, por lo tanto, su número de elementos no puede variar según lo que esté en el archivo de propiedades.

Es más probable que lo que se necesita una estructura que sea flexible a construirse en tiempo de ejecución - tal vez una matriz asociativa.

Answer 3

Java tiene tipos estáticos. Eso significa que no puede crear tipos dinámicamente. Entonces, la respuesta es no. No puede convertir un archivo de propiedades en una enumeración.

Lo que podría hacer es generar un enum de ese archivo de propiedades. O bien, utilizar un diccionario (Mapa) para acceder a sus propiedades con algo como:

equipment.get("height"); 

Answer 4

No. Bueno, supongo que se podría si se puede compilar un archivo de propiedades en una clase Java (o enumeración). No puedo encontrar nada de eso (pero sería muy frío)

Answer 5

Puede convertir un archivo de propiedades en una enumeración con el código generado. Puede hacerlo de forma estática antes de compilar el programa y, opcionalmente, en tiempo de ejecución utilizando la API del compilador. Hacer esto agrega mucha complejidad y, por lo general, es más sencillo utilizar un mapa como se ha sugerido.

Answer 6

Una forma, podría imaginar, para obtener todas las propiedades en su IDE puede ser definir un Enum con todos ellos, así:

public enum Settings 
{ 
    EQUIPMENT_HEIGHT("equipment.height", "0"), 

    EQUIPMENT_WIDTH("equipment.width", "0"), 

    EQUIPMENT_DEPTH("equipment.depth", "0"); 

    private String property; 

    private String value; 

    Settings(final String aProperty, final String aValue) 
    { 
     property = aProperty; 
     value = aValue; 
    } 

    public String getProperty() 
    { 
     return property; 
    } 

    public String getValue() 
    { 
     return value; 
    } 

    private void setValue(final String aValue) 
    { 
     value = aValue; 
    } 

    public static void initialize(final Properties aPropertyTable) 
    { 
     for(final Settings setting : values()) 
     { 
     final String key = setting.getProperty(); 
     final String defaultValue = setting.getValue(); 
     setting.setValue(aPropertyTable.getProperty(key, defaultValue)); 
     } 
    } 
} 

La inicialización de la enumeración es auto explicado (método initialize()).

Después de eso, se puede utilizar de esta manera:

Settings.EQUIPMENT_HEIGHT.getValue(); 

Adición nueva propiedad es simplemente añadiendo nueva enumeración-Constant.

Answer 7

Se hizo la pregunta sobre enum, quería crear una enumeración basada en la propiedad. Renuncié a la idea, porque esta enumeración debe ser dinámica, si obtenemos un nuevo código de error, debe agregarse al archivo de propiedades. Tristemente, no veo forma de hacer eso con enum, así que elegí una ruta diferente mientras leo que todo el mundo sugiere una solución basada en mapas. En lugar de enum, creé un singleton que solo lee un archivo de propiedades y responde con las palabras clave para devolver el valor.

el archivo de propiedades:

C102 = Blablabla1 
C103 = Blablabla2 
C104 = Blablabla3 

el código de producto único:

package mypackage; 

import java.io.FileInputStream; 
import java.io.IOException; 
import java.util.HashMap; 
import java.util.Map.Entry; 
import java.util.Properties; 

public class ResponseValidationTypeCodes { 

private final HashMap<String, String> codes; 

private static ResponseValidationTypeCodes instance; 

public static ResponseValidationTypeCodes getInstance() { 
    if (instance == null) { 
     instance = new ResponseValidationTypeCodes(); 
    } 
    return instance; 
} 

private ResponseValidationTypeCodes() { 
    super(); 
    codes = new HashMap<String, String>(); 
    initEntry(); 
} 

private void initEntry() { 
    Properties prop = new Properties(); 
    try { 
     prop.load(new FileInputStream(
       "src/main/resources/validationcodes.properties")); 
     for (Entry<Object, Object> element : prop.entrySet()) { 
      codes.put(element.getKey().toString(), element.getValue() 
        .toString()); 
     } 

    } catch (IOException ex) { 
     ex.printStackTrace(); 
    } 
} 

public String getValueByCode(String code) { 
    return codes.get(code); 
} 
} 

para obtener los valores, simplemente llame:

ResponseValidationTypeCodes.getInstance() 
      .getValueByCode("C102"); 

la lectura inicial de la propiedad se ejecuta sólo una vez. Así que solo expandes la propiedad cuando aparece algún cambio y vuelves a desplegar tus cosas ese momento. Espero que ayude a alguien que esté abierto a usar alguna alternativa a enum.

Answer 8

public enum ErrorCode{ 


    DB_ERROR(PropertiesUtil.getProperty("DB_ERRROR_CODE"), PropertiesUtil.getProperty("DB_ERROR")), 
    APP_ERROR(PropertiesUtil.getProperty("APPLICATION_ERROR_CODE"), PropertiesUtil.getProperty("APPLICATION_ERROR")), 
    ERROR_FOUND(PropertiesUtil.getProperty("ERROR_FOUND_CODE"), PropertiesUtil.getProperty("ERROR_FOUND")); 


    private final String errorCode; 
    private final String errorDesc; 



    private ErrorCode(String errorCode, String errorDesc) { 
     this.errorCode = errorCode; 
     this.errorDesc = errorDesc; 
    } 

    public String getErrorDesc() { 
     return errorDesc; 
    } 

    public String getErrorCode() { 
     return errorCode; 
    } 

    public static String getError(String errorCode) 
    { 
     System.out.println("errorCode in Enum"+errorCode); 
     System.out.println(java.util.Arrays.asList(ErrorCode.values())); 
     for (ErrorCode errorEnum : ErrorCode.values()) { 
      System.out.println(errorEnum.errorCode); 
      System.out.println(errorEnum.errorDesc); 
     if ((errorEnum.errorCode).equals(errorCode)) { 
      return errorEnum.getErrorDesc(); 
     } 
     } 
     return ERROR_FOUND.getErrorDesc(); 

    } 


public class PropertiesUtil { 
static Properties prop = new Properties(); 

    static{ 

     try { 

       InputStream inputStream = 
         PropertiesUtil.class.getClassLoader().getResourceAsStream("db.properties"); 

      prop.load(inputStream); 
    }catch(Exception e) 
     { 
     e.printStackTrace(); 
     } 
    } 



     public static PropertiesUtil getInstance() 
     { 

      return new PropertiesUtil(); 
     } 

     public Properties getProperties() 
     { 
      return prop; 
     } 

     public static String getProperty(String key) 
     { 
      return prop.getProperty(key); 
     } 


}