Comment utiliser UTF-8 dans les propriétés de ressource avec ResourceBundle

J'ai besoin d'utiliser UTF-8 dans mes propriétés de ressource en utilisant Java ResourceBundle. Lorsque j'entre le texte directement dans le fichier de propriétés, il s'affiche sous forme de mojibake.

Mon application s'exécute sur Google App Engine.

Quelqu'un peut-il me donner un exemple? Je ne peux pas obtenir ce travail.

Les ResourceBundle#getBundle()utilisations sous les couvertures PropertyResourceBundlelorsqu'un .propertiesfichier est spécifié. Ceci à son tour utilise par défaut Properties#load(InputStream)pour charger ces fichiers de propriétés. Selon le javadoc , ils sont par défaut lus comme ISO-8859-1.

public void load(InputStream inStream) throws IOException

Lit une liste de propriétés (paires de clés et d'éléments) dans le flux d'octets d'entrée. Le flux d'entrée est dans un format simple orienté ligne comme spécifié dans la charge (Reader) et est supposé utiliser le codage de caractères ISO 8859-1 ; c'est-à-dire que chaque octet est un caractère Latin1. Les caractères qui ne sont pas en Latin1 et certains caractères spéciaux sont représentés dans des clés et des éléments utilisant des échappements Unicode comme défini dans la section 3.3 de la spécification du langage Java ™.

Vous devez donc les enregistrer au format ISO-8859-1. Si vous avez des caractères au-delà de la plage ISO-8859-1 et que vous ne pouvez pas les utiliser \uXXXXde haut en bas et que vous êtes donc obligé d'enregistrer le fichier au format UTF-8, vous devrez utiliser l' outil native2ascii pour convertir un Fichier de propriétés enregistrées UTF-8 dans un fichier de propriétés enregistrées ISO-8859-1 dans lequel tous les caractères découverts sont convertis au \uXXXXformat. L'exemple ci-dessous convertit un fichier de propriétés codées UTF-8 text_utf8.propertiesen un fichier de propriétés codées ISO-8859-1 valide text.properties.

native2ascii -encoding UTF-8 text_utf8.properties text.properties

Lorsque vous utilisez un IDE sain comme Eclipse, cela se fait déjà automatiquement lorsque vous créez un .propertiesfichier dans un projet basé sur Java et utilisez le propre éditeur d'Eclipse. Eclipse convertira de manière transparente les caractères au-delà de la plage ISO-8859-1 au \uXXXXformat. Voir également les captures d'écran ci-dessous (notez les onglets "Propriétés" et "Source" en bas, cliquez pour agrandir):

Alternativement, vous pouvez également créer une ResourceBundle.Controlimplémentation personnalisée dans laquelle vous lisez explicitement les fichiers de propriétés au format UTF-8 InputStreamReader, afin de pouvoir simplement les enregistrer au format UTF-8 sans avoir à vous encombrer native2ascii. Voici un exemple de lancement:

public class UTF8Control extends Control {
    public ResourceBundle newBundle
        (String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
            throws IllegalAccessException, InstantiationException, IOException
    {
        // The below is a copy of the default implementation.
        String bundleName = toBundleName(baseName, locale);
        String resourceName = toResourceName(bundleName, "properties");
        ResourceBundle bundle = null;
        InputStream stream = null;
        if (reload) {
            URL url = loader.getResource(resourceName);
            if (url != null) {
                URLConnection connection = url.openConnection();
                if (connection != null) {
                    connection.setUseCaches(false);
                    stream = connection.getInputStream();
                }
            }
        } else {
            stream = loader.getResourceAsStream(resourceName);
        }
        if (stream != null) {
            try {
                // Only this line is changed to make it to read properties files as UTF-8.
                bundle = new PropertyResourceBundle(new InputStreamReader(stream, "UTF-8"));
            } finally {
                stream.close();
            }
        }
        return bundle;
    }
}

Cela peut être utilisé comme suit:

ResourceBundle bundle = ResourceBundle.getBundle("com.example.i18n.text", new UTF8Control());

Voir également:

• Unicode - Comment obtenir les bons caractères?

Étant donné que vous disposez d'une instance de ResourceBundle et que vous pouvez obtenir String par:

String val = bundle.getString(key); 

J'ai résolu mon problème d'affichage japonais en:

return new String(val.getBytes("ISO-8859-1"), "UTF-8");

regardez ceci: http://docs.oracle.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader)

les propriétés acceptent un objet Reader comme arguments, que vous pouvez créer à partir d'un InputStream.

au moment de la création, vous pouvez spécifier l'encodage du Reader:

InputStreamReader isr = new InputStreamReader(stream, "UTF-8");

puis appliquez ce Reader à la méthode de chargement:

prop.load(isr);

BTW: récupérez le flux depuis le fichier .properties :

 InputStream stream = this.class.getClassLoader().getResourceAsStream("a.properties");

BTW: obtenez un ensemble de ressources à partir de InputStreamReader:

ResourceBundle rb = new PropertyResourceBundle(isr);

j'espère que cela peut vous aider!

ResourceBundle.Control avec UTF-8 et les nouvelles méthodes String ne fonctionnent pas, si le fichier de propriétés utilise le jeu de caractères cp1251, par exemple.

J'ai donc recommandé d'utiliser une méthode commune: écrire en symboles unicode . Pour ça:

IDEA - dispose d'une option spéciale " Conversion native native vers ASCII transparente " (Paramètres> Encodage de fichier).

Eclipse - possède un plugin " Propriétés Editor " . Il peut fonctionner comme une application distincte.

Ce problème a finalement été corrigé dans Java 9: https://docs.oracle.com/javase/9/intl/internationalization-enhancements-jdk-9

Le codage par défaut des fichiers de propriétés est désormais UTF-8.

La plupart des fichiers de propriétés existants ne devraient pas être affectés: UTF-8 et ISO-8859-1 ont le même codage pour les caractères ASCII, et le codage ISO-8859-1 non ASCII lisible par l'homme n'est pas UTF-8 valide. Si une séquence d'octets UTF-8 non valide est détectée, le runtime Java relit automatiquement le fichier dans ISO-8859-1.

Nous créons un fichier resources.utf8 qui contient les ressources en UTF-8 et avons une règle pour exécuter ce qui suit:

native2ascii -encoding utf8 resources.utf8 resources.properties

package com.varaneckas.utils;  

import java.io.UnsupportedEncodingException;  
import java.util.Enumeration;  
import java.util.PropertyResourceBundle;  
import java.util.ResourceBundle;  

/** 
 * UTF-8 friendly ResourceBundle support 
 *  
 * Utility that allows having multi-byte characters inside java .property files. 
 * It removes the need for Sun's native2ascii application, you can simply have 
 * UTF-8 encoded editable .property files. 
 *  
 * Use:  
 * ResourceBundle bundle = Utf8ResourceBundle.getBundle("bundle_name"); 
 *  
 * @author Tomas Varaneckas <tomas.varaneckas@gmail.com> 
 */  
public abstract class Utf8ResourceBundle {  

    /** 
     * Gets the unicode friendly resource bundle 
     *  
     * @param baseName 
     * @see ResourceBundle#getBundle(String) 
     * @return Unicode friendly resource bundle 
     */  
    public static final ResourceBundle getBundle(final String baseName) {  
        return createUtf8PropertyResourceBundle(  
                ResourceBundle.getBundle(baseName));  
    }  

    /** 
     * Creates unicode friendly {@link PropertyResourceBundle} if possible. 
     *  
     * @param bundle  
     * @return Unicode friendly property resource bundle 
     */  
    private static ResourceBundle createUtf8PropertyResourceBundle(  
            final ResourceBundle bundle) {  
        if (!(bundle instanceof PropertyResourceBundle)) {  
            return bundle;  
        }  
        return new Utf8PropertyResourceBundle((PropertyResourceBundle) bundle);  
    }  

    /** 
     * Resource Bundle that does the hard work 
     */  
    private static class Utf8PropertyResourceBundle extends ResourceBundle {  

        /** 
         * Bundle with unicode data 
         */  
        private final PropertyResourceBundle bundle;  

        /** 
         * Initializing constructor 
         *  
         * @param bundle 
         */  
        private Utf8PropertyResourceBundle(final PropertyResourceBundle bundle) {  
            this.bundle = bundle;  
        }  

        @Override  
        @SuppressWarnings("unchecked")  
        public Enumeration getKeys() {  
            return bundle.getKeys();  
        }  

        @Override  
        protected Object handleGetObject(final String key) {  
            final String value = bundle.getString(key);  
            if (value == null)  
                return null;  
            try {  
                return new String(value.getBytes("ISO-8859-1"), "UTF-8");  
            } catch (final UnsupportedEncodingException e) {  
                throw new RuntimeException("Encoding not supported", e);  
            }  
        }  
    }  
}  

Attention: les fichiers de propriétés java doivent être encodés en ISO 8859-1!

Codage de caractères ISO 8859-1. Les caractères qui ne peuvent pas être directement représentés dans cet encodage peuvent être écrits en utilisant des échappements Unicode; un seul caractère «u» est autorisé dans une séquence d'échappement.

@see Properties Java Doc

Si vous voulez toujours vraiment le faire: jetez un œil à: Propriétés Java Encodage UTF-8 dans Eclipse - il y a quelques exemples de code

http://sourceforge.net/projects/eclipse-rbe/

comme déjà indiqué, les fichiers de propriétés doivent être encodés en ISO 8859-1

Vous pouvez utiliser le plug-in ci-dessus pour Eclipse IDE pour effectuer la conversion Unicode pour vous.

Voici une solution Java 7 qui utilise l'excellente bibliothèque de support de Guava et la construction try-with-resources. Il lit et écrit des fichiers de propriétés en utilisant UTF-8 pour l'expérience globale la plus simple.

Pour lire un fichier de propriétés au format UTF-8:

File file =  new File("/path/to/example.properties");

// Create an empty set of properties
Properties properties = new Properties();

if (file.exists()) {

  // Use a UTF-8 reader from Guava
  try (Reader reader = Files.newReader(file, Charsets.UTF_8)) {
    properties.load(reader);
  } catch (IOException e) {
    // Do something
  }
}

Pour écrire un fichier de propriétés au format UTF-8:

File file =  new File("/path/to/example.properties");

// Use a UTF-8 writer from Guava
try (Writer writer = Files.newWriter(file, Charsets.UTF_8)) {
  properties.store(writer, "Your title here");
  writer.flush();
} catch (IOException e) {
  // Do something
}

Comme on l'a suggéré, je suis passé par l'implémentation du bundle de ressources .. mais cela n'a pas aidé .. car le bundle était toujours appelé sous les paramètres régionaux en_US ... j'ai essayé de définir mes paramètres régionaux par défaut dans une langue différente et toujours mon implémentation du bundle de ressources le contrôle était appelé avec en_US ... j'ai essayé de mettre des messages de journal et de faire une étape de débogage et de voir si un appel local différent était en cours après avoir changé les paramètres régionaux au moment de l'exécution via des appels xhtml et JSF ... cela ne s'est pas produit ... puis j'ai essayé de faire un système défini par défaut sur un utf8 pour lire les fichiers par mon serveur (serveur tomcat) .. mais cela a provoqué un pronlem car toutes mes bibliothèques de classes n'étaient pas compilées sous utf8 et tomcat a commencé à lire ensuite au format utf8 et le serveur ne fonctionnait pas correctement ... alors j'ai fini par implémenter une méthode dans mon contrôleur java pour être appelée à partir de fichiers xhtml ..dans cette méthode, j'ai fait ce qui suit:

        public String message(String key, boolean toUTF8) throws Throwable{
            String result = "";
            try{
                FacesContext context = FacesContext.getCurrentInstance();
                String message = context.getApplication().getResourceBundle(context, "messages").getString(key);

                result = message==null ? "" : toUTF8 ? new String(message.getBytes("iso8859-1"), "utf-8") : message;
            }catch(Throwable t){}
            return result;
        }

J'étais particulièrement nerveux car cela pourrait ralentir les performances de mon application ... cependant, après avoir implémenté cela, il semble que mon application est plus rapide maintenant .. je pense que c'est parce que, j'accède maintenant directement aux propriétés au lieu de laisser JSF analyse son chemin dans l'accès aux propriétés ... je passe spécifiquement l'argument booléen dans cet appel parce que je sais que certaines propriétés ne seraient pas traduites et n'ont pas besoin d'être au format utf8 ...

Maintenant, j'ai enregistré mon fichier de propriétés au format UTF8 et cela fonctionne bien car chaque utilisateur de mon application a une préférence locale de référence.

Properties prop = new Properties();
String fileName = "./src/test/resources/predefined.properties";
FileInputStream inputStream = new FileInputStream(fileName);
InputStreamReader reader = new InputStreamReader(inputStream,"UTF-8");

Pour ce que ça vaut mon problème, c'est que les fichiers eux-mêmes étaient mal encodés. Utiliser iconv a fonctionné pour moi

iconv -f ISO-8859-15 -t UTF-8  messages_nl.properties > messages_nl.properties.new

J'ai essayé d'utiliser l'approche fournie par Rod, mais en tenant compte de la préoccupation de BalusC de ne pas répéter la même solution de contournement dans toute l'application et je suis venu avec cette classe:

import java.io.UnsupportedEncodingException;
import java.util.Locale;
import java.util.ResourceBundle;

public class MyResourceBundle {

    // feature variables
    private ResourceBundle bundle;
    private String fileEncoding;

    public MyResourceBundle(Locale locale, String fileEncoding){
        this.bundle = ResourceBundle.getBundle("com.app.Bundle", locale);
        this.fileEncoding = fileEncoding;
    }

    public MyResourceBundle(Locale locale){
        this(locale, "UTF-8");
    }

    public String getString(String key){
        String value = bundle.getString(key); 
        try {
            return new String(value.getBytes("ISO-8859-1"), fileEncoding);
        } catch (UnsupportedEncodingException e) {
            return value;
        }
    }
}

La façon d'utiliser cela serait très similaire à l'utilisation régulière de ResourceBundle:

private MyResourceBundle labels = new MyResourceBundle("es", "UTF-8");
String label = labels.getString(key)

Ou vous pouvez utiliser le constructeur alternatif qui utilise UTF-8 par défaut:

private MyResourceBundle labels = new MyResourceBundle("es");

Ouvrez la boîte de dialogue Paramètres / Préférences ( Ctrl+ Alt+ S), puis cliquez sur Éditeur et encodages de fichiers.

Ensuite, en bas, vous trouverez les encodages par défaut des fichiers de propriétés. Choisissez votre type d'encodage.

Vous pouvez également utiliser des symboles Unicode au lieu du texte dans votre ensemble de ressources (par exemple, "ів"égal \u0456\u0432)

Depuis Java 9, le fichier de propriétés par défaut pour charger a été changé en UTF-8. https://docs.oracle.com/javase/9/intl/internationalization-enhancements-jdk-9.htm