How to Internationalize Exceptions II

In my previous post I asked for some advice on how to internationalize Exceptions. You guys gave me some great feedback.

Anders raised a valid issue, which I had not considered before. In terms of layering, he thinks it's the view's responsibility to internationalize error messages. I tend to agree - however, I came across the requirement to log internationalized error messages and send them by email. Usually it's not the view layers responsibility to send emails, so you need to think of internationalization almost as some kind of cross cutting concern.

I guess in most projects, error codes/messages are managed the same way Martin described it: you have static final ints in a separate interface. It is imported into every class that handles Exceptions. This might be straight forward in the beginning, but could turn into a maintenance nightmare after that interface grew to a couple hundred lines. I admit, I'm guilty of it too and that's the reason why I wanna get it right in my current project.

After I read the article and checked the corresponding source code that Alex had suggested, I investigated a little further and could find any more information on this topic. So I decided to come up with something myself, based on your input.

How about 2 abstract classes as a template for Exception and RuntimeException. They form a contract for an internationalized Throwable. Below is a sample implementation for Exception.

public abstract class I18NException extends Exception {
public enum Message implements ExceptionMessage {
DEFAULT("default.error");

private String key;
private Message(String argKey) {
key = argKey;
}

public String getLocalizedMessage(Locale argLocale) {
return ResourceBundle.getBundle("ErrorResources", argLocale).getString(key);
}

}
private Locale locale;
private Message message;

public I18NException(Locale argLocale, Message argMessage, String arg0, Throwable arg1) {
super(arg0, arg1);
locale = argLocale;
message = argMessage;
}
/** other constructors omitted **/

public String getLocalizedMessage() {
return message.getLocalizedMessage(locale);
}
}

You can use this class as a template for all other Exceptions that need to be internationalized. The default enum is optional, you can omit it if you don't need it. The interface ExceptionMessage defines a contract between the enum responsible for error messages and the Exception class containing it.

public interface ExceptionMessage {
public String getLocalizedMessage(Locale argLocale);
}

So if you want to implement your own internationalized Exception all you have to do is subclass I18NException with it's constructors and add an enum implementing the ExceptionMessage interface. The contract enforced by ExceptionMessage makes sure that getLocalizedMessage is called by the abstract base class.

I think this design is pretty straightforward and easy to use. You don't have to implement a lot of code to get your internationalized error messages working and you have a clean design enforced by contracts. The only alien thing for me is the Local instance that you have to pass along in the constructor. I couldn't think of any other way to pass it along, so the constructor seemed to be a nice way to define that interface.

Let me know what you think of this solution. I'm pretty sure there is a lot of room for improvements and I'm keen to know about it.