Class FactoryRegistry
- Direct Known Subclasses:
AnnotatedBeanProcessFactory.BeanFactoryRegistry
,FactoryCreator
CRSFactory.class
is a category, and
MathTransformFactory.class
is another category.
For each category, implementations are registered in a file placed in the META-INF/services/
directory, as
specified in the CategoryRegistry
javadoc. Those files are usually bundled into the JAR file distributed by
the vendor. If the same META-INF/services/
file appears many time in different JARs, they are processed as if
their content were merged.
Example use:
Set<Class<?>> categories =
Collections.singleton(new Class<?>[] {
MathTransformProvider.class
});
FactoryRegistry registry = new FactoryRegistry(categories);
// get the factories
Predicate filter = null;
Hints hints = null;
Iterator<MathTransform> providers =
registry.getFactories(MathTransformProvider.class, null, hints);
NOTE: This class is not thread safe. Users are responsible for synchronisation. This is usually
done in an utility class wrapping this factory registry (e.g.
ReferencingFactoryFinder
).
NOTE: Java 9 Service Registry Incompatibility. Prior releases of GeoTools uses Java's built-in
ServiceRegistry
to manage instances for our plug-in system. In Java 9 the service registry
was restricted to a limited number of imageio services and was no longer available for general use. We have
introduced CategoryRegistry
to take over instance management, in conjunction with the supported
ServiceLoader
discovery.
- Since:
- 2.1
- Author:
- Martin Desruisseaux, Richard Gould, Jody Garnett
- See Also:
-
Field Summary
Fields -
Constructor Summary
ConstructorsConstructorDescriptionFactoryRegistry
(Class<?> category) Constructs a new registry for the specified category.FactoryRegistry
(Class<?>... categories) Constructs a new registry for the specified categories.FactoryRegistry
(Collection<Class<?>> categories) Constructs a new registry for the specified categories. -
Method Summary
Modifier and TypeMethodDescriptionvoid
Clear all registered factories.void
deregisterAll
(Class<?> category) Clear registered factories for a provided category.void
deregisterFactories
(Iterable<?> factories) Manually deregister factories.void
deregisterFactories
(Iterator<?> factories) Manually deregister factories.void
deregisterFactory
(Object factory) Manually deregister a factory<T> boolean
deregisterFactory
(T factory, Class<T> category) Manually deregister a factoryprotected void
finalize()
final Set<ClassLoader>
Returns all class loaders to be used for scanning plugins.<T> Stream<T>
getFactories
(Class<T> category, boolean useOrdering) Factories for the provided category type.<T> Stream<T>
getFactories
(Class<T> category, Predicate<? super T> factoryFilter, boolean useOrdering) Factories for the provided category type.<T> Stream<T>
getFactories
(Class<T> category, Predicate<? super T> filter, Hints hints) Returns the factories in the registry for the specified category, filter and hints.<T> T
getFactory
(Class<T> category, Predicate<? super T> filter, Hints hints, Hints.Key key) Returns the first factory in the registry for the specified category, using the specified map of hints (if any).<T> T
getFactoryByClass
(Class<T> category) Instance of category, or null if not available.protected <T> boolean
isAcceptable
(T factory, Class<T> category, Hints hints) Returnstrue
if the specifiedfactory
meets the requirements specified by a map ofhints
.void
registerFactories
(Iterable<?> factories) Manually register factories.void
registerFactories
(Iterator<?> factories) Manually register factories.void
registerFactory
(Object factory) Manually register a factory.<T> boolean
registerFactory
(T factory, Class<T> category) Manually register a factory.void
Scans for factory plug-ins on the application class path.<T> boolean
setOrdering
(Class<T> base, boolean set, Predicate<? super T> filter1, Predicate<? super T> filter2) Sets or unsets a pairwise ordering between all factories meeting a criterion.<T> boolean
setOrdering
(Class<T> category, Comparator<T> comparator) Set pairwise ordering between all factories according a comparator.<T> boolean
setOrdering
(Class<T> category, T firstFactory, T secondFactory) Define pairwise ordering giving priority to thefirstFactory
over thesecondFactory
.<T> boolean
unsetOrdering
(Class<T> category, T firstFactory, T secondFactory) Removes the ordering between the specified factories, so that the first no longer appears before the second.
-
Field Details
-
LOGGER
The logger for all events related to factory registry.
-
-
Constructor Details
-
FactoryRegistry
Constructs a new registry for the specified category.- Parameters:
category
- The single category.- Since:
- 2.4
-
FactoryRegistry
Constructs a new registry for the specified categories.- Parameters:
categories
- The categories.- Since:
- 2.4
-
FactoryRegistry
Constructs a new registry for the specified categories.- Parameters:
categories
- The categories.
-
-
Method Details
-
finalize
-
streamCategories
-
getFactoryByClass
Instance of category, or null if not available.- Parameters:
category
- The category to look for. Usually an interface class (not the actual implementation class).- Returns:
- instance, or null of not available
- Since:
- 19
-
getFactories
Factories for the provided category type.- Parameters:
category
- The category to look for. Usually an interface class (not the actual implementation class).useOrdering
- true to use provided pairwise orderings- Returns:
- factories registered for category
- Since:
- 19
-
getFactories
public <T> Stream<T> getFactories(Class<T> category, Predicate<? super T> factoryFilter, boolean useOrdering) Factories for the provided category type.- Parameters:
category
- The category to look for. Usually an interface class (not the actual implementation class).factoryFilter
- Predicate to filter factories, null for all factoriesuseOrdering
- true to use provided pairwise orderings- Returns:
- factories registered for category
- Since:
- 19
-
getFactories
Returns the factories in the registry for the specified category, filter and hints. Factories that are not available will be ignored. This method will scan for plugins the first time it is invoked for the given category.- Type Parameters:
T
- The class represented by thecategory
argument.- Parameters:
category
- The category to look for. Usually an interface class (not the actual implementation class).filter
- The optional filter predicate, ornull
.hints
- The optional user requirements, ornull
.- Returns:
- Factories ready to use for the specified category, filter and hints.
- Since:
- 19
-
getFactory
public <T> T getFactory(Class<T> category, Predicate<? super T> filter, Hints hints, Hints.Key key) throws FactoryRegistryException Returns the first factory in the registry for the specified category, using the specified map of hints (if any). This method may scan for plugins the first time it is invoked. Except as a result of this scan, no new factory instance is created by the default implementation of this method. TheFactoryCreator
class change this behavior however.- Type Parameters:
T
- The class represented by thecategory
argument.- Parameters:
category
- The category to look for. Must be one of the categories declared to the constructor. Usually an interface class (not the actual implementation class).filter
- An optional filter, ornull
if none. This is used for example in order to select the first factory for some authority.hints
- A map of hints, ornull
if none.key
- The key to use for looking for a user-provided instance in the hints, ornull
if none.- Returns:
- A factory available for use for the specified category and
hints. The returns type is
Object
instead ofFactory
because the factory implementation doesn't need to be a Geotools one. - Throws:
FactoryNotFoundException
- if no factory was found for the specified category, filter and hints.FactoryRegistryException
- if a factory can't be returned for some other reason.- See Also:
-
isAcceptable
Returnstrue
if the specifiedfactory
meets the requirements specified by a map ofhints
.The default implementation always returns
true
. There is no need to override this method forAbstractFactory
implementations, since their hints are automatically checked.Override this method for non-Geotools implementations. For example a JTS geometry factory finder may overrides this method in order to check if a
GeometryFactory
uses the requiredCoordinateSequenceFactory
. Such method should be implemented as below, since this method may be invoked for various kind of objects:if (provider instanceof GeometryFactory) { // ... Check the GeometryFactory state here. }
- Type Parameters:
T
- The class represented by thecategory
argument.- Parameters:
factory
- The factory to checks.category
- The factory category. Usually an interface.hints
- The user requirements, ornull
if none.- Returns:
true
if theprovider
meets the user requirements.
-
getClassLoaders
Returns all class loaders to be used for scanning plugins. Current implementation returns the following class loaders:- Returns:
- All classloaders to be used for scanning plugins.
-
scanForPlugins
public void scanForPlugins()Scans for factory plug-ins on the application class path. This method is needed because the application class path can theoretically change, or additional plug-ins may become available. Rather than re-scanning the classpath on every invocation of the API, the class path is scanned automatically only on the first invocation. Clients can call this method to prompt a re-scan. Thus this method need only be invoked by sophisticated applications which dynamically make new plug-ins available at runtime. -
registerFactories
Manually register factories.Used to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
registerFactories
Manually register factories.Used to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
registerFactory
Manually register a factory.Used to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
registerFactory
Manually register a factory.Used to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
deregisterAll
public void deregisterAll()Clear all registered factories. -
deregisterAll
Clear registered factories for a provided category. -
deregisterFactories
Manually deregister factories.Used to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
deregisterFactories
Manually deregister factories.Used to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
deregisterFactory
Manually deregister a factoryUsed to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
deregisterFactory
Manually deregister a factoryUsed to facilitate integration with other plug-in systems, such as OSGi or Spring, that block CLASSPATH visibility of
ServiceLoader
implementation registration. -
setOrdering
Define pairwise ordering giving priority to thefirstFactory
over thesecondFactory
.- Returns:
- if this call establishes a new order
-
setOrdering
Set pairwise ordering between all factories according a comparator. Calls tocompare(factory1, factory2)
should returns:-1
iffactory1
is preferred tofactory2
+1
iffactory2
is preferred tofactory1
0
if there is no preferred order betweenfactory1
andfactory2
- Type Parameters:
T
- The class represented by thecategory
argument.- Parameters:
category
- The category to set ordering.comparator
- The comparator to use for ordering.- Returns:
true
if at least one ordering setting has been modified as a consequence of this call.
-
setOrdering
public <T> boolean setOrdering(Class<T> base, boolean set, Predicate<? super T> filter1, Predicate<? super T> filter2) Sets or unsets a pairwise ordering between all factories meeting a criterion.For example in the CRS framework (
org.geotools.referencing.FactoryFinder
), this is used for setting ordering between all factories provided by two vendors, or for two authorities. If one or both factories are not currently registered, or if the desired ordering is already set/unset, nothing happens and false is returned.- Type Parameters:
T
- The class represented by thebase
argument.- Parameters:
base
- The base category. Only categories assignable tobase
will be processed.set
-true
for setting the ordering, orfalse
for unsetting.filter1
- Predicate for the preferred factory.filter2
- Predicate for the factory to whichfilter1
is preferred.- Returns:
true
if the ordering changed as a result of this call.
-
unsetOrdering
Removes the ordering between the specified factories, so that the first no longer appears before the second.- Parameters:
category
- The category to clear instance order for.- Returns:
true
if that ordering was previously defined
-