È possibile includere file di pacchetti di risorse all'interno di un gruppo di risorse

Question

Stiamo utilizzando java.util.ResourceBundle per caricare le informazioni sulle proprietà. Il nostro file di proprietà è diventato così grande e stiamo pensando di suddividere il file di proprietà principale in diversi sottomoduli. È possibile raggiungere questo?

master.properties 

==> 

master.properties 
    include moduleA.properties 
    include moduleB.properties 

Fammi sapere?

Answer 1

Prima di tutto, mi chiedo perché hai scelto java.util.ResourceBundle su java.util.Properties. Dato il modo in cui viene formulata la tua domanda, non ti sembra interessare la localizzazione/internazionalizzazione né l'ereditarietà del file bundle.

Con Properties è straordinariamente facile poiché implementa Map che a sua volta offre un metodo putAll() per unire un'altra mappa. Kickoff esempio:

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. 

Se proprio insisti nell'utilizzo ResourceBundle, la soluzione migliore è quella di creare un costume ResourceBundle in cui si contol il carico corrispondente a una personalizzato Control.

Supponendo che hai la seguente voce in master.properties che rappresenta una stringa commaseparated con nomi di base dei file Proprietà del modulo:

include=moduleA,moduleB 

Poi il seguente personalizzato ResourceBundle esempio dovrebbe funzionare:

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

} 

(la manipolazione delle eccezioni e la gestione della localizzazione sono trascurate, dipende da voi)

Questo può essere usato come:

ResourceBundle bundle = new MultiResourceBundle("master"); 

Answer 2

È possibile tuttavia, in modo programmatico, creare ResourceBundle ma, come si dice, il file è enorme, e se viene caricato in memoria.

aggiornamento

public class Resource extends java.util.ResourceBundle { 



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

    public Enumeration getKeys() { 
     //code 
    } 
} 

poi per IN locale

import java.util.*; 

public class Resource_en_IN extends Resource{ 

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

Answer 3

Più cibo per la mente di una soluzione testata.

I file XML supportano le entità inline da altri file durante l'analisi. Se si vedono file xml complessi, dove questa tecnica è stata utilizzata per modulare i file.

Properties ora supporta due formati di file, il formato comune .properties con coppie chiave/valore e un formato xml. Properties può caricare e memorizzare su/da file xml.

ResourceBundle ha una sottoclasse diretta: PropertyResourceBundle. Sembra che questa classe sia effettivamente limitata al vecchio formato di coppia chiave/valore, ma potrebbe essere utilizzata per implementare un'altra classe, come XMLPropertyResourceBundle che è in grado di leggere le proprietà da file xml dove il trucco entity potrebbe aiutare a modulare questi file.

Se questo funziona, la trasformazione dei file di proprietà esistenti in file di proprietà xml dovrebbe essere semplice, basta usare la classe Properties, leggere dal formato standard e archiviare in XML.