ALcdOGCWFSCommandDispatcherFactory (LuciadFusion API documentation)

java.lang.Object
- com.luciad.ogc.wfs.ALcdOGCWFSCommandDispatcherFactory

All Implemented Interfaces:

ILcdOGCCommandDispatcherFactory
```
public abstract class ALcdOGCWFSCommandDispatcherFactory
extends Object
implements ILcdOGCCommandDispatcherFactory
```
This factory class creates a command dispatcher following the OGC WFS specification. A number of protected 'create' methods of this class can be overridden to customize the behaviour of the WFS server. This makes it possible to support additional\ input and output formats, extend the filtering capabilities, and to plug in custom transaction and lock handling.
A concrete implementation of this class is referenced from the web servlet configuration file, so it can be instantiated when the web server starts up. This will then cause the createCommandDispatcher method to be called, which will in turn call all protected factory methods of this class to construct the instances which are required by the request handlers.
The final server initialization step is to create a request handler for each WFS request using the createRequestHandler method. These handlers can then be registered on the TLcdWFSCommandDispatcher instance that is created by the createWFSCommandDispatcherInstance factory method.

Constructor Summary

Constructors
Constructor and Description

ALcdOGCWFSCommandDispatcherFactory()

Constructors
Constructor and Description
`ALcdOGCWFSCommandDispatcherFactory()`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`addModelReferenceFormatter(ILcdModelReferenceFormatter aFormatter)` Adds a reference formatter.
`protected void`	`addModelReferenceParser(ILcdModelReferenceParser aParser)` Adds a reference parser.
`protected ILcdWFSClientModelEncoderFactory`	`createClientModelEncoderFactory()` Creates an `ILcdWFSClientModelEncoderFactory`.
`ALcdOGCCommandDispatcher`	`createCommandDispatcher(ILcdInitializationConfig aConfig)` Called during servlet initialization to create a command dispatcher.
`protected ILcdWFSFilteredModelFactory`	`createFilteredModelFactory(ILcdWFSCapabilitiesProvider aCapabilitiesProvider, ILcdOGCModelProvider aModelProvider)` Creates an `ILcdWFSFilteredModelFactory`.
`protected ILcdWFSLockFactory`	`createLockFactory(ILcdWFSFilteredModelFactory aFilteredModelFactory)` Creates a lock factory which creates locks for locking support.
`protected ILcdOGCModelDecoderFactory`	`createModelDecoderFactory()` Creates an `ILcdOGCModelDecoderFactory`.
`protected ILcdOGCModelProvider`	`createModelProvider(ILcdOGCModelDecoderFactory aModelDecoderFactory)` Creates an `ILcdOGCModelProvider`, which provides central access to all models.
`ILcdRequestHandler`	`createRequestHandler(String aRequest, TLcdWFSCommandDispatcherContext aCommandDispatcherContext)` Factory method to create a WFS request handler.
`protected ILcdWFSServerModelEncoderFactory`	`createServerModelEncoderFactory()` Creates an `ILcdWFSServerModelEncoderFactory`.
`protected ILcdWFSServiceMetaData`	`createServiceMetaData()` Deprecated. Since 2017.0 Please make use of `ILcdWFSCapabilitiesProvider`.
`TLcdOWSServiceProvider`	`createServiceProvider()` Deprecated. Since 2017.0 Please make use of `ILcdWFSCapabilitiesProvider`.
`protected List<TLcdDataModel>`	`createTransactionContentDataModels(ILcdInitializationConfig aConfig)` Creates the data models to configure the transaction XML decoder used by the transaction request handler.
`protected ILcdWFSTransactionHandlerFactory`	`createTransactionHandlerFactory(ILcdOGCModelProvider aModelProvider, ILcdWFSLockFactory aLockFactory, ILcdWFSFilteredModelFactory aFilteredModelFactory, ILcdWFSServerModelEncoderFactory aServerModelEncoderFactory)` Creates a transaction handler factory.
`protected ILcdWFSCapabilitiesProvider`	`createWFSCapabilitiesProvider(ILcdInitializationConfig aConfig, ILcdOGCModelProvider aModelProvider, ILcdModelReferenceFormatter aModelReferenceFormatter, ILcdModelReferenceParser aModelReferenceParser)` Creates a WFS capabilities provider.
`protected TLcdWFSCommandDispatcher`	`createWFSCommandDispatcherInstance()` Called by `createWFSCommandDispatcher()` to create a command dispatcher.
`protected ILcdWFSFeatureTypeListDecoder`	`createWFSFeatureTypeListDecoder(ILcdOGCModelProvider aModelProvider)` Deprecated. Since 2017.0 Please make use of `ILcdWFSCapabilitiesProvider`.
`ILcdModelReferenceFormatter`	`getModelReferenceFormatter()` Get the model reference formatter used by the server.
`ILcdModelReferenceParser`	`getModelReferenceParser()` Get the model reference parser used by the server.
`protected void`	`registerModelReferenceFormatters()` This is called during initialization to give users the opportunity to register a number of `ILcdModelReferenceFormatter`s.
`protected void`	`registerModelReferenceParsers()` This is called during initialization to give users the opportunity to register a number of `ILcdModelReferenceParser`s.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ALcdOGCWFSCommandDispatcherFactory
```
public ALcdOGCWFSCommandDispatcherFactory()
```
- Method Detail
  - createCommandDispatcher
```
public ALcdOGCCommandDispatcher createCommandDispatcher(ILcdInitializationConfig aConfig)
                                                 throws TLcdOGCServiceException
```
    Called during servlet initialization to create a command dispatcher. This method also configures the dispatcher, by registering the necessary request handlers and setting up global objects such as a model decoder factory.
    
    Specified by:
    
    createCommandDispatcher in interface ILcdOGCCommandDispatcherFactory
    
    Parameters:
    
    aConfig - The servlet configuration parameters loaded from web.xml.
    
    Returns:
    
    An ALcdOGCCommandDispatcher
    
    Throws:
    
    TLcdOGCServiceException - when the creation process fails
    
    See Also:
    
    createWFSCommandDispatcherInstance()
  - createModelDecoderFactory
```
protected ILcdOGCModelDecoderFactory createModelDecoderFactory()
```
    Creates an ILcdOGCModelDecoderFactory. The ILcdOGCModelDecoderFactory is used by the server to load data: it is responsible of creating an ILcdModelDecoder for a given source. This ILcdModelDecoder is then used to decode the data identified by that source.
    
    By default, this method returns a TLcdOGCModelDecoderFactory instance. This implementation uses TLcdServiceLoader to find ILcdModelDecoder instances.
    
    Returns:
    
    an ILcdOGCModelDecoderFactory to read data at the server
  - createClientModelEncoderFactory
```
protected ILcdWFSClientModelEncoderFactory createClientModelEncoderFactory()
```
    Creates an ILcdWFSClientModelEncoderFactory. The ILcdWFSClientModelEncoderFactory is used by the server to create an ILcdModelEncoder for the output format requested by the client. The ILcdModelEncoder is then used to encode the features that were returned by the server.
    This factory is also used to generate encoders for the schemas that describe the data. These schemas can be requested using DescribeFeatureType requests.
    The ILcdWFSClientModelEncoderFactory also specifies the output formats that will be supported by the server, these output formats will be advertised in the capabilities document of the server.
    By default, the TLcdServiceLoader is used to find an ILcdWFSClientModelEncoderFactory instance. If multiple instances are found, the one annotated with the highest priority is used. If no instance is found or if null is returned, TLcdWFSClientModelEncoderFactory is used by default.
    
    Returns:
    
    an ILcdWFSClientModelEncoderFactory to send data to the client
  - createServerModelEncoderFactory
```
protected ILcdWFSServerModelEncoderFactory createServerModelEncoderFactory()
```
    Creates an ILcdWFSServerModelEncoderFactory. The ILcdWFSServerModelEncoderFactory is used by the default transaction handler to store modified data at the server.
    A server model encoder factory is required if the default transaction handler is used; otherwise it depends on the implementation of the ALcdWFSTransactionHandler that is created by the ILcdWFSTransactionHandlerFactory.
    To enable transactions, the servlet configuration parameter 'wfs.enableTransactions' should be set to 'true'.
    
    Returns:
    
    an ILcdWFSServerModelEncoderFactory to store modified data at the server, returns null by default.
    
    See Also:
    
    createTransactionHandlerFactory(com.luciad.ogc.common.ILcdOGCModelProvider, ILcdWFSLockFactory, ILcdWFSFilteredModelFactory, ILcdWFSServerModelEncoderFactory)
  - createModelProvider
```
protected ILcdOGCModelProvider createModelProvider(ILcdOGCModelDecoderFactory aModelDecoderFactory)
```
    Creates an ILcdOGCModelProvider, which provides central access to all models. The server uses this interface to retrieve a model, instead of directly using the model decoder factory (see createModelDecoderFactory()). The model decoder factory should only be used by the ILcdOGCModelProvider to decode the necessary models. This centralized access allows implementations to define additional functionality, like a cache mechanism.
    The default implementation returns a TLcdOGCModelProvider that maintains a cache for all decoded models. To prevent memory problems, it makes use of soft reference objects, which are cleared at the discretion of the garbage collector in response to memory demand. Soft references are most often used to implement memory-sensitive caches.
    The request context object type supplied to the ILcdOGCModelProvider#getModel(String, ILcdRequestContext) is of the type TLcdWFSRequestContext.
    
    Parameters:
    
    aModelDecoderFactory - The model decoder factory that must be used by the model provider to read data
    
    Returns:
    
    a model provider.
  - createLockFactory
```
protected ILcdWFSLockFactory createLockFactory(ILcdWFSFilteredModelFactory aFilteredModelFactory)
```
    Creates a lock factory which creates locks for locking support. To enable locking the servlet configuration parameter 'wfs.enableLocking' should be set to 'true'.
    The default implementation creates a factory which locks all features 'in memory'. This means that the data in the underlying data store can still be read or written by other processes at all times.
    
    Parameters:
    
    aFilteredModelFactory - The filtered model factory which can be used to retrieve features to be locked, this is the factory that is created by createFilteredModelFactory().
    
    Returns:
    
    A valid lock factory.
    
    Since:
    
    10.0
  - createTransactionHandlerFactory
```
protected ILcdWFSTransactionHandlerFactory createTransactionHandlerFactory(ILcdOGCModelProvider aModelProvider,
                                                                           ILcdWFSLockFactory aLockFactory,
                                                                           ILcdWFSFilteredModelFactory aFilteredModelFactory,
                                                                           ILcdWFSServerModelEncoderFactory aServerModelEncoderFactory)
```
    Creates a transaction handler factory. This is only required in case the WFS server should support transactions.
    The default implementation of this method creates a transaction handler which applies the changes to an ILcdModel, and stores these changes on commit using an ILcdModelEncoder created by the ILcdWFSServerModelEncoderFactory.
    To enable transactions, the servlet configuration parameter 'wfs.enableTransactions' should be set to 'true'.
    
    Parameters:
    
    aModelProvider - the model provider created by createModelProvider(com.luciad.ogc.common.ILcdOGCModelDecoderFactory).
    
    aLockFactory - the lock factory created by createLockFactory(com.luciad.ogc.wfs.ILcdWFSFilteredModelFactory).
    
    aFilteredModelFactory - the filtered model factory created by createFilteredModelFactory(com.luciad.ogc.wfs.ILcdWFSCapabilitiesProvider, com.luciad.ogc.common.ILcdOGCModelProvider)
    
    aServerModelEncoderFactory - the server model encoder factory created by createServerModelEncoderFactory()
    
    Returns:
    
    a valid transaction handler factory, or null if transactional support is not required.
    
    Since:
    
    10.0 f
  - createWFSCommandDispatcherInstance
```
protected TLcdWFSCommandDispatcher createWFSCommandDispatcherInstance()
```
    Called by createWFSCommandDispatcher() to create a command dispatcher.
    
    Returns:
    
    a TLcdWFSCommandDispatcher.
  - createWFSFeatureTypeListDecoder
```
protected ILcdWFSFeatureTypeListDecoder createWFSFeatureTypeListDecoder(ILcdOGCModelProvider aModelProvider)
```
    Deprecated. Since 2017.0 Please make use of ILcdWFSCapabilitiesProvider.
    
    Called during servlet initialization to create an ILcdWFSFeatureTypeListDecoder. The feature type list decoder is responsible for creating the list of data offered by the WFS service.
    
    If access to the data is required to construct the feature type list (e.g., to add more info about the data to the corresponding ILcdWFSFeatureType), the supplied ILcdOGCModelProvider should be used. This instance provides central access to all models that need to be decoded.
    
    By default, this method will return null. Unless the createWFSCapabilitiesProvider method is implemented directly, this method needs to be implemented as well.
    
    Parameters:
    
    aModelProvider - The model provider used to read data
    
    Returns:
    
    an ILcdWFSFeatureTypeListDecoder
  - createWFSCapabilitiesProvider
```
protected ILcdWFSCapabilitiesProvider createWFSCapabilitiesProvider(ILcdInitializationConfig aConfig,
                                                                    ILcdOGCModelProvider aModelProvider,
                                                                    ILcdModelReferenceFormatter aModelReferenceFormatter,
                                                                    ILcdModelReferenceParser aModelReferenceParser)
                                                             throws TLcdOGCServiceException
```
    Creates a WFS capabilities provider.
    
    By default, this method creates an ILcdWFSCapabilitiesProvider instance based on the results of the following methods:
    This method offers advantages over these separate methods. It in particular eases the implementation of access control, and it allows to return feature types lazily. See ILcdWFSCapabilitiesProvider for more information.
    Parameters:
    
    aConfig - The servlet configuration parameters.
    
    aModelProvider - The model provider
    
    aModelReferenceFormatter - Formatter for model references.
    
    aModelReferenceParser - Parser for model references.
    
    Returns:
    
    a WFS capabilities provider, never null.
    
    Throws:
    
    TLcdOGCServiceException - when the capabilities provider can not be created.
    
    Since:
    
    2017.0
  - registerModelReferenceFormatters
```
protected void registerModelReferenceFormatters()
```
    This is called during initialization to give users the opportunity to register a number of ILcdModelReferenceFormatters. These reference formatters are used to generate the SRS strings for each feature type, as listed in the WFS capabilities document. To register a new reference formatter, use the addModelReferenceFormatter(ILcdModelReferenceFormatter) method. The formatter that should be called first should be added last.
  - addModelReferenceFormatter
```
protected final void addModelReferenceFormatter(ILcdModelReferenceFormatter aFormatter)
```
    Adds a reference formatter.
    
    Parameters:
    
    aFormatter - An ILcdModelReferenceFormatter
  - registerModelReferenceParsers
```
protected void registerModelReferenceParsers()
```
    This is called during initialization to give users the opportunity to register a number of ILcdModelReferenceParsers. These reference parsers are used to parse incoming srs strings. To register a new reference parser, use the addModelReferenceParser(ILcdModelReferenceParser) method. The parser that should be called first should be added last.
    
    Since:
    
    10.0
  - addModelReferenceParser
```
protected final void addModelReferenceParser(ILcdModelReferenceParser aParser)
```
    Adds a reference parser.
    
    Parameters:
    
    aParser - An ILcdModelReferenceParser
    
    Since:
    
    10.0
  - createFilteredModelFactory
```
protected ILcdWFSFilteredModelFactory createFilteredModelFactory(ILcdWFSCapabilitiesProvider aCapabilitiesProvider,
                                                                 ILcdOGCModelProvider aModelProvider)
                                                          throws TLcdOGCServiceException
```
    Creates an ILcdWFSFilteredModelFactory. This factory is responsible for supporting the use of filters in WFS requests.
    
    Parameters:
    
    aCapabilitiesProvider - The list of data offered by the WFS service
    
    aModelProvider - The model provider used to read data
    
    Returns:
    
    an ILcdWFSFilteredModelFactory
    
    Throws:
    
    TLcdOGCServiceException - if the creation of the object fails
  - createServiceMetaData
```
protected ILcdWFSServiceMetaData createServiceMetaData()
```
    Deprecated. Since 2017.0 Please make use of ILcdWFSCapabilitiesProvider.
    
    Creates an ILcdWFSServiceMetaData, which provides values to be written to the Service section of the WFS capabilities. If this method returns null, default values will be written to the capabilities.
    
    Returns:
    
    an ILcdWFSServiceMetaData
  - createServiceProvider
```
public TLcdOWSServiceProvider createServiceProvider()
```
    Deprecated. Since 2017.0 Please make use of ILcdWFSCapabilitiesProvider.
    
    Returns the general service info/metadata that will appear in the server's capabilities.
    
    Returns:
    
    the general service info/metadata that will appear in the server's capabilities.
    
    Since:
    
    10.0
  - createTransactionContentDataModels
```
protected List<TLcdDataModel> createTransactionContentDataModels(ILcdInitializationConfig aConfig)
```
    Creates the data models to configure the transaction XML decoder used by the transaction request handler.
    
    The transaction XML decoder is already configured with the data models required to parse regular WFS transaction requests containing GML data. Through this method, additional data models can be supplied to make the decoder aware of specific formats (for example AIXM 5.1).
    
    The default implementation of this method picks up all suitable data models available in the Luciad API, including AIXM 5.1.
    
    Each data model needs to be equipped with annotations of type TLcdXMLSchemaMappingAnnotation that indicate how the XML data needs to be decoded. This is automatically the case for all XML format-based data models available in the Luciad API and for data models created via TLcdXMLDataModelBuilder.
    
    Parameters:
    
    aConfig - The servlet configuration parameters
    
    Returns:
    
    the data models to configure the transaction XML decoder
    
    Since:
    
    2017.0
  - getModelReferenceFormatter
```
public ILcdModelReferenceFormatter getModelReferenceFormatter()
```
    Get the model reference formatter used by the server.
    
    Returns:
    
    the model reference formatter
    
    Since:
    
    2012.1
  - getModelReferenceParser
```
public ILcdModelReferenceParser getModelReferenceParser()
```
    Get the model reference parser used by the server.
    
    Returns:
    
    the model reference parser
    
    Since:
    
    2012.1
  - createRequestHandler
```
public ILcdRequestHandler createRequestHandler(String aRequest,
                                               TLcdWFSCommandDispatcherContext aCommandDispatcherContext)
                                        throws TLcdWFSServiceException
```
    Factory method to create a WFS request handler. This method is called for all requests defined by the WFS specification, and the returned handlers are registered with the WFS command dispatcher.
    
    Parameters:
    
    aRequest - the name of a WFS request, e.g. "GetCapabilities"
    
    aCommandDispatcherContext - global objects that may be used by the request handlers
    
    Returns:
    
    an ILcdRequestHandler that can respond to the specified request
    
    Throws:
    
    TLcdWFSServiceException - if no handler can be created
    
    See Also:
    
    createCommandDispatcher(com.luciad.ogc.common.ILcdInitializationConfig)

LuciadFusionClass ALcdOGCWFSCommandDispatcherFactory

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ALcdOGCWFSCommandDispatcherFactory

Method Detail

createCommandDispatcher

createModelDecoderFactory

createClientModelEncoderFactory

createServerModelEncoderFactory

createModelProvider

createLockFactory

createTransactionHandlerFactory

createWFSCommandDispatcherInstance

createWFSFeatureTypeListDecoder

createWFSCapabilitiesProvider

registerModelReferenceFormatters

addModelReferenceFormatter

registerModelReferenceParsers

addModelReferenceParser

createFilteredModelFactory

createServiceMetaData

createServiceProvider

createTransactionContentDataModels

getModelReferenceFormatter

getModelReferenceParser

createRequestHandler