Interface design considerations II - Exceptions, Sessions,
Testability
Hi all,
Thanks to all the suggestions provided in the previous thread <http://
groups.google.com/group/comp.lang.java.programmer/browse_thread/thread/
f21886dbb1dbfa71/>, I was able to come with a basic implementation of
my translation library. The interfaces I ended
up creating are:
public interface ITranslator {
String translate(String text);
}
// This is implemented by classes like GoogleTranslatorImpl
public interface ILocaleTranslator extends ITranslator {
void setFromLocale(Locale fromLocale);
void setFromLocale(Locale fromLocale);
Locale getToLocale();
Locale getFromLocale();
}
// This is implemented by classes like PropertiesFileTranslatorImpl
public interface ITextFileTranslator {
void setTranslator(ITranslator translator);
void translateFile(File inFile, File outFile) throws
TranslationException;
}
Having reached this far, I still have a couple of queries:
= Let's suppose I've a very simple Socket server for dealing with
translations. For translating each piece of text I:
- Connect to the server socket
- Send the request
- Receive the translated response
- Close the resources
What would be a good way of introducing the concept of session in my
library implementation wherein the user can take advantage of using
the same connection [if supported] for all its translations during a
session instead of creating and destroying the socket connection for
each piece of text? I was thinking along the lines of having a `init
()' and `destroy()' methods which would be invoked by the client to
initiate or destroy a translation session respectively.
= What would be a good way of handling exceptions when creating such
general purpose libraries? Right now I have a single exception class,
TranslationException which extends RuntimeException for this. It
encapsulates all the checked exceptions thrown by the application by
catching all the checked exceptions and wrapping them like:
try {
// any piece of code
} catch(Exception e) {
throw new TranslationException(e.getMessage(), e);
}
= How would I go about writing test cases for translation
implementations which require external resources like a socket
connection to the translation service and so on? Let's assume my
implementation class looks something along the lines of:
class XXXTranslator implements ILocaleTranslator {
// implement all interface getters and setters
public String translate(String translate) {
// some complicated preprocessing
// connection to the translation service
// some complicated post processing
}
}
Please let me know in case further clarifications are required.
Comments and suggestions would be greatly appreciated.
../sasuke