I'd like to conduct a small experimental project in the sandbox if noone
objects. If it proves useful cool, if it doesn't we can zap it.
We use interfaces alot in Java and I like the idea of having some simple,
lightweight component to allow runtime, loose binding of concrete types to
interfaces.
I'd like to investigate building a small, simple facade API over the loading
of objects from either
* JAR extension mechansim (/META-INF/services/foo.bar) like JAXP
* JNDI
* web.xml / ServletContext / init params
* Properties / ExtendedProperties files
* XML documents
It may or may not be useful on other Jakarta projects too. Its not my
intention to implement specific configuration mechanisms like the Digester,
rather just a way of loading a concrete factory class which might use (say)
the digester or JNDI directly.
My early thoughts are to use a Facade pattern along with a variation of two
patterns from IBM's San Francisco Desirgn Patterns book:-
* Class Replacement
* Special Class Factory
The basic idea is there can be default implementations for specific
interfaces which can be overridden for named instances if necessary or can
be overridden for specifc 'categories' in a log4j sense or package or class
names.
The idea being a little like log4j's categories and a little like Java's
ResourceBundles where specific language & country combinations can override
default configurations. Only in the MetaFactory it would be caller class
name (or package), the desired interface and an optional name which decides
which implementation to use. So this could be implemented as a fairly
trivial layer above JAR extension mechanism or JNDI. (e.g. it could be used
as a bootstrap mechanism to find the JNDI context when in a JUnit test
case).
So code would be something along these lines...
public Foo {
// look up my region of the MetaFactory
// like a log4j style Category
protected static final MetaFactory metaFactory =
etaFactory.get( Foo.class );
public void doSomething() {
// create some default Map implementation
Map map = metaFactory.create( Map.class );
// create a named Map implementation
Map fooCache = metaFactory.create( Map.class, "fooCache" );
...
// create some object pool
ObjectPoolFactory poolFactory = (ObjectPoolFactory)
metaFactory.create( ObjectPoolFactory.class );
ObjectPool pool = poolFactory.createPool();
...
// create some named database connection pool
ConnectionFactory connFactory = (ConnectionFactory)
metaFactory.create( ConnectionFactory.class, "customerDb" );
}
}
So from an API its one class though I would expect a small number of
implementation classes too so that it is capable of bootstrapping itself and
talk to JNDI and JAR manifests.
Does this seem an acceptable use of the sandbox? If so Craig, could I get
sandbox karma please?
James
_________________________________________________________
Do You Yahoo!?
Get your free @yahoo.com address at http://mail.yahoo.com
