How to Internationalize Exceptions

Yesterday I read a german article about the best practises of handling Exceptions in Java. Somewhat it is one of those articles which try to tell you don't do this, don't do that and never come up with any useful alternatives after all. Anyways, as far as I can remember it is the first article I've read, trying to come up with a solution to tackle the error code/message problem.

In an ideal world your custom designed Exception tells a user what went wrong, maybe with a simple error message. Additionally you might add error codes, so that the guys at support can easily identify what went wrong, in case a customer calls. This is the ideal world - the real world looks different: most Exceptions don't even have error messages, they are simply wrappers around various kind of other Exceptions.

Take a look at what the article calls Exception Facade:

public class PluginInitialisationException extends Exception {
public enum PluginInitialisationError {
PLUGIN_LIFECYCLE ("Plugin lifecycle has ended"),
ILLEGAL_ACCESS ("Illegal access while creating the plugin instance"),
INSTANTIATION ("Error while creating the plugin instance"),
CLASS_CAST ("Plugin class cannot be cast"),
CLASS_NOT_FOUND ("Plugin class not found");
private String message;
private PluginInitialisationError(String message) {
this.message = message;
}
}
private PluginInitialisationError error;
public PluginInitialisationException(PluginInitialisationError error) {
this.error = error;
}
public PluginInitialisationException(PluginInitialisationError error, Exception cause) {
super(error.message);
this.error = error;
this.initCause(cause);
}
public String getErrorMessage() {
return error.message;
}
}

I like this approach, because it gives you type safe error messages and a clean design at the same time. If you need error codes you can simply extend PluginInitialisationError enum or add a new enum handling the codes.

I used this kind of Exception in one of my projects, but only with error codes. Now I'm asking you, how to handle internationalization of error messages with this approach? Let's assume we don't use any fancy framework, just plain old Java. The standard way of internationalizing a String goes as follows:

Locale currentLocale = new Locale(language, country);
ResourceBundle messages = ResourceBundle.getBundle("MessagesBundle", currentLocale);
System.out.println(messages.getString("greetings"));

Where does this code belong? Should it be in your Exception? How to determine language and country? I'm sill looking for resources on the web to find a clean designed solution. Since my next project is going to be a Eclipse RCP desktop app, I guess there must be someone out there which already had the same problem.