java - variable - Obtener int, float, booleano y cadena de propiedades
variables java oracle (7)
Dambros tiene razón, todo lo que almacena dentro de un archivo de Propiedades es como un valor de Cadena. Puede hacer un seguimiento de sus diferentes tipos de datos primitivos después de recuperar el valor de las propiedades como se muestra a continuación, como ref. -
Archivo de propiedades de Java: ¿Cómo leer los valores de config.properties en Java?
package crunchify.com.tutorial;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Date;
import java.util.Properties;
/**
* @author Crunchify.com
*
*/
public class CrunchifyGetPropertyValues {
String result = "";
InputStream inputStream;
public String getPropValues() throws IOException {
try {
Properties prop = new Properties();
String propFileName = "config.properties";
inputStream = getClass().getClassLoader().getResourceAsStream(propFileName);
if (inputStream != null) {
prop.load(inputStream);
} else {
throw new FileNotFoundException("property file ''" + propFileName + "'' not found in the classpath");
}
Date time = new Date(System.currentTimeMillis());
// get the property value and print it out
String user = prop.getProperty("user");
String company1 = prop.getProperty("company1");
String company2 = prop.getProperty("company2");
String company3 = prop.getProperty("company3");
result = "Company List = " + company1 + ", " + company2 + ", " + company3;
System.out.println(result + "/nProgram Ran on " + time + " by user=" + user);
} catch (Exception e) {
System.out.println("Exception: " + e);
} finally {
inputStream.close();
}
return result;
}
}
y luego convertir a primitivo - ¿Cómo convertir una cadena a un valor de tipo primitivo?
Le sugiero que realice un seguimiento del valor de los tipos de datos colocando los valores clave dentro de la instrucción de cambio de tipo de cadena y luego recupere el valor del tipo de datos relacionado mediante el uso de casos de nombre de clave. Es posible cambiar el tipo de cadena después de Java 7.
Tengo int, float, booleano y cadena del archivo de propiedades. Todo se ha cargado en Propiedades. Actualmente, estoy analizando los valores, ya que sé el valor esperado para una clave en particular.
Boolean.parseBoolean("false");
Integer.parseInt("3")
¿Cuál es la mejor manera de establecer estos valores de constantes? Si no sé cuál podría ser el tipo de datos de valor primitivo para una clave.
public class Messages {
Properties appProperties = null;
FileInputStream file = null;
public void initialization() throws Exception {
appProperties = new Properties();
try {
loadPropertiesFile();
} catch (Exception e) {
throw new Exception(e.getMessage(), e);
}
}
public void loadPropertiesFile() throws IOException {
String path = "./cfg/message.properties";
file = new FileInputStream(path);
appProperties.load(file);
file.close();
}
}
Archivo de propiedades. messassge.properties
SSO_URL = https://example.com/connect/token
SSO_API_USERNAME = test
SSO_API_PASSWORD = Uo88YmMpKUp
SSO_API_SCOPE = intraday_api
SSO_IS_PROXY_ENABLED = false
SSO_MAX_RETRY_COUNT = 3
SSO_FLOAT_VALUE = 3.0
Constant.java
public class Constants {
public static String SSO_URL = null;
public static String SSO_API_USERNAME = null;
public static String SSO_API_PASSWORD = null;
public static String SSO_API_SCOPE = null;
public static boolean SSO_IS_PROXY_ENABLED = false;
public static int SSO_MAX_RETRY_COUNT = 0;
public static float SSO_FLOAT_VALUE = 0;
}
No estoy completamente seguro de si entiendo exactamente el problema, pero una posibilidad podría ser incluir el tipo de valor de la propiedad en el valor (Cadena). Entonces, por ejemplo, las propiedades que mostraste se convertirían en algo como:
SSO_URL = URL:https://example.com/connect/token
SSO_API_USERNAME = STRING:test
SSO_API_PASSWORD = STRING:Uo88YmMpKUp
SSO_API_SCOPE = STRING:intraday_api
SSO_IS_PROXY_ENABLED = BOOLEAN:false
SSO_MAX_RETRY_COUNT = INTEGER:3
SSO_FLOAT_VALUE = FLOAT:3.0
Durante el análisis de los valores de propiedad, primero determina el tipo de propiedad mirando la parte anterior : y utilice la parte posterior para el análisis real.
private static Object getValue(Properties props, String name) {
String propertyValue = props.getProperty(name);
if (propertyValue == null) {
throw new IllegalArgumentException("Missing configuration value: " + name);
} else {
String[] parts = string.split(":");
switch(parts[0]) {
case "STRING":
return parts[1];
case "BOOLEAN":
return Boolean.parseBoolean(parts[1]);
....
default:
throw new IllegalArgumentException("Unknown configuration value type: " + parts[0]);
}
}
}
Puede definir sus parámetros configurables como ''estáticos'' en su clase de elección, y desde una llamada de inicio estática a un método que carga los valores de los parámetros desde un archivo de propiedades.
Por ejemplo:
public class MyAppConfig {
final static String propertiesPath="/home/workspace/MyApp/src/config.properties";
static String strParam;
static boolean boolParam;
static int intParam;
static double dblParam;
static {
// Other static initialization tasks...
loadParams();
}
private static void loadParams(){
Properties prop = new Properties();
try (InputStream propStream=new FileInputStream(propertiesPath)){
// Load parameters from config file
prop.load(propStream);
// Second param is default value in case key-pair is missing
strParam=prop.getProperty("StrParam", "foo");
boolParam=Boolean.parseBoolean(prop.getProperty("boolParam", "false"));
intParam= Integer.parseInt(prop.getProperty("intParam", "1"));
dblParam=Double.parseDouble(prop.getProperty("dblParam", "0.05"));
} catch (IOException e) {
logger.severe(e.getMessage());
e.printStackTrace();
}
}
}
Si conoce el tipo de constante, puede usar Apache Commons Collections .
Por ejemplo, puede usar algún método de utilidades basado en el tipo de su constante.
booelan SSO_IS_PROXY_ENABLED = MapUtils.getBooleanValue(appProperties, "SSO_IS_PROXY_ENABLED", false);
String SSO_URL = MapUtils.getString(appProperties, "SSO_URL", "https://example.com/connect/token");
Incluso puedes usar valores por defecto para evitar errores.
Si tiene una clase de valores de configuración, como su clase de Constants , y desea cargar todos los valores de un archivo de configuración (propiedades), puede crear una pequeña clase auxiliar y usar la reflexión:
public class ConfigLoader {
public static void load(Class<?> configClass, String file) {
try {
Properties props = new Properties();
try (FileInputStream propStream = new FileInputStream(file)) {
props.load(propStream);
}
for (Field field : configClass.getDeclaredFields())
if (Modifier.isStatic(field.getModifiers()))
field.set(null, getValue(props, field.getName(), field.getType()));
} catch (Exception e) {
throw new RuntimeException("Error loading configuration: " + e, e);
}
}
private static Object getValue(Properties props, String name, Class<?> type) {
String value = props.getProperty(name);
if (value == null)
throw new IllegalArgumentException("Missing configuration value: " + name);
if (type == String.class)
return value;
if (type == boolean.class)
return Boolean.parseBoolean(value);
if (type == int.class)
return Integer.parseInt(value);
if (type == float.class)
return Float.parseFloat(value);
throw new IllegalArgumentException("Unknown configuration value type: " + type.getName());
}
}
Entonces lo llamas así:
ConfigLoader.load(Constants.class, "/path/to/constants.properties");
Puede ampliar el código para manejar más tipos. También puede cambiarlo para ignorar las propiedades faltantes, en lugar de fallar como lo hace ahora, de manera que las asignaciones en la declaración de campo permanecerán sin cambios, es decir, serán las predeterminadas.
Siga el patrón de configuración de dropwizard donde define sus constantes usando YAML en lugar de Propiedades y use Jackson para deserializarlo en su Clase. Aparte del tipo de seguridad, el patrón de configuración de dropwizard va un paso más allá al permitir que las anotaciones del Hibernate Validator validen que los valores caen en los rangos esperados.
Para el ejemplo de dropwizard ...
Para más información sobre la tecnología involucrada ...
- github.com/FasterXML/jackson-dataformat-yaml
- hibernate.org/validator/
Spring Boot tiene listo para usar y la solución de alcance de características para las propiedades de configuración seguras para el tipo .
Definitivamente, el uso de Spring solo para esta tarea es excesivo, pero Spring tiene muchas características geniales y esta puede atraerlo hacia el lado derecho;)