¿Es posible incluir archivos de paquete de recursos dentro de un paquete de recursos

Question

Estamos usando java.util.ResourceBundle para cargar información de la propiedad. Nuestro archivo de propiedades ha crecido tanto y estamos pensando en dividir el archivo de propiedad principal en varios submódulos. ¿Es posible lograr esto?

master.properties 

==> 

master.properties 
    include moduleA.properties 
    include moduleB.properties 

Dejarme saber?

Answer 1

Antes que nada, me pregunto por qué ha elegido java.util.ResourceBundle sobre java.util.Properties. Teniendo en cuenta cómo se formula su pregunta, no parece importarle la localización/internacionalización ni la herencia de archivos empaquetados.

Con Properties es extraordinariamente fácil ya que implementa Map que a su vez ofrece un método putAll() para unir otro mapa. Kickoff ejemplo:

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 realmente insisten en el uso de ResourceBundle, lo mejor es crear una costumbre ResourceBundle en donde se contol la carga por una costumbre Control.

Asumiendo que usted tiene la siguiente entrada en master.properties que representa una cadena commaseparated con los nombres de base de los archivos de propiedades del módulo:

include=moduleA,moduleB 

A continuación, el siguiente encargo ResourceBundle ejemplo debería funcionar:

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

} 

(se deja de lado el manejo trivial de excepciones y la localización, esto depende de usted)

Esto se puede utilizar como:

ResourceBundle bundle = new MultiResourceBundle("master"); 

Answer 2

Sin embargo, puede programar ResourceBundle, pero como está diciendo que su archivo es enorme, entonces ¿qué ocurre si se carga en la memoria?

actualización

public class Resource extends java.util.ResourceBundle { 



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

    public Enumeration getKeys() { 
     //code 
    } 
} 

continuación, en el entorno local para

import java.util.*; 

public class Resource_en_IN extends Resource{ 

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

Answer 3

Más Alimento para el pensamiento de una solución probada.

Los archivos XML admiten entidades para incorporar texto de otros archivos durante el análisis. Si se ven archivos XML complejos, donde esta técnica se ha utilizado para modularizar los archivos.

Properties ahora admite dos formatos de archivo, el formato .properties común con pares de clave/valor y un formato xml. Properties puede cargar y almacenar en/desde archivos xml.

tiene una subclase directa: PropertyResourceBundle. Parece que esta clase está limitada al formato de par clave/valor anterior, pero podría usarse para implementar otra clase, como XMLPropertyResourceBundle, que es capaz de leer propiedades de archivos xml donde el truco entity podría ayudar a modularizar esos archivos.

Si esto funciona, la transformación de los archivos de propiedades existentes en archivos de propiedades xml debería ser fácil, solo use la clase Properties, lea desde el formato estándar y almacene en XML.