Comment utiliser la classe sous-jacente internationalisée ResourceBundle en Java

Dans le développement Java, ResourceBundle est un mécanisme permettant de gérer facilement les ressources localisées. Il permet au programme de charger automatiquement les fichiers de ressources localisés correspondants en fonction de la langue et du pays/région de l'environnement système actuel, évitant ainsi le codage en dur et réduisant le code répété. Voici les étapes de base pour utiliser ResourceBundle :

1. Préparer les fichiers de ressources

ResourceBundle implémente la localisation en chargeant des fichiers de ressources, un fichier de ressources correspondant doit donc être préparé pour chaque langue et pays/région. Les fichiers de ressources peuvent être des fichiers texte au format .properties, ou des fichiers .class ou .jar.

Dans le fichier de ressources, vous devez spécifier un nom d'attribut pour chaque chaîne à localiser, puis fournir une traduction dans la langue pour chaque nom d'attribut. Par exemple, voici un exemple de fichier de ressources appelé messages.properties :

greeting=Hello
farewell=Goodbye

Différentes traductions peuvent être fournies pour le même nom de propriété dans différentes langues et pays. Par exemple, voici un exemple de fichier de ressources français nommé messages_fr.properties :

greeting=Bonjour
farewell=Au revoir

2. Chargement des fichiers de ressources

En Java, vous pouvez utiliser la classe ResourceBundle pour charger des fichiers de ressources. La classe ResourceBundle fournit plusieurs constructeurs différents pour charger les fichiers de ressources, par exemple :

ResourceBundle rb = ResourceBundle.getBundle("messages", Locale.getDefault());

Cette instruction chargera le fichier de ressources nommé messages en fonction de la langue par défaut et du pays/région de l'environnement système actuel. Si l'environnement système est l'anglais et les États-Unis, cette instruction chargera le fichier de ressources messages.properties. Si l'environnement système est français et français, alors cette instruction chargera le fichier de ressources messages_fr.properties.

Si vous devez charger des fichiers de ressources dans une langue et un pays/région spécifiés, vous pouvez utiliser la méthode getBundle() avec le paramètre Locale. Par exemple :

Locale locale = new Locale("fr", "FR");
ResourceBundle rb = ResourceBundle.getBundle("messages", locale);

Cette instruction chargera le fichier de ressources français/français nommé messages_fr_FR.properties.

3. Obtenez la chaîne localisée

Une fois le fichier de ressources chargé avec succès, vous pouvez utiliser la méthode getString() de ResourceBundle pour obtenir la chaîne localisée. Par exemple :

String greeting = rb.getString("greeting");
String farewell = rb.getString("farewell");

Ces instructions obtiendront les chaînes localisées avec les attributs nommés salutation et adieu à partir du fichier de ressources, et les affecteront respectivement aux variables de salutation et d'adieu. Si le nom de propriété spécifié est introuvable, la méthode getString() lèvera une MissingResourceException.

4. Conseils pour utiliser ResourceBundle

En plus des étapes de base ci-dessus, il existe quelques fonctionnalités et conseils remarquables pour utiliser ResourceBundle :

4.1 Choisissez le format de fichier de ressources approprié

ResourceBundle prend en charge plusieurs formats de fichiers de ressources, y compris .properties. , fichiers .xml et .class, etc. Pour les chaînes localisées simples, le format .properties est souvent le choix le plus courant car il est simple à utiliser, facile à modifier et à localiser.

Pour des ressources localisées plus complexes, telles que des images, des sons, des vidéos, etc., vous devrez peut-être utiliser des fichiers de ressources dans d'autres formats. Par exemple, vous pouvez utiliser des fichiers .class ou .jar pour inclure des fichiers image ou son et utiliser la méthode ClassLoader.getSystemClassLoader() de ResourceBundle pour charger ces fichiers.

4.2 Traitement des caractères spéciaux dans les chaînes localisées

Les chaînes localisées peuvent contenir divers caractères spéciaux, tels que des nouvelles lignes, des tabulations, des caractères Unicode, etc. Si vous intégrez ces caractères directement dans des fichiers de ressources, cela peut provoquer des problèmes et des erreurs inutiles.

Pour éviter ces problèmes, vous pouvez utiliser les caractères d'échappement de Java pour représenter ces caractères spéciaux. Par exemple, vous pouvez utiliser « n » pour représenter un caractère de nouvelle ligne, « t » pour représenter un caractère de tabulation, « uXXXX » pour représenter un caractère Unicode, etc.

4.3 Gestion des chaînes localisées manquantes

Dans certains cas, il peut y avoir des situations où les traductions ne sont pas fournies pour les chaînes localisées dans certaines langues. Afin d'éviter les exceptions MissingResourceException dans le programme, vous pouvez fournir une traduction par défaut pour ces chaînes manquantes dans le fichier de ressources, telle qu'une traduction en anglais. Par exemple, voici un exemple de fichier messages_fr.properties avec une traduction par défaut :

greeting=Bonjour
farewell=Au revoir
warning=Attention: This message has no translation in French. Please refer to the English version.

De cette façon, dans l'environnement français, si la chaîne localisée pour un certain nom de propriété est introuvable, le ResourceBundle renverra automatiquement la valeur par défaut pour le nom de propriété Translation, évitant ainsi les exceptions du programme.

4.4 Traitement des chaînes localisées dynamiques

Certaines chaînes localisées peuvent contenir du contenu dynamique, tel que l'heure, la date, les chiffres, la devise, etc. Afin de localiser correctement ces chaînes, vous devez utiliser les mécanismes de formatage de Java, tels que MessageFormat et NumberFormat, etc. Par exemple, voici un exemple d'utilisation de MessageFormat pour localiser des chaînes dynamiques :

String pattern = rb.getString("greeting");
Object[] arguments = {"John"};
String greeting = MessageFormat.format(pattern, arguments);

Dans cet exemple, le modèle est une chaîne localisée contenant l'espace réservé "{0}", "{0}" signifie qu'il doit être remplacé par L'emplacement du contenu dynamique. arguments est un tableau contenant le contenu dynamique réel, qui remplacera les positions de "{0}" dans l'ordre. Enfin, la méthode MessageFormat.format() renvoie une chaîne localisée.

4.5 处理多个资源文件

在一些情况下，可能需要使用多个资源文件来管理不同类型或不同用途的本地化资源。在这种情况下，可以使用ResourceBundle.Control类的方法来指定资源文件的搜索路径和加载顺序。

例如，可以使用ResourceBundle.Control.getControl()方法来获取默认的ResourceBundle.Control实例，然后使用ResourceBundle.getBundle()方法来指定基础名称和Locale信息，以便查找合适的资源文件。例如，以下是一个使用多个资源文件来管理本地化字符串的示例：

ResourceBundle.Control control = ResourceBundle.Control.getControl(ResourceBundle.Control.FORMAT_PROPERTIES);
ResourceBundle messages = ResourceBundle.getBundle("Messages", new Locale("fr"), control);
ResourceBundle errors = ResourceBundle.getBundle("Errors", new Locale("fr"), control);

String greeting = messages.getString("greeting");
String error = errors.getString("invalid_input");

System.out.println(greeting); // Bonjour
System.out.println(error); // Entrée invalide

在这个示例中，我们使用ResourceBundle.Control.FORMAT_PROPERTIES指定了资源文件的格式为.properties文件，然后分别使用Messages和Errors作为基础名称来获取不同类型的资源文件。这样，我们就可以轻松地管理不同类型的本地化资源，从而使程序更加可读和易于维护。

4.6 自定义资源加载器

如果默认的资源加载机制无法满足需求，我们还可以自定义资源加载器来实现更高级的功能。自定义资源加载器需要继承java.util.ResourceBundle.Control类，并重写其中的方法来实现自定义逻辑。

例如，以下是一个使用自定义资源加载器来加载本地化字符串的示例：

public class MyResourceLoader extends ResourceBundle.Control {
    @Override
    public ResourceBundle newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
            throws IllegalAccessException, InstantiationException, IOException {
        String bundleName = toBundleName(baseName, locale);
        String resourceName = toResourceName(bundleName, "myproperties");
        InputStream stream = loader.getResourceAsStream(resourceName);
        if (stream != null) {
            try {
                return new PropertyResourceBundle(stream);
            } finally {
                stream.close();
            }
        } else {
            return super.newBundle(baseName, locale, format, loader, reload);
        }
    }
}

ResourceBundle.Control control = new MyResourceLoader();
ResourceBundle messages = ResourceBundle.getBundle("Messages", new Locale("fr"), control);

String greeting = messages.getString("greeting");

System.out.println(greeting); // Bonjour

在这个示例中，我们定义了一个名为MyResourceLoader的自定义资源加载器，并重写了其中的newBundle()方法来实现自定义资源加载逻辑。然后，我们使用这个自定义资源加载器来获取Messages资源文件中的本地化字符串。这样，我们就可以实现更高级的资源加载功能，从而满足更复杂的需求。

4.7 动态更新资源文件

有时候，在应用程序运行期间，可能需要动态地更新资源文件中的某些值。在Java中，我们可以使用PropertyResourceBundle类来实现这个功能。

PropertyResourceBundle是ResourceBundle的一个子类，它可以读取.properties格式的资源文件，并将其转换为一个键值对的形式。然后，我们可以通过这个键值对来动态地更新资源文件中的值。

例如，以下是一个使用PropertyResourceBundle来动态更新本地化字符串的示例：

// 加载资源文件
InputStream stream = new FileInputStream("Messages.properties");
PropertyResourceBundle bundle = new PropertyResourceBundle(stream);

// 动态更新本地化字符串
bundle.handleKey("greeting", (key, value) -> "Hello");

// 输出本地化字符串
String greeting = bundle.getString("greeting");
System.out.println(greeting); // Hello

在这个示例中，我们首先使用FileInputStream来加载Messages.properties资源文件，然后将其转换为一个PropertyResourceBundle对象。然后，我们使用handleKey()方法来动态地更新greeting这个键对应的值。最后，我们使用getString()方法来获取更新后的本地化字符串。

这种动态更新资源文件的方式可以使应用程序更加灵活，能够快速响应变化。但是需要注意的是，这种方式需要保证资源文件的正确性和一致性，否则可能会导致应用程序运行出错。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!