Est-il possible d'inclure des fichiers de faisceau de ressources au sein d'un groupe de ressources

Question

Nous utilisons java.util.ResourceBundle pour charger des informations de propriété. Notre dossier de propriété est devenu si énorme et nous pensons à diviser le fichier maître propriété en plusieurs sous-modules. Est-il possible d'y parvenir?

master.properties

==> 

 master.properties
   include moduleA.properties
   include moduleB.properties

Permettez-moi?

Answer 1

D'abord, je me demande pourquoi vous avez choisi java.util.Properties . Étant donné la façon dont votre question est formulée, vous ne semblez pas se soucier de la localisation / internationalisation, ni sur l'héritage de fichiers bundle.

Avec Properties il est extraordinaire facile car il met en œuvre Map qui à son tour offre une putAll() méthode pour fusionner une autre carte. par exemple le coup d'envoi:

Properties master = new Properties();
master.load(masterInput);

Properties moduleA = new Properties();
moduleA.load(moduleAinput);
master.putAll(moduleA);

Properties moduleB = new Properties();
moduleB.load(moduleBinput);
master.putAll(moduleB);

// Now `master` contains the properties of all files.

Si vous insistez vraiment à utiliser ResourceBundle, votre meilleur pari est de créer un ResourceBundle personnalisé dans laquelle vous contôle le chargement par une coutume Control .

En supposant que vous avez l'entrée suivante dans master.properties qui représente une chaîne commaseparated avec des noms de base des propriétés du module fichiers:

include=moduleA,moduleB

Alors l'exemple ResourceBundle personnalisé devrait fonctionner:

public class MultiResourceBundle extends ResourceBundle {

    protected static final Control CONTROL = new MultiResourceBundleControl();
    private Properties properties;

    public MultiResourceBundle(String baseName) {
        setParent(ResourceBundle.getBundle(baseName, CONTROL));
    }

    protected MultiResourceBundle(Properties properties) {
        this.properties = properties;
    }

    @Override
    protected Object handleGetObject(String key) {
        return properties != null ? properties.get(key) : parent.getObject(key);
    }

    @Override
    @SuppressWarnings("unchecked")
    public Enumeration<String> getKeys() {
        return properties != null ? (Enumeration<String>) properties.propertyNames() : parent.getKeys();
    }

    protected static class MultiResourceBundleControl extends Control {
        @Override
        public ResourceBundle newBundle(
            String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
                throws IllegalAccessException, InstantiationException, IOException
        {
            Properties properties = load(baseName, loader);
            String include = properties.getProperty("include");
            if (include != null) {
                for (String includeBaseName : include.split("\\s*,\\s*")) {
                    properties.putAll(load(includeBaseName, loader));
                }
            }
            return new MultiResourceBundle(properties);
        }

        private Properties load(String baseName, ClassLoader loader) throws IOException {
            Properties properties = new Properties();
            properties.load(loader.getResourceAsStream(baseName + ".properties"));
            return properties;
        }
    }

}

(gestion des exceptions trivial et le traitement de la localisation est laissée de côté, c'est à vous)

Ceci peut être utilisé comme:

ResourceBundle bundle = new MultiResourceBundle("master");

Answer 2

Vous pouvez programatically, cependant, construire ResourceBundle mais comme vous dites votre dossier est énorme alors s'il est chargé dans la mémoire.

mise à jour

public class Resource extends java.util.ResourceBundle {



    public Object handleGetObject(String key) {
         //code
    }

    public Enumeration getKeys() {
         //code
    }
}

puis pour les paramètres régionaux IN

import java.util.*;

public class Resource_en_IN extends Resource{

  public Object handleGetObject(String key) {
    //code
  }
}

Answer 3

plus de nourriture pour la pensée qu'une solution testée.

Les fichiers XML prennent en charge entités texte en ligne à partir d'autres fichiers lors de l'analyse. Si les fichiers XML complexes, vu où cette technique a été utilisée pour modulariser les fichiers.

Properties prend désormais en charge deux formats de fichiers, le format .properties commun avec des paires clé / valeur et un format XML. Properties peut charger et stocker à / à partir de fichiers XML.

ResourceBundle a une sous-classe directe: PropertyResourceBundle. On dirait que cette classe est en fait limitée au format paire clé / valeur plus ancienne, mais il pourrait être utilisé pour mettre en œuvre une autre classe, comme XMLPropertyResourceBundle qui est capable de propriétés lire des fichiers xml où l'astuce entity pourrait aider à modularisation ces fichiers.

Si cela fonctionne -. Transformer les fichiers de propriété existants aux propriétés XML des fichiers devrait être facile, il suffit d'utiliser la classe Properties, lire du format standard et stocker au format XML