De nos jours, il est indispensable d'internationaliser correctement les applications, et en particulier les applications web.

La technique habituelle consiste à externaliser les chaînes de caractère affichées par l'application dans des fichiers ".properties" (un par langue). Ces fichiers peuvent ensuite être chargés grâce à la classe Properties, soit manuellement (à la charge du développeur de déterminer le bon fichier), soit via un ResourceBundle (qui sait sélectionner le fichier adéquat en fonction d'une Locale).

Dans les deux cas, on se heurte à une limitation fondamentale du fichier ".properties" : son contenu est systématiquement considéré comme encodé en ISO-8859-1. Si cela convient parfaitement pour la plupart des langues de racine latine ou germanique, il est en revanche très difficile de représenter les symboles de beaucoup d'autres langues (asiatiques, arabes...). Certes, il est toujours possible de les remplacer par leurs équivalents unicodes (ex: 家 = \u5bb6), mais le texte ainsi produit est illisible et se prête mal à la relecture ou à la modification.

Démonstration du problème

Pour démontrer le problème, nous allons créer un fichier ".properties", y placer des caractères russes et japonais, et tenter de le charger avec la classe Properties.
Attention : si vous êtes sous Eclipse, n'oubliez pas de régler la console afin qu'elle puisse afficher correctement des caractères UTF-8 : menu Run -> Run Configurations... -> onglet Common -> Console Encoding -> UTF-8.

Voici le contenu du fichier ".properties" :

# Fichier : i18n.properties
francais=Français
japonais=日本語
russe=русский язык

Voici un petit programme de test, qui lit le fichier ci-dessus et l'affiche dans la console :

// Fichier : I18NTest.java
public class I18NTest
{
	public static void main(String[] args) throws Exception
	{
		Properties p = new Properties();
		p.load(new FileInputStream("i18n.properties"));
		p.list(System.out);
	}
}

L'exécution de ce programme donne le résultat suivant, prouvant que les caractères non-ascii ont été mal décodés par la classe Properties :

-- listing properties --
francais=Français
japonais=日本語
russe=русский язык

Une solution simple en Java 5+

Cette limitation de la classe Properties a été apparemment reconnue, et depuis Java 5, celle-ci dispose d'une méthode alternative de chargement des propriétés : il est désormais possible de charger des fichiers au format XML, dont le principal avantage est le libre choix de la méthode d'encodage, moyennant sa déclaration au niveau du header :

<?xml version="1.0" encoding="UTF-8"?>

Le format du fichier XML est défini par une DTD très simple :

<!ELEMENT properties ( comment?, entry* ) >
<!ATTLIST properties version CDATA #FIXED "1.0">
<!ELEMENT comment (#PCDATA) >
<!ELEMENT entry (#PCDATA) >
<!ATTLIST entry key CDATA #REQUIRED>

Convertissons notre fichier d'exemple au format XML :

<!-- Fichier : i18n.properties.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<entry key="francais">Français</entry>
	<entry key="japonais">日本語</entry>
	<entry key="russe">русский язык</entry>
</properties>

Et modifions le programme d'exemple.
Notez que la méthode appelée est désormais loadFromXML(), et non plus load() :

public class I18NTest
{
	public static void main(String[] args) throws Exception
	{
		Properties p = new Properties();
		p.loadFromXML(new FileInputStream("i18n.properties.xml"));
		p.list(System.out);
	}
}

Cette fois nous obtenons le bon résultat :

-- listing properties --
japonais=日本語
russe=русский язык
francais=Français

Utilisation avec les ResourceBundles

Nous avons vu qu'il est avantageux et très facile de remplacer les "vieux" fichiers ".properties" par des fichiers XML... si l'on manipule la classe Properties directement. Mais qu'en est-il si l'on passe par un ResourceBundle ?

Edit :
Lors de la rédaction de cet article, je n'avais trouvé aucune solution pour utiliser les ResourceBundles en conjonction avec les fichiers de propriétés au format XML. Depuis, les deux solutions ci-dessous ont été portées à mon attention (merci à fabien29200 !).

Il existe donc (au moins) deux solutions pour charger des fichiers de propriétés XML depuis un ResourceBundle.

• La première consiste à implémenter une classe ResourceBundle.Control personnalisée, et à la passer en paramètre de la méthode ResourceBundle.getBundle(). Cette technique est bien expliquée dans la javadoc de cette classe, mais peu pratique à mettre en oeuvre.
• La seconde consiste à développer une sous-classe (réutilisable) de ResourceBundle, sachant gérer les fichiers XML. Voici donc la classe XMLResourceBundle, inspirée de PropertyResourceBundle (et qui, à mon sens, aurait dû être incluse dans le JDK...) :

/**
 * Implémentation de ResourceBundle permettant de charger les ressources depuis un fichier XML.
 */
public abstract class XMLResourceBundle extends ResourceBundle
{
	/** Suffixe des fichiers de ressources */
	public static final String FILE_SUFFIX = ".xml";
 
	/** Ensemble des propriétés lues depuis le fichier de ressources */
	private final Properties properties = new Properties();
 
	/**
	 * Constructeur. Charge le fichier de ressources identifié par {@link XMLResourceBundle#getFileName()}
	 * @throws IOException Si une erreur survient lors de la lecture du fichier de ressources.
	 */
	protected XMLResourceBundle() throws IOException
	{
		InputStream stream = getClass().getClassLoader().getResourceAsStream(getFileName());
		try
		{	this.properties.loadFromXML(stream);
		}
		finally
		{	stream.close();
		}
	}
 
	/** Implémentation de ResourceBundle */
	@Override
	public Object handleGetObject(String key)
	{
		return this.properties.get(key);
	}
 
	/** Implémentation de ResourceBundle */
	@Override
	public Enumeration getKeys()
	{
		return this.properties.keys();
	}
 
	/**
	 * Détermine le nom du fichier de ressources. Permet aux sous-classes de modifier la stratégie de localisation du fichier de ressources.
	 * Par défaut, recherche un fichier de même nom et situé dans la même package que la classe ResourceBundle associée, avec une extension définie par {@link XMLResourceBundle#FILE_SUFFIX}.
	 * @return Le nom du fichier de ressources
	 */
	protected String getFileName()
	{
		return this.getClass().getName().replace('.', '/') + XMLResourceBundle.FILE_SUFFIX;
	}
}

Cette classe s'utilise ensuite exactement comme un PropertyResourceBundle. Pour chaque Locale supportée, il faut :

• Créer une sous-classe de XMLResourceBundle, nommée selon le pattern "MaClasse_Locale" (ex: "LoginScreenProperties_fr_FR")
• Créer un fichier de propriétés associé. Par défaut, le fichier doit avoir le même nom et être situé dans le même package que la classe permettant de le gérer, mais ceci est configurable en surchargeant la méthode XMLResourceBundle.getFileName().

Exemple :

• Soit une classe LoginScreen devant être internationalisée
• Nous décidons que le nom de base des ResourceBundles gérant l'internationalisation de cette classe sera "LoginScreenProperties"
• Pour chaque Locale supportée, nous allons donc :
  • développer une classe dérivant de XMLResourceBundle, nommée selon le pattern "LoginScreenProperties_Locale" (ex: LoginScreenProperties_fr_FR)
  • créer un fichier XML nommé selon le même pattern (ex: LoginScreenProperties_fr_FR.xml)
• La classe LoginScreen peut maintenant appeler ResourceBundle.getBundle("LoginScreenProperties", locale) pour récupérer le XMLResourceBundle correspondant à la Locale sélectionnée
• La classe LoginScreen peut enfin interroger ce XMLResourceBundle pour récupérer les textes internationalisés

/** ResourceBundle par défaut */
public class LoginScreenProperties extends XMLResourceBundle
{
	public LoginScreenProperties() throws IOException { }
}
 
/** ResourceBundle pour la Locale française */
public class LoginScreenProperties_fr_FR extends XMLResourceBundle
{
	public LoginScreenProperties_fr_FR() throws IOException { }
}

Fichiers de propriétés (dans le même package que les classes ci-dessus) :

<!-- Fichier LoginScreenProperties.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<entry key="login">Login</entry>
	<entry key="username">Username</entry>
	<entry key="password">Password</entry>
</properties>
 
<!-- Fichier LoginScreenProperties_fr_FR.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<entry key="login">Identification</entry>
	<entry key="username">Identifiant</entry>
	<entry key="password">Mot de passe</entry>
</properties>

Notre hypothétique classe LoginScreen pourrait alors charger les propriétés comme ceci :

public class LoginScreen
{
	public LoginScreen(Locale locale)
	{
		// Calcul du nom du nom de base des ResourceBundles associés, en ajoutant "Properties" au nom de la classe (ex: LoginScreen -> LoginScreenProperties)
		String propertiesClassBaseName = LoginScreen.class.getName() + "Properties";
 
		// Chargement du bon ResourceBundle en fonction de la Locale
		ResourceBundle rb = ResourceBundle.getBundle(propertiesClassBaseName, locale);
 
		// Récupération du texte localisé pour la clé "password"
		String passwordInputLabel = rb.getString("password");
	}
}