FirstSupportingResourceResolver.java

  1. package fr.sii.ogham.core.resource.resolver;

  2. import static java.util.Arrays.asList;

  3. import java.util.ArrayList;
  4. import java.util.List;

  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;

  7. import fr.sii.ogham.core.exception.resource.NoResolverException;
  8. import fr.sii.ogham.core.exception.resource.ResourceResolutionException;
  9. import fr.sii.ogham.core.resource.Resource;
  10. import fr.sii.ogham.core.resource.path.ResolvedPath;
  11. import fr.sii.ogham.core.resource.path.ResourcePath;

  12. /**
  13.  * Decorator that will ask each resource resolver if it is able to handle the
  14.  * lookup. If the resource resolver can, then this implementation asks the
  15.  * resolver to really provide the resource.
  16.  *
  17.  * Only the first resource resolver that can handle the lookup is used.
  18.  *
  19.  * @author AurĂ©lien Baudet
  20.  * @see ResourceResolver
  21.  */
  22. public class FirstSupportingResourceResolver implements ResourceResolver, ResourceResolverRegistry {
  23.     private static final Logger LOG = LoggerFactory.getLogger(FirstSupportingResourceResolver.class);

  24.     /**
  25.      * The list of resolvers used to resolve the resource according to the
  26.      * lookup.
  27.      */
  28.     private List<ResourceResolver> resolvers;

  29.     /**
  30.      * Initialize the decorator with the provided resource resolver
  31.      * implementations. The registration order may be important.
  32.      *
  33.      * @param resolvers
  34.      *            the resolvers to register
  35.      */
  36.     public FirstSupportingResourceResolver(ResourceResolver... resolvers) {
  37.         this(new ArrayList<>(asList(resolvers)));
  38.     }

  39.     /**
  40.      * Initialize the decorator with the provided resource resolver
  41.      * implementations. The registration order may be important.
  42.      *
  43.      * @param resolvers
  44.      *            the resolvers to register
  45.      */
  46.     public FirstSupportingResourceResolver(List<ResourceResolver> resolvers) {
  47.         super();
  48.         this.resolvers = resolvers;
  49.     }

  50.     @Override
  51.     public Resource getResource(ResourcePath path) throws ResourceResolutionException {
  52.         LOG.debug("Finding a resolver able to handle the lookup {}...", path);
  53.         ResourceResolver supportingResolver = getSupportingResolver(path);
  54.         if (supportingResolver != null) {
  55.             return supportingResolver.getResource(path);
  56.         }
  57.         throw new NoResolverException("No resource resolver available to find resource " + path.getOriginalPath(), path);
  58.     }

  59.     /**
  60.      * Register a new resolver. The resolver is added at the end.
  61.      *
  62.      * @param resolver
  63.      *            the resolver to register
  64.      * @return this instance for fluent chaining
  65.      */
  66.     @Override
  67.     public FirstSupportingResourceResolver register(ResourceResolver resolver) {
  68.         resolvers.add(resolver);
  69.         return this;
  70.     }

  71.     @Override
  72.     public boolean supports(ResourcePath path) {
  73.         return getSupportingResolver(path) != null;
  74.     }

  75.     /**
  76.      * Find the first supporting resolver.
  77.      *
  78.      * @param path
  79.      *            the name of the path of the resource
  80.      * @return the first resolver supporting the path
  81.      */
  82.     @Override
  83.     public ResourceResolver getSupportingResolver(ResourcePath path) {
  84.         LOG.debug("Finding resolver for resource {}...", path);
  85.         for (ResourceResolver resolver : resolvers) {
  86.             if (resolver.supports(path)) {
  87.                 LOG.debug("{} can handle resource {}", resolver, path);
  88.                 return resolver;
  89.             }
  90.         }

  91.         LOG.debug("No resolver can handle path '{}'", path);
  92.         return null;
  93.     }

  94.     @Override
  95.     public List<ResourceResolver> getResolvers() {
  96.         return resolvers;
  97.     }

  98.     @Override
  99.     public ResolvedPath resolve(ResourcePath path) {
  100.         ResourceResolver supportingResolver = getSupportingResolver(path);
  101.         if (supportingResolver != null) {
  102.             return supportingResolver.resolve(path);
  103.         } else {
  104.             return null;
  105.         }
  106.     }
  107. }