|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.geotools.arcsde.ArcSDEJNDIDataStoreFactory
public class ArcSDEJNDIDataStoreFactory
A GeoTools DataStore
factory to access an ArcSDE database by grabbing the connection pool
from a JNDI reference.
This DataStore factory expects the arcsde connection information to be given as a JNDI resource
path through the jndiRefName
parameter at createDataStore(Map)
.
The resource provided by the JNDI context at that location may be either:
java.util.Map<String, String>
with the connection parameters from
ArcSDEConnectionConfig
. If so, the session pool
will be taken from
ArcSDEConnectionFactory.getInstance(Map)
ISessionPool
instance
If not an ISessionPool
, the object will be used to get one from
ArcSDEConnectionFactory
. Whether the resulting session (connection) pool is shared among
ArcSDEDataStore
instances is dependent on how the JNDI resource is externally configured.
For example, on the J2EE container, it will depend on if the JNDI resource is globally configured
or not, and the required jar files are on a J2EE container shared libraries folder or not.
Nested Class Summary |
---|
Nested classes/interfaces inherited from interface org.geotools.data.DataAccessFactory |
---|
DataAccessFactory.Param |
Field Summary | |
---|---|
static DataAccessFactory.Param |
JNDI_REFNAME
JNDI context path name |
Constructor Summary | |
---|---|
ArcSDEJNDIDataStoreFactory()
|
Method Summary | |
---|---|
boolean |
canProcess(java.util.Map<java.lang.String,java.io.Serializable> params)
Returns whether this factory could process the given parameters. |
DataStore |
createDataStore(java.util.Map<java.lang.String,java.io.Serializable> params)
Creates and ArcSDEDataStore from the provided params , where the connection
pool is provided by JNDI. |
DataStore |
createNewDataStore(java.util.Map<java.lang.String,java.io.Serializable> params)
|
java.lang.String |
getDescription()
Describe the nature of the datasource constructed by this factory. |
java.lang.String |
getDisplayName()
Name suitable for display to end user. |
java.util.Map<java.awt.RenderingHints.Key,?> |
getImplementationHints()
Map of hints (maybe unmodifiable) used by this factory to customize its use. |
DataAccessFactory.Param[] |
getParametersInfo()
Provides the datastore creation parameter metadata for this factory. |
boolean |
isAvailable()
Determines if the datastore is available. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
public static final DataAccessFactory.Param JNDI_REFNAME
Constructor Detail |
---|
public ArcSDEJNDIDataStoreFactory()
Method Detail |
---|
public DataStore createDataStore(java.util.Map<java.lang.String,java.io.Serializable> params) throws java.io.IOException
ArcSDEDataStore
from the provided params
, where the connection
pool is provided by JNDI.
See getParametersInfo()
to check which datastore creation parameters are expected by
this factory method.
createDataStore
in interface DataAccessFactory
createDataStore
in interface DataStoreFactorySpi
params
- The full set of information needed to construct a live
data store. Typical key values for the map include: url -
location of a resource, used by file reading datasources. dbtype
- the type of the database to connect to, e.g. postgis, mysql
java.io.IOException
- if there were any problems setting up (creating or
connecting) the datasource.DataStoreFactorySpi.createDataStore(java.util.Map)
public boolean canProcess(java.util.Map<java.lang.String,java.io.Serializable> params)
JNDI_REFNAME
parameter is
present. That is so so any failure is handled by createDataStore(Map)
instead of
getting client code silently failing (as this method does not throw an exception)
canProcess
in interface DataAccessFactory
params
- The full set of information needed to construct a live
data source.
DataAccessFactory.canProcess(java.util.Map)
public java.lang.String getDescription()
DataAccessFactory
A non localized description of this data store type.
getDescription
in interface DataAccessFactory
DataAccessFactory.getDescription()
public java.lang.String getDisplayName()
DataAccessFactory
A non localized display name for this data store type.
getDisplayName
in interface DataAccessFactory
DataAccessFactory.getDisplayName()
public DataAccessFactory.Param[] getParametersInfo()
The returned parameters are:
jndiReferenceName
: the JNDI path to the connection pool
namespace
: the namespace uri the
datastore should create feature types in
database.version
the arcsde database
version the datastore shall work upon. If non provided or empty, the DEFAULT version will be
used.
datastore.allowNonSpatialTables
whether to publish non spatial registered tables (aka,
Object Classes). Defaults to false
.
getParametersInfo
in interface DataAccessFactory
DataAccessFactory.getParametersInfo()
public boolean isAvailable()
Check in an Initial Context is available, that is all what can be done Checking for the right jdbc jars in the classpath is not possible here
isAvailable
in interface DataAccessFactory
DataAccessFactory.isAvailable()
public java.util.Map<java.awt.RenderingHints.Key,?> getImplementationHints()
Factory
FactoryUsingVolatileDependencies
).
The primary purpose of this method is to determine if an existing
factory instance can be reused for a set of user-supplied hints. This method is invoked by
FactoryRegistry
in order to compare this factory's hints against user's hints.
This is dependency introspection only; FactoryRegistry
never
invokes this method for creating new factories.
Keys are usually static constants from the Hints
class, while values are
instances of some key-dependent class. The key set must contains
at least all hints impacting functionality. While the key set may contains all hints
supplied by the user, it is recommended to limit the set to only the hints used by this
particular factory instance. A minimal set will helps FactoryRegistry
to compare
only hints that matter and avoid the creation of unnecessary instances of this factory.
The hint values may be different than the one supplied by the user. If a user supplied a
hint as a Class
object, this method shall replace it by the actual instance used,
if possible.
Implementations of this method are usually quite simple. For example if a datum authority factory uses an ordinary datum factory, its method could be implemented as below (note that we should not check if the datum factory is null, since key with null value is the expected behaviour in this case). Example:
Map hints = new HashMap();
hints.put(Hints.DATUM_FACTORY, datumFactory);
return hints;
getImplementationHints
in interface Factory
Factory.getImplementationHints()
public DataStore createNewDataStore(java.util.Map<java.lang.String,java.io.Serializable> params) throws java.io.IOException
createNewDataStore
in interface DataStoreFactorySpi
java.io.IOException
DataStoreFactorySpi.createNewDataStore(java.util.Map)
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |