Remote exporting of a database interface

Question

I have an interface defining a database layer (all the following code has of course been simplified)
public interface Database {
  public Collection select() throws Exception;
}and an implementation class
public class DatabaseImpl implements Database {
  public Collection select() throws DatabaseException {
}Now, I wanted to be able to use this remotely as well, so I created an empty remote interface extending the Database interface as well as Remote:
public interface RemoteDatabase extends Database, Remote {
}and implement it like this:
public class RemoteDatabaseImpl extends UnicastRemoteObject implements RemoteDatabase {
  DatabaseImpl databaseImpl;
  public Collection select() throws RemoteException, DatabaseException {
    return databaseImpl.select();
}On the client side I created a DatabaseProvider which returns a remote or local connection depending on configuration parameters:
public class DatabaseProvider {
  public Database getDatabase() {
    if (isRemoteConnection())
      return connectRemoteDatabase();
    else
      return connectLocalDatabase();
}This works like a charm, but the generic "throws Exception" required on all the methods in the Database interface bothers me a lot. Without them I cant do the Remote extension, since that requires "throws RemoteException" on all the methods and I dont want to pollute the Database and DatabaseImpl classes with RemoteExceptions, so the generic Exception throws clause seems like the only solution. Optimally I would have liked the Database interface methods to simply throw DatabaseExceptions, such as RecordNotFoundException. I've spent quite a lot of time wrestling with this but haven't been able to come up with a "cleaner" implementation. So, I wonder if there is anyone here who could give me any pointers or suggestions on how to do this differently.
With thanks in advance,
Darri

Answer 1

You would normally do this by having two implementations of the Database interface - one which accesses the database locally and one which access the database remotely. (This is equivalent to your 'if' statement - I always try and avoid conditional logic where possible).
To get around the exception issue, you could wrap your remote implementation (which implements DatabaseRemote) with a wrapper which only implements Database. This wrapper could delegate all calls to the remote implementation and then decide how to deal with the RemoteExceptions that come back according to some (possibly pluggable) policy. Typically, you might retry select operations a few times before giving up. When you give up, you simply wrap your RemoteException inside a new DatabaseException and re-throw it.
Like this:
public class LocalDatabase implements Database {
    public Collection select() throws DatabaseException {
        try {
            jdbc.select(blah);
        } catch (SQLException e) {
            throw new DatabaseException(e);  // or whatever
public class RemoteDatabase implements (err...) RemoteDatabase {   // you see what I mean here!
    public Collection select() throws DatabaseException, RemoteException {
        remote.select(blah);
public class LocalRemoteDatabaseWrapper implements Database {
    public LocalRemoteDatabaseWrapper(RemoteDatabase remote) {
        this.remote = remote;
    public Collection select() throws DatabaseException {
        int retry = 3;
        while (true) {
            try {
                remote.select(blah);
                return results;
            } catch (RemoteException e) {
                if (retry-- == 0) {
                    throw new DatabaseException(e);
}