In der Java-Entwicklung ist ResourceBundle ein Mechanismus zur bequemen Verwaltung lokalisierter Ressourcen. Dadurch kann das Programm automatisch die entsprechenden lokalisierten Ressourcendateien entsprechend der Sprache und dem Land/der Region der aktuellen Systemumgebung laden, wodurch harte Codierung vermieden und wiederholter Code reduziert wird. Im Folgenden sind die grundlegenden Schritte zur Verwendung von ResourceBundle aufgeführt:
ResourceBundle implementiert die Lokalisierung durch das Laden von Ressourcendateien. Daher muss für jede Sprache und jedes Land/jede Region eine entsprechende Ressourcendatei vorbereitet werden. Ressourcendateien können Textdateien im .properties-Format oder .class-Dateien oder .jar-Dateien sein.
In der Ressourcendatei müssen Sie für jede Zeichenfolge, die lokalisiert werden muss, einen Attributnamen angeben und dann für jeden Attributnamen eine Übersetzung in der Sprache bereitstellen. Hier ist beispielsweise ein Beispiel für eine Ressourcendatei mit dem Namen „messages.properties“:
greeting=Hello farewell=Goodbye
Für denselben Eigenschaftsnamen können in verschiedenen Sprachen und Ländern verschiedene Übersetzungen bereitgestellt werden. Hier ist beispielsweise ein Beispiel für eine französische Ressourcendatei mit dem Namen „messages_fr.properties“:
greeting=Bonjour farewell=Au revoir
In Java können Sie die ResourceBundle-Klasse verwenden, um Ressourcendateien zu laden. Die ResourceBundle-Klasse stellt mehrere verschiedene Konstruktoren zum Laden von Ressourcendateien bereit, zum Beispiel:
ResourceBundle rb = ResourceBundle.getBundle("messages", Locale.getDefault());Diese Anweisung lädt die Ressourcendatei mit dem Namen „messages“ entsprechend der Standardsprache und dem Land/der Region der aktuellen Systemumgebung. Wenn die Systemumgebung Englisch und die Vereinigten Staaten ist, lädt diese Anweisung die Ressourcendatei „messages.properties“. Wenn die Systemumgebung Französisch und Französisch ist, lädt diese Anweisung die Ressourcendatei „messages_fr.properties“.
Wenn Sie Ressourcendateien in einer bestimmten Sprache und einem bestimmten Land/einer bestimmten Region laden müssen, können Sie die Methode getBundle() mit dem Parameter Locale verwenden. Beispiel:
Locale locale = new Locale("fr", "FR");
ResourceBundle rb = ResourceBundle.getBundle("messages", locale);Diese Anweisung lädt die französische/französische Ressourcendatei mit dem Namen „messages_fr_FR.properties“.
Sobald die Ressourcendatei erfolgreich geladen wurde, können Sie die getString()-Methode von ResourceBundle verwenden, um die lokalisierte Zeichenfolge abzurufen. Zum Beispiel:
String greeting = rb.getString("greeting");
String farewell = rb.getString("farewell");Diese Anweisungen rufen die lokalisierten Zeichenfolgen mit den Attributen Greeting und Farewell aus der Ressourcendatei ab und weisen sie den Variablen Greeting und Farewell zu. Wenn der angegebene Eigenschaftsname nicht gefunden werden kann, löst die Methode getString() eine MissingResourceException aus.
Zusätzlich zu den oben genannten grundlegenden Schritten gibt es einige bemerkenswerte Funktionen und Tipps zur Verwendung von ResourceBundle:
ResourceBundle unterstützt mehrere Ressourcendateiformate, einschließlich .properties , .xml- und .class-Dateien usw. Für einfache lokalisierte Zeichenfolgen ist das .properties-Format oft die häufigste Wahl, da es einfach zu verwenden, leicht zu bearbeiten und zu lokalisieren ist.
Für komplexere lokalisierte Ressourcen wie Bilder, Töne, Videos usw. müssen Sie möglicherweise Ressourcendateien in anderen Formaten verwenden. Sie können beispielsweise .class-Dateien oder .jar-Dateien verwenden, um Bild- oder Tondateien einzuschließen, und die ClassLoader.getSystemClassLoader()-Methode von ResourceBundle verwenden, um diese Dateien zu laden.
Lokalisierte Zeichenfolgen können verschiedene Sonderzeichen enthalten, z. B. Zeilenumbrüche, Tabulatoren, Unicode-Zeichen usw. Wenn Sie diese Zeichen direkt in Ressourcendateien einbetten, kann dies zu unnötigen Problemen und Fehlern führen.
Um diese Probleme zu vermeiden, können Sie die Escape-Zeichen von Java verwenden, um diese Sonderzeichen darzustellen. Sie können beispielsweise „n“ für ein Zeilenumbruchzeichen, „t“ für ein Tabulatorzeichen, „uXXXX“ für ein Unicode-Zeichen usw. verwenden.
In einigen Fällen kann es Situationen geben, in denen für lokalisierte Zeichenfolgen in bestimmten Sprachen keine Übersetzungen bereitgestellt werden. Um MissingResourceException-Ausnahmen im Programm zu vermeiden, können Sie eine Standardübersetzung für diese fehlenden Zeichenfolgen in der Ressourcendatei bereitstellen, z. B. eine englische Übersetzung. Hier ist beispielsweise ein Beispiel für eine Datei „messages_fr.properties“ mit einer Standardübersetzung:
greeting=Bonjour farewell=Au revoir warning=Attention: This message has no translation in French. Please refer to the English version.
Auf diese Weise gibt das ResourceBundle in der französischen Umgebung automatisch die Standardübersetzung zurück, wenn die lokalisierte Zeichenfolge für einen bestimmten Eigenschaftsnamen nicht gefunden werden kann für die Eigenschaftsnamenübersetzung, wodurch Programmausnahmen vermieden werden.
Einige lokalisierte Zeichenfolgen können dynamische Inhalte wie Uhrzeit, Datum, Zahlen, Währung usw. enthalten. Um diese Zeichenfolgen korrekt zu lokalisieren, müssen Sie die Formatierungsmechanismen von Java wie MessageFormat und NumberFormat usw. verwenden. Das Folgende ist beispielsweise ein Beispiel für die Verwendung von MessageFormat zum Lokalisieren dynamischer Zeichenfolgen:
String pattern = rb.getString("greeting");
Object[] arguments = {"John"};
String greeting = MessageFormat.format(pattern, arguments);In diesem Beispiel ist „Muster“ eine lokalisierte Zeichenfolge, die den Platzhalter „{0}“ enthält. „{0}“ bedeutet, dass er durch ersetzt werden muss Der Speicherort dynamischer Inhalte. arguments ist ein Array mit dem tatsächlichen dynamischen Inhalt, der die Positionen von „{0}“ der Reihe nach ersetzt. Schließlich gibt die Methode MessageFormat.format() eine lokalisierte Zeichenfolge zurück.
在一些情况下，可能需要使用多个资源文件来管理不同类型或不同用途的本地化资源。在这种情况下，可以使用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作为基础名称来获取不同类型的资源文件。这样，我们就可以轻松地管理不同类型的本地化资源，从而使程序更加可读和易于维护。
如果默认的资源加载机制无法满足需求，我们还可以自定义资源加载器来实现更高级的功能。自定义资源加载器需要继承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资源文件中的本地化字符串。这样，我们就可以实现更高级的资源加载功能，从而满足更复杂的需求。
有时候，在应用程序运行期间，可能需要动态地更新资源文件中的某些值。在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()方法来获取更新后的本地化字符串。
这种动态更新资源文件的方式可以使应用程序更加灵活，能够快速响应变化。但是需要注意的是，这种方式需要保证资源文件的正确性和一致性，否则可能会导致应用程序运行出错。
Das obige ist der detaillierte Inhalt vonSo verwenden Sie die internationalisierte zugrunde liegende Klasse ResourceBundle in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
