Java tutorial
/* * GeoTools - The Open Source Java GIS Toolkit * http://geotools.org * * (C) 2005-2008, Open Source Geospatial Foundation (OSGeo) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * This package contains documentation from OpenGIS specifications. * OpenGIS consortium's work is fully acknowledged here. */ package org.geotools.referencing.factory; import java.util.Set; import java.util.logging.Level; import javax.measure.unit.Unit; import org.apache.commons.pool.ObjectPool; import org.apache.commons.pool.ObjectPoolFactory; import org.apache.commons.pool.PoolableObjectFactory; import org.apache.commons.pool.impl.GenericObjectPool; import org.apache.commons.pool.impl.GenericObjectPoolFactory; import org.apache.commons.pool.impl.GenericObjectPool.Config; import org.geotools.factory.BufferedFactory; import org.geotools.factory.Hints; import org.geotools.util.ObjectCache; import org.geotools.util.ObjectCaches; import org.opengis.metadata.citation.Citation; import org.opengis.referencing.AuthorityFactory; import org.opengis.referencing.FactoryException; import org.opengis.referencing.IdentifiedObject; import org.opengis.referencing.crs.CRSAuthorityFactory; import org.opengis.referencing.crs.CompoundCRS; import org.opengis.referencing.crs.CoordinateReferenceSystem; import org.opengis.referencing.crs.DerivedCRS; import org.opengis.referencing.crs.EngineeringCRS; import org.opengis.referencing.crs.GeocentricCRS; import org.opengis.referencing.crs.GeographicCRS; import org.opengis.referencing.crs.ImageCRS; import org.opengis.referencing.crs.ProjectedCRS; import org.opengis.referencing.crs.TemporalCRS; import org.opengis.referencing.crs.VerticalCRS; import org.opengis.referencing.cs.CSAuthorityFactory; import org.opengis.referencing.cs.CartesianCS; import org.opengis.referencing.cs.CoordinateSystem; import org.opengis.referencing.cs.CoordinateSystemAxis; import org.opengis.referencing.cs.CylindricalCS; import org.opengis.referencing.cs.EllipsoidalCS; import org.opengis.referencing.cs.PolarCS; import org.opengis.referencing.cs.SphericalCS; import org.opengis.referencing.cs.TimeCS; import org.opengis.referencing.cs.VerticalCS; import org.opengis.referencing.datum.Datum; import org.opengis.referencing.datum.DatumAuthorityFactory; import org.opengis.referencing.datum.Ellipsoid; import org.opengis.referencing.datum.EngineeringDatum; import org.opengis.referencing.datum.GeodeticDatum; import org.opengis.referencing.datum.ImageDatum; import org.opengis.referencing.datum.PrimeMeridian; import org.opengis.referencing.datum.TemporalDatum; import org.opengis.referencing.datum.VerticalDatum; import org.opengis.referencing.operation.CoordinateOperation; import org.opengis.referencing.operation.CoordinateOperationAuthorityFactory; import org.opengis.util.InternationalString; /** * An authority mediator that consults (a possibily shared) cache before delegating the generation * of the content to a "worker" authority factory. * </p> * The behaviour of the {@code createFoo(String)} methods first looks if a previously created object * exists for the given code. If such an object exists, it is returned directly. The testing of the * cache is synchronized and may block if the referencing object is under construction. * <p> * If the object is not yet created, the definition is delegated to the appropriate * {@code createFoo} method of the factory, which will cache the result for next time. * <p> * This object is responsible for maintaining an {{ObjectCache}} of "workers" based on the following: * <ul> * <li>Hints.AUTHORITY_MAX_ACTIVE (default 2) - indicates the maximum number of worker created, if non * positive the number of workers is unbounded. * <li>Hints. * </ul> * </p> * * @since 2.4 * * * @source $URL$ * @version $Id$ * @author Jody Garnett (Refractions Research) * @author Cory Horner (Refractions Research) */ public abstract class AbstractAuthorityMediator extends AbstractAuthorityFactory implements AuthorityFactory, CRSAuthorityFactory, CSAuthorityFactory, DatumAuthorityFactory, CoordinateOperationAuthorityFactory, BufferedFactory { static final int PRIORITY = MAXIMUM_PRIORITY - 10; /** * Cache to be used for referencing objects defined by this authority. Please note that this * cache may be shared! * <p> * Your cache may grow to considerable size during actual use; in addition to storing * CoordinateReferenceSystems (by code); it will also store all the component parts * (each under its own code), along with MathTransformations between two * CoordinateReferenceSystems. So even if you are only planning on working with * 50 CoordianteReferenceSystems please keep in mind that you will need larger * cache size in order to prevent a bottleneck. */ ObjectCache cache; /** * The findCache is used to store search results; often match a "raw" CoordinateReferenceSystem * created from WKT (as the key) with a "real" CoordianteReferenceSystem as defined * by this authority. */ ObjectCache findCache; /** * Pool to hold workers which will be used to construct referencing objects which are not * present in the cache. */ private ObjectPool workers; /** * Configuration object for the object pool. The constructor reads its hints and sets the pool * configuration in this object; */ Config poolConfig = new Config(); /** * A container of the "real factories" actually used to construct objects. */ protected final ReferencingFactoryContainer factories; /** * Constructs an instance making use of the default cache and priority level. */ protected AbstractAuthorityMediator() { this(PRIORITY); } /** * Constructs an instance based on the provided Hints * * @param factory The factory to cache. Can not be {@code null}. */ protected AbstractAuthorityMediator(Hints hints) { this(PRIORITY, hints); } /** * Constructs an instance making use of the default cache. * * @param factory The factory to cache. Can not be {@code null}. */ protected AbstractAuthorityMediator(int priority) { this(priority, ObjectCaches.create("weak", 50), ReferencingFactoryContainer.instance(null)); } /** * Constructs an instance making use of the default cache. * * @param factory The factory to cache. Can not be {@code null}. */ protected AbstractAuthorityMediator(int priority, Hints hints) { this(priority, ObjectCaches.create(hints), ReferencingFactoryContainer.instance(hints)); // configurable behaviour poolConfig.minIdle = Hints.AUTHORITY_MIN_IDLE.toValue(hints); poolConfig.maxIdle = Hints.AUTHORITY_MAX_IDLE.toValue(hints); poolConfig.maxActive = Hints.AUTHORITY_MAX_ACTIVE.toValue(hints); poolConfig.minEvictableIdleTimeMillis = Hints.AUTHORITY_MIN_EVICT_IDLETIME.toValue(hints); poolConfig.softMinEvictableIdleTimeMillis = Hints.AUTHORITY_SOFTMIN_EVICT_IDLETIME.toValue(hints); poolConfig.timeBetweenEvictionRunsMillis = Hints.AUTHORITY_TIME_BETWEEN_EVICTION_RUNS.toValue(hints); // static behaviour poolConfig.maxWait = -1; // block indefinitely until a worker is available poolConfig.whenExhaustedAction = GenericObjectPool.WHEN_EXHAUSTED_BLOCK; } /** * Constructs an instance making use of the indicated cache. * <p> * This constructor is protected because subclasses must declare which of the * {@link DatumAuthorityFactory}, {@link CSAuthorityFactory}, {@link CRSAuthorityFactory} and * {@link CoordinateOperationAuthorityFactory} interfaces they choose to implement. * * @param factory The factory to cache. Can not be {@code null}. * @param maxStrongReferences The maximum number of objects to keep by strong reference. */ protected AbstractAuthorityMediator(int priority, ObjectCache cache, ReferencingFactoryContainer container) { super(priority); this.factories = container; this.cache = cache; this.findCache = ObjectCaches.chain(ObjectCaches.create("weak", 0), cache); } protected void completeHints() { hints.put(Hints.DATUM_AUTHORITY_FACTORY, this); hints.put(Hints.CS_AUTHORITY_FACTORY, this); hints.put(Hints.CRS_AUTHORITY_FACTORY, this); hints.put(Hints.COORDINATE_OPERATION_AUTHORITY_FACTORY, this); } /** * True if this mediator is currently connected to one or more workers. * * @return */ public boolean isConnected() { return (workers.getNumActive() + workers.getNumIdle()) > 0; } ObjectPool getPool() { if (workers == null) { // create pool PoolableObjectFactory objectFactory = new AuthorityPoolableObjectFactory(); ObjectPoolFactory poolFactory = new GenericObjectPoolFactory(objectFactory, poolConfig); this.setPool(poolFactory.createPool()); } return workers; } void setPool(ObjectPool pool) { this.workers = pool; } // // Utility Methods and Cache Care and Feeding // protected String toKey(String code) { return ObjectCaches.toKey(getAuthority(), code); } /** * Trims the authority scope, if present. For example if this factory is an EPSG authority * factory and the specified code start with the "EPSG:" prefix, then the prefix is removed. * Otherwise, the string is returned unchanged (except for leading and trailing spaces). * * @param code The code to trim. * @return The code without the authority scope. */ protected String trimAuthority(String code) { return toKey(code); } /** * The authority body of the objects this factory provides. */ public abstract Citation getAuthority(); public Set getAuthorityCodes(Class type) throws FactoryException { Set codes = (Set) cache.get(type); if (codes == null) { try { cache.writeLock(type); codes = (Set) cache.peek(type); if (codes == null) { AbstractCachedAuthorityFactory worker = null; try { worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); codes = worker.getAuthorityCodes(type); cache.put(type, codes); } catch (FactoryException e) { throw e; } catch (Exception e) { throw new FactoryException(e); } finally { try { getPool().returnObject(worker); } catch (Exception e) { LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); } } } } finally { cache.writeUnLock(type); } } return codes; } public abstract InternationalString getDescriptionText(String code) throws FactoryException; public IdentifiedObject createObject(String code) throws FactoryException { final String key = toKey(code); IdentifiedObject obj = (IdentifiedObject) cache.get(key); if (obj == null) { try { cache.writeLock(key); obj = (IdentifiedObject) cache.peek(key); if (obj == null) { AbstractCachedAuthorityFactory worker = null; try { worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); obj = worker.createDerivedCRS(code); cache.put(key, obj); } catch (FactoryException e) { throw e; } catch (Exception e) { throw new FactoryException(e); } finally { try { getPool().returnObject(worker); } catch (Exception e) { LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); } } } } finally { cache.writeUnLock(key); } } return obj; } // // CRSAuthority // public synchronized CompoundCRS createCompoundCRS(final String code) throws FactoryException { final String key = toKey(code); CompoundCRS crs = (CompoundCRS) cache.get(key); if (crs == null) { try { cache.writeLock(key); crs = (CompoundCRS) cache.peek(key); if (crs == null) { AbstractCachedAuthorityFactory worker = null; try { worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); crs = worker.createCompoundCRS(code); cache.put(key, crs); } catch (FactoryException e) { throw e; } catch (Exception e) { throw new FactoryException(e); } finally { try { getPool().returnObject(worker); } catch (Exception e) { LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); } } } } finally { cache.writeUnLock(key); } } return crs; } public CoordinateReferenceSystem createCoordinateReferenceSystem(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createCoordinateReferenceSystem(key); } }); } public DerivedCRS createDerivedCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createEngineeringCRS(key); } }); } public GeocentricCRS createGeocentricCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createGeocentricCRS(key); } }); } public GeographicCRS createGeographicCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createGeographicCRS(key); } }); } public ImageCRS createImageCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createImageCRS(key); } }); } public ProjectedCRS createProjectedCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createProjectedCRS(key); } }); } public TemporalCRS createTemporalCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createTemporalCRS(key); } }); } public VerticalCRS createVerticalCRS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createVerticalCRS(key); } }); } // // CSAuthority // public CartesianCS createCartesianCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createCartesianCS(key); } }); } public CoordinateSystem createCoordinateSystem(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createCoordinateSystem(key); } }); } // sample implemenation with get/test public CoordinateSystemAxis createCoordinateSystemAxis(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createCoordinateSystemAxis(key); } }); } public CylindricalCS createCylindricalCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createCylindricalCS(key); } }); } public EllipsoidalCS createEllipsoidalCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createEllipsoidalCS(key); } }); } public PolarCS createPolarCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createPolarCS(key); } }); } public SphericalCS createSphericalCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createSphericalCS(key); } }); } public TimeCS createTimeCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createTimeCS(key); } }); } public Unit<?> createUnit(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createUnit(key); } }); } public VerticalCS createVerticalCS(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createVerticalCS(key); } }); } // // DatumAuthorityFactory // public Datum createDatum(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createDatum(key); } }); } public Ellipsoid createEllipsoid(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createEllipsoid(key); } }); } public EngineeringDatum createEngineeringDatum(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createEngineeringDatum(key); } }); } public GeodeticDatum createGeodeticDatum(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createGeodeticDatum(key); } }); } public ImageDatum createImageDatum(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createImageDatum(key); } }); } public PrimeMeridian createPrimeMeridian(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createPrimeMeridian(key); } }); } public TemporalDatum createTemporalDatum(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createTemporalDatum(key); } }); } public VerticalDatum createVerticalDatum(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createVerticalDatum(key); } }); } public CoordinateOperation createCoordinateOperation(String code) throws FactoryException { final String key = toKey(code); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createCoordinateOperation(key); } }); } public synchronized Set/* <CoordinateOperation> */ createFromCoordinateReferenceSystemCodes( final String sourceCode, final String targetCode) throws FactoryException { final Object key = ObjectCaches.toKey(getAuthority(), sourceCode, targetCode); return createWith(key, new WorkerSafeRunnable() { public Object run(AbstractCachedAuthorityFactory worker) throws FactoryException { return worker.createFromCoordinateReferenceSystemCodes(sourceCode, targetCode); } }); } /** * This method is used to cut down the amount of try/catch/finally code * needed when working with the cache and workers. * <p> * This code brings together two try/catch/finally blocks. * * For cache management:<pre><code> * T value = (T) cache.get(key); * if (value == null) { * try { * cache.writeLock(key); * value = (T) cache.peek(key); * if (value == null) { * ....generate value.... * cache.put( key, value ); * } * } finally { * cache.writeUnLock(key); * } * } * </code></pre> * And worker management when generating values:<pre><code> * AbstractCachedAuthorityFactory worker = null; * try { * worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); * value = (T) runner.run( worker ); * } catch (FactoryException e) { * throw e; * } catch (Exception e) { * throw new FactoryException(e); * } finally { * try { * getPool().returnObject(worker); * } catch (Exception e) { * LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); * } * } * </code></pre> * * @param key Used to look in the cache * @param runner Used to generate a value in the case of a cache miss * @return value from either the cache or generated */ protected <T> T createWith(Object key, WorkerSafeRunnable runner) throws FactoryException { T value = (T) cache.get(key); if (value == null) { try { cache.writeLock(key); value = (T) cache.peek(key); if (value == null) { AbstractCachedAuthorityFactory worker = null; try { worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); value = (T) runner.run(worker); } catch (FactoryException e) { throw e; } catch (Exception e) { throw new FactoryException(e); } finally { try { getPool().returnObject(worker); } catch (Exception e) { LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); } } cache.put(key, value); } } finally { cache.writeUnLock(key); } } return value; } /** * An interface describing a portion of work for which a worker is needed. * <p> * The worker is borrowed from the pool */ protected abstract class WorkerSafeRunnable { public abstract Object run(AbstractCachedAuthorityFactory worker) throws FactoryException; } public String getBackingStoreDescription() throws FactoryException { AbstractCachedAuthorityFactory worker = null; try { worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); return worker.getBackingStoreDescription(); } catch (FactoryException e) { throw e; } catch (Exception e) { throw new FactoryException(e); } finally { try { getPool().returnObject(worker); } catch (Exception e) { LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); } } } /** * Clean up the object pool of workers (since we are shutting down). * <p> * Subclasses may wish to override this method if they have their own resources * to clean up (like a database connection). If you do this please remember to call * super.dispose(). * </p> */ public void dispose() throws FactoryException { if (workers != null) { try { workers.clear(); } catch (FactoryException e) { throw e; } catch (Exception e) { throw new FactoryException(e); } workers = null; } } /** * Creates the objects, subclasses of AbstractCachedAuthorityFactory, which are held by the * ObjectPool. This implementation simply delegates each method to the subclass. * * @author Cory Horner (Refractions Research) */ private class AuthorityPoolableObjectFactory implements PoolableObjectFactory { AuthorityPoolableObjectFactory() { } public void activateObject(Object obj) throws Exception { AbstractCachedAuthorityFactory worker = (AbstractCachedAuthorityFactory) obj; worker.cache = cache; activateWorker(worker); } public void destroyObject(Object obj) throws Exception { destroyWorker((AbstractCachedAuthorityFactory) obj); } public Object makeObject() throws Exception { AbstractCachedAuthorityFactory worker = makeWorker(); return worker; } public void passivateObject(Object obj) throws Exception { passivateWorker((AbstractCachedAuthorityFactory) obj); } public boolean validateObject(Object obj) { return validateWorker((AbstractCachedAuthorityFactory) obj); } } /** * Reinitialize an instance to be returned by the pool. * <p> * Please note that BEFORE this method has been called AbstractAuthorityMediator has already: * <ul> * <li>provided the worker with the single shared <code>cache</code> * <li>provided the worker with the single shared <code>findCache</code> * </ul> */ protected abstract void activateWorker(AbstractCachedAuthorityFactory worker) throws Exception; /** * Destroys an instance no longer needed by the pool. */ protected abstract void destroyWorker(AbstractCachedAuthorityFactory worker) throws Exception; /** * Creates an instance that can be returned by the pool. */ protected abstract AbstractCachedAuthorityFactory makeWorker() throws Exception; /** * Un-initialize an instance to be returned to the pool. */ protected abstract void passivateWorker(AbstractCachedAuthorityFactory worker) throws Exception; /** * Ensures that the instance is safe to be returned by the pool. */ protected abstract boolean validateWorker(AbstractCachedAuthorityFactory worker); /** * Returns a finder which can be used for looking up unidentified objects. * <p> * The returned implementation will make use of workers as needed. * * @param type The type of objects to look for. * @return A finder to use for looking up unidentified objects. * @throws FactoryException if the finder can not be created. * @since 2.4 */ public IdentifiedObjectFinder getIdentifiedObjectFinder(final Class/* <? extends IdentifiedObject> */ type) throws FactoryException { return new LazyCachedFinder(type); } /** * An {@link IdentifiedObjectFinder} which uses a worker when searching. * <p> * The worker used is configured to store answers in a separate <code>findCache</code>, rather * that disrupt the regular <code>cached</code>(which is focused on retaining codes requested * by the user application). This is because hundred of objects may be created during a * scan while only one will be typically retained. We don't want to overload the cache with * every false candidates that we encounter during the scan. * <p> * Because the worker is configured differently before use we must be careful to return it to * its original state before returning back to the <code>workers</code> pool. */ private final class LazyCachedFinder extends IdentifiedObjectFinder { private Class type; /** * Creates a finder for the underlying backing store. */ LazyCachedFinder(final Class type) { super(AbstractAuthorityMediator.this, type); this.type = type; } /** * Looks up an object from this authority factory which is equals, ignoring metadata, * to the specified object. The default implementation performs the same lookup than * the backing store and caches the result. */ @Override public IdentifiedObject find(final IdentifiedObject object) throws FactoryException { IdentifiedObject candidate; candidate = (IdentifiedObject) findCache.get(object); if (candidate != null) { return candidate; } try { findCache.writeLock(object); // avoid searching for the same object twice IdentifiedObject found; AbstractCachedAuthorityFactory worker = null; try { worker = (AbstractCachedAuthorityFactory) getPool().borrowObject(); worker.cache = ObjectCaches.chain(ObjectCaches.create("weak", 3000), cache); worker.findCache = findCache; setProxy(AuthorityFactoryProxy.getInstance(worker, type)); found = super.find(object); } catch (Exception e) { throw new FactoryException(e); } finally { setProxy(null); worker.cache = cache; worker.findCache = findCache; try { getPool().returnObject(worker); } catch (Exception e) { LOGGER.log(Level.WARNING, "Unable to return worker " + e, e); } } if (found == null) { return null; // not found } candidate = (IdentifiedObject) findCache.peek(object); if (candidate == null) { findCache.put(object, found); return found; } else { return candidate; } } finally { findCache.writeUnLock(object); } } protected Citation getAuthority() { return AbstractAuthorityMediator.this.getAuthority(); } /** * Returns the identifier for the specified object. */ @Override public String findIdentifier(final IdentifiedObject object) throws FactoryException { IdentifiedObject candidate; candidate = (IdentifiedObject) findCache.get(object); if (candidate != null) { return getIdentifier(candidate); } return super.findIdentifier(object); } } }