Designs for interface/implementation factory APIs

Question

I've been building a complex data store for geographical information based on JNDI.
The store is basically working but I've been trying to make the API for programs accessing it more regular.
I'm dissatisfied with the way that new objects for addition to the store are instanciated. It's all a bit ad-hoc at the moment so I want to create a proper factory system, separating interface from implementation and allowing for the case where the interface has a different implentation for remote and local contexts.
I'm thinking the best approach would be to have a single create method, probably as a member of the extended context interface.
What I want to get is a sample of how programmers feal about different methods of passing creation parameters to such a factory method (or for that matter, to invite comments on the basic idea).
One possibility would be as a Hashtable or Hashmap. Generic keys (like datastore path) would be defined as constants in the context or factory interface, type specific keys in the interface which is used to access the object being created.
e.g.
Hashtable fsCreate = new Hashtable(5);
fgCreate.put(DataContext.PATH_KEY, "test.features");
fgCreate.put(DataContext.FORMAT_KEY, format);
fgCreate.put(DataContext.BOUNDS_KEY, boundaryRectangle);
FeatureSet fs = (FeatureSet)dataContext.create(FeatureSet.TYPE_VALUE,fsCreate);Another possibility would be some kind of parameter bean, with an fundamental parameter class and different extensions for each type of object to be created.
FeatureSetParams fsCreate = new fsCreate();
fsCreate.setPath("test.features");
fsCreate.setFormat(format);
fgCreate.setBounds(boundaryRectangle);
FeatureSet fs = (FeatureSet)dataContext.create(fgCreate);The Hashtable method has a slightly clumbsy feel, but it does avoid directly instanciating a whole bunch of new concrete classes (which seems to go against the spirit of interface/implementation separation).

Answer 1

If there's a create method in the interface, wouldn't
that make it accessible from anything that knows about
the interface? This would nullify the factory
pattern, wouldn't it?Not necesasrilly, that would depend how the create method was implemented. I already have a "retriever" object associated with each implentation class that can be retrieved from the data store. I can add a "create" method, effectively adding a factory class function to these. These retrievers are already registered with the concrete implentation of the JNDI Context.
Granted the implentations are in several different packages, so I can't restrict acces to these retriever objects to the package level.