É possível incluir arquivos de pacote de recursos em um pacote de recursos

Question

Nós estamos usando java.util.ResourceBundle para carregar informações da propriedade. Nosso arquivo de propriedade cresceu tão grande e estamos pensando em dividir o arquivo de propriedades mestre em vários sub -módulos. É possível conseguir isso?

master.properties

==> 

 master.properties
   include moduleA.properties
   include moduleB.properties

Avise?

Answer 1

Primeiro de tudo, eu me pergunto por que você escolheu java.util.ResourceBundle sobre java.util.Properties. Dado como sua pergunta é formulada, você parece não se importar com localização/internacionalização nem sobre herança de arquivos de pacote.

Com Properties É extraordinário fácil, pois implementa Map que por sua vez oferece um putAll() Método para mesclar outro mapa. Exemplo de kickoff:

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 você realmente insiste em usar ResourceBundle, sua melhor aposta é criar um costume ResourceBundle onde você contém o carregamento por um costume Control.

Supondo que você tenha a seguinte entrada em master.properties que representa uma string comaseuada com nomes básicos dos arquivos de propriedades do módulo:

include=moduleA,moduleB

Então o seguinte costume ResourceBundle Exemplo deve 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;
        }
    }

}

(O manuseio de exceção trivial e o manuseio de localização são deixados de lado, isso depende de você)

Isso pode ser usado como:

ResourceBundle bundle = new MultiResourceBundle("master");

Answer 2

Você pode programar, no entanto, construir o ResourceBundle, mas como está dizendo que seu arquivo é enorme, e se ele for carregado na memória.

atualizar

public class Resource extends java.util.ResourceBundle {



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

    public Enumeration getKeys() {
         //code
    }
}

então para no local

import java.util.*;

public class Resource_en_IN extends Resource{

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

Answer 3

Mais comida para o pensamento do que uma solução testada.

Suporte de arquivos XML entidades para o texto embutido de outros arquivos durante a análise. Se visto arquivos XML complexos, onde essa técnica foi usada para modularizar os arquivos.

Properties agora suporta dois formatos de arquivo, o comum .properties formato com pares de chave/valor e formatos XML. Properties pode carregar e armazenar de/a partir de arquivos XML.

ResourceBundle tem uma subclasse direta: PropertyResourceBundle. Parece que essa classe está realmente limitada ao formato mais antigo do par de chave/valor, mas pode ser usado para implementar outra classe, como XMLPropertyResourceBundle que é capaz de ler propriedades de arquivos XML onde o entity O Trick pode ajudar a modularizar esses arquivos.

Se isso funcionar - transformar os arquivos de propriedades existentes em arquivos de propriedades XML devem ser fáceis, basta usar o Properties Classe, leia do formato padrão e armazene para XML.