web-dev-qa-db-fra.com

Meilleure façon de représenter un tableau dans un fichier de propriétés Java

Je suis en train de créer un fichier .properties qui doit être chargé et transformé en tableau. Mais il est possible qu’il existe entre 0 et 25 de chacune des clés de propriété. J'ai essayé quelques implémentations mais je suis juste coincé à le faire proprement. Quelqu'un a des idées?

foo.1.filename=foo.txt
foo.1.expire=200

foo.2.filename=foo2.txt
foo.2.expire=10

etc more foo's

bar.1.filename=bar.txt
bar.1.expire=100

où je vais assembler les paires nom de fichier/expire dans un objet de données, dans le cadre d'un tableau pour chaque élément de propriété parent tel que foo[myobject]

Le formatage du fichier de propriétés peut changer, je suis ouvert aux idées.

javaarraysenumsproperties
45
yep

Définissez un délimiteur qui ne sera pas une valeur potentielle ou apprenez à utiliser XML.

Si vous persistez à utiliser les propriétés, utilisez l’une des méthodes permettant de renvoyer une liste de toutes les clés. Votre clé semble comporter trois parties: un identificateur de groupe (foo, bar), un index (1, 2), puis un nom d'élément (nom de fichier, expiration). Obtenez toutes les clés les briser en leurs composants. Créez une liste pour chaque type d'identifiant. Lors du traitement de la liste, utilisez l'identifiant pour déterminer la liste à ajouter. Créez vos éléments appariés comme vous l'avez dit et ajoutez-les simplement à la liste! Si l'ordre de l'index est important, ajoutez-le sous forme de champ à vos éléments couplés ou triez les clés avant le traitement.

11
BigMac66

Vous n’avez pas exactement compris votre intention ... Vérifiez la bibliothèque de configuration d’Apache Commons http://commons.Apache.org/configuration/

Vous pouvez avoir plusieurs valeurs contre une clé comme dans Key = valeur1, valeur2 .__ et vous pouvez le lire dans un tableau sous la forme configuration.getAsStringArray("key").

11
Venu K

Je recommande fortement d'utiliser Apache Commons (http://commons.Apache.org/configuration/). Il peut utiliser un fichier XML en tant que fichier de configuration. L'utilisation d'une structure XML facilite la représentation des tableaux sous forme de listes de valeurs plutôt que de propriétés numérotées. 

4
Jack Cox

J'ai un chargement personnalisé. Les propriétés doivent être définies comme suit:

key.0=value0
key.1=value1
...

Chargement personnalisé:

/** Return array from properties file. Array must be defined as "key.0=value0", "key.1=value1", ... */
public List<String> getSystemStringProperties(String key) {

    // result list
    List<String> result = new LinkedList<>();

    // defining variable for assignment in loop condition part
    String value;

    // next value loading defined in condition part
    for(int i = 0; (value = YOUR_PROPERTY_OBJECT.getProperty(key + "." + i)) != null; i++) {
        result.add(value);
    }

    // return
    return result;
}
3
somtomas

Utilisez les fichiers YAML pour les propriétés, cela prend en charge les propriétés en tant que tableau

Coup d'œil rapide sur YAML:

Un sur-ensemble de JSON, il peut faire tout ce que JSON peut + +

  1. Simple à lire
  2. Propriétés longues en valeurs multilignes
  3. Soutient les commentaires
  4. Propriétés en tant que tableau
  5. Validation YAML
3
Sangeeth

voici une autre façon de le faire en implémentant vous-même le mécanisme 

    /**
     * get a string property's value
     * @param propKey property key
     * @param defaultValue default value if the property is not found
     * @return value
     */
    public static String getSystemStringProperty(String propKey,
            String defaultValue) {
        String strProp = System.getProperty(propKey);
        if (strProp == null) {
            strProp = defaultValue;
        }
        return strProp;
    }

    /**
     * internal recursive method to get string properties (array)
     * @param curResult current result
     * @param paramName property key prefix
     * @param i current indice
     * @return array of property's values
     */
    private static List<String> getSystemStringProperties(List<String> curResult, String paramName, int i) {
        String paramIValue = getSystemStringProperty(paramName + "." + String.valueOf(i), null);
        if (paramIValue == null) {
            return curResult;
        }
        curResult.add(paramIValue);
        return getSystemStringProperties(curResult, paramName, i+1);
    }

    /**
     * get the values from a property key prefix
     * @param paramName property key prefix
     * @return string array of values
     */
    public static String[] getSystemStringProperties(
            String paramName) {
        List<String> stringProperties = getSystemStringProperties(new ArrayList<String>(), paramName, 0);
        return stringProperties.toArray(new String[stringProperties.size()]);
    }

Voici un moyen de tester:

    @Test
    public void should_be_able_to_get_array_of_properties() {
        System.setProperty("my.parameter.0", "ooO");
        System.setProperty("my.parameter.1", "oO");
        System.setProperty("my.parameter.2", "boo");
        // WHEN 
        String[] pluginParams = PropertiesHelper.getSystemStringProperties("my.parameter");

        // THEN
        assertThat(pluginParams).isNotNull();
        assertThat(pluginParams).containsExactly("ooO","oO","boo");
        System.out.println(pluginParams[0].toString());
    }

j'espère que cela t'aides

et toutes les remarques sont les bienvenues ..

1
boly38

Comme l'utilisateur 'Skip Head' l'a déjà souligné, le format CSV ou tout autre fichier de tableau constituerait un meilleur ajustement dans votre cas.

Si c'est une option pour vous, peut-être que cette Table implémentation pourrait vous intéresser.

0
Omnaest