it-swarm.com.de

Holen Sie sich int, float, boolean und string von Properties

Ich habe Int, Float, Boolean und String aus der Eigenschaftendatei. Alles wurde in Eigenschaften geladen. Derzeit analysiere ich Werte, da ich den erwarteten Wert für bestimmte Schlüssel kenne.

Boolean.parseBoolean("false");
Integer.parseInt("3")

Was ist die bessere Möglichkeit, diese Konstantenwerte festzulegen?.

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();
    }
}

Eigenschaftendatei . 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;
}
26

Wenn Sie über eine Klasse von Konfigurationswerten wie Ihre Constants-Klasse verfügen und alle Werte aus einer Konfigurationsdatei (Eigenschaftendatei) laden möchten, können Sie eine kleine Hilfsklasse erstellen und Reflection verwenden:

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());
    }
}

Dann nennen Sie es so:

ConfigLoader.load(Constants.class, "/path/to/constants.properties");

Sie können den Code für weitere Typen erweitern. Sie können es auch so ändern, dass fehlende Eigenschaften ignoriert werden, anstatt wie bisher zu fehlschlagen, sodass Zuweisungen in der Felddeklaration unverändert bleiben, d. H.

25
Andreas

Dambros hat recht, alles, was Sie in einer Eigenschaftendatei speichern, ist ein String-Wert. Sie können Ihre verschiedenen primitiven Datentypen nach dem Abrufen des Eigenschaftswerts wie unter ref abrufen. -

Java-Eigenschaftendatei: Wie werden Werte von config.properties in Java gelesen?

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;
    }
}

und später in primitive konvertieren - Wie konvertiert man String in primitive Typwerte?

Ich empfehle Ihnen, den Wert Ihres Datentyps zu verfolgen, indem Sie die Schlüsselwerte in die String-Anweisung switch eingeben und später den zugehörigen Datentypwert mithilfe von Schlüsselnamenfällen abrufen. __ String-Typwechsel ist nach Java 7 möglich.

5
ArifMustafa

Wenn Sie den Typ der Konstante kennen, können Sie Apache Commons Collections verwenden.

Sie können beispielsweise eine Dienstprogrammmethode verwenden, die auf dem Typ Ihrer Konstante basiert.

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");

Sie können sogar Standardwerte verwenden, um Fehler zu vermeiden.

5
josivan

Ich bin mir nicht ganz sicher, ob ich das Problem genau verstehe, aber eine Möglichkeit könnte darin bestehen, den Typ des Eigenschaftswerts in den (String) -Wert aufzunehmen. Die Eigenschaften, die Sie gezeigt haben, würden beispielsweise so aussehen:

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

Während der Analyse der Eigenschaftswerte bestimmen Sie zunächst den Typ der Eigenschaft, indem Sie den Teil vor : betrachten und den Teil danach für die eigentliche Analyse verwenden. 

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]);
        }
    }
 }
4
uniknow

Folgen Sie dem Drop-Wizard-Konfigurationsmuster, in dem Sie Ihre Konstanten mithilfe von YAML anstelle von Eigenschaften definieren, und verwenden Sie Jackson, um sie in Ihre Klasse zu deserialisieren. Abgesehen von der Typensicherheit geht das Konfigurationsmuster von dropwizard noch einen Schritt weiter, indem es Hibernate Validator-Anmerkungen zulässt, um zu bestätigen, dass die Werte in Ihren erwarteten Bereichen liegen.

Für das Beispiel des Dropwizard ...

Für weitere Informationen zur verwendeten Technologie ...

  • github.com/FasterXML/jackson-dataformat-yaml
  • hibernate.org/validator/
4
Carlos Herrera

Spring Boot verfügt über eine einsatzbereite und funktionsfähige Lösung für die typsichere Konfiguration -Eigenschaft.

Auf jeden Fall ist die Verwendung des Frühlings nur für diese Aufgabe übertrieben, aber Spring bietet viele coole Funktionen und diese können Sie zur rechten Seite ziehen;)

3
Andrew Kolpakov

Sie können Ihre konfigurierbaren Parameter in Ihrer bevorzugten Klasse als "statisch" definieren und von einem statischen Init-Aufruf eine Methode aufrufen, die die Parameterwerte aus einer Eigenschaftendatei lädt. 

Zum Beispiel:

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();
        } 
    }
}
0
Alicia