It struck me that a difficulty with using interfaces and factories in Java is that you need to know which factory goes with which interface. A naming convention can help here, but it might not be consistent.
Instead, I suggest that you annotate your interface, to know about a default implementation.
This immediately brings up "Interfaces shouldn't be bound to their implementations!!! This is unpure, evil code!!!". When you are navigating code, trying to find implementations for a particular interface can be annoying and time-consuming.
I have set out here the most cohesive way I can think of for finding out which class to use as a default implementation when all you have is an interface. It doesn't 'bind' the implementation to the interface. It neither 'binds' nor mentions the implementation. The interface 'knows about' a factory.
I experimented with non-annotation ways of doing this, such as static blocks in interfaces, xdoclet-based solutions (well, I thought about xdoclet), but I decided they were all ugly. I think what I have is the most elegant but pragmatic way.
Time for some code.
@DefaultFactory(BlobbyFactory.class)
interface Blobby
{
void doSomething();
}
This says that BlobbyFactory is the default factory for the Blobby interface.
So when you want a Blobby, you instantiate BlobbyFactory and call its newInstance method.
As a convenience, I wrote a Farm class that you can use as follows:
Blobby blobby=(Blobby)new Farm().newInstance(Blobby.class);
The reason newInstance is not a static method is that you may wish to override the default factory, in some part of your application.
So the unit testing part of your application might want a mock object instead of whatever BlobbyFactory gives you (actually a BlobbyImplementation in this case).
Farm farm=new Farm();
farm.setFactory(Blobby.class,new MockBlobbyFactory());
then elsewhere:
Blobby blobby=(Blobby)farm.newInstance(Blobby.class);
In effect, a Farm is a Map
CodeSOD: Secondary Waits
19 hours ago
