Es posible incluir los recursos haz archivos dentro de un paquete de recursos

Question

Estamos utilizando java.util.ResourceBundle a la información de propiedad de carga. Nuestro archivo de propiedades ha crecido tan grande y estamos pensando en dividir el archivo de utilería en varios submódulos. ¿Es posible lograr esto?

master.properties

==> 

 master.properties
   include moduleA.properties
   include moduleB.properties

Avisadme?

Answer 1

En primer lugar, me pregunto por qué ha elegido java.util.ResourceBundle sobre href="http://download.oracle.com/javase/6/docs/api/java/util/Properties.html" rel="nofollow noreferrer"> java.util.Properties . Dado lo está formulado su pregunta, no parece que se preocupan por la localización / internacionalización, ni sobre la herencia archivo de paquete.

Con Properties es extraordinario fácil, ya que implementa Map que a su vez ofrece un putAll() método para combinar 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 un ResourceBundle a medida que se contol la carga por un encargo Control .

Si se asume 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 ejemplo ResourceBundle personalizado debe trabajar:

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

}

(manejo de excepciones triviales y manejo de localización se deja a un lado, esto depende de usted)

Esto se puede utilizar como:

ResourceBundle bundle = new MultiResourceBundle("master");

Answer 2

Puede programáticamente, sin embargo, la construcción de ResourceBundle pero como usted está diciendo su archivo es enorme entonces lo que si se carga en memoria.

actualización

public class Resource extends java.util.ResourceBundle {



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

    public Enumeration getKeys() {
         //code
    }
}

entonces para IN locale

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 de soporte entidades de texto en línea de otros archivos durante el análisis. Si los archivos XML complejos visto, en los que esta técnica se ha utilizado para modularizar los archivos.

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

ResourceBundle tiene una subclase directa: PropertyResourceBundle. Parece que esta clase es en realidad limita al formato de par de mayores clave / valor, pero podría ser usado para implementar otra clase, como XMLPropertyResourceBundle que es capaz de leer las propiedades de archivos XML, donde el truco entity podría ayudar a modularizar esos archivos.

Si esto funciona -. Transformando los archivos de propiedades existentes en los archivos de propiedades XML debe ser fácil, sólo tiene que utilizar la clase Properties, lee de formato estándar y tienda para XML