HttpResources

+    package de.juplo.httpresources;
+
+
+    import org.slf4j.Logger;
+    import org.slf4j.LoggerFactory;
+    import org.springframework.core.io.Resource;
+    import org.springframework.util.Assert;
+
+    import java.io.*;
+    import java.net.URI;
+    import java.net.URISyntaxException;
+    import java.time.Clock;
+    import java.util.regex.Pattern;
+
+
+    /**
+     *
+     * @author Kai Moritz
+     */
+    public class HttpResources
+    {
+      private final static Logger LOG =
+          LoggerFactory.getLogger(HttpResources.class);
+      private final static Pattern RESOURCE_PATH_PATTERN =
+          Pattern.compile("^http", Pattern.CASE_INSENSITIVE);
+      private final static URI ABSOLUTE_PATH = URI.create("/");
+
+
+      private final HttpResourceFetcher fetcher;
+      private final Clock clock;
+
+
+      public HttpResources(HttpResourceFetcher fetcher, Clock clock)
+      {
+        Assert.notNull(fetcher, "The HttpResourceFetcher must not be null");
+        Assert.notNull(clock, "The Clock must not be null");
+        this.fetcher = fetcher;
+        this.clock = clock;
+      }
+
+
+      /**
+       * @param uri the resource location (must be a valid <code>URI</code>)
+       * @return the corresponding Resource handle (never {@code null})
+       * @see {@link HttpResources#getResource(String)}
+       */
+      public HttpResource getResource(String uri)
+      {
+        return getResource(HttpResources.convert(uri));
+      }
+
+      /**
+       * Returns the {@link HttpResource}, that represents the given {@link URI}.
+    	 * <p>Note that a Resource handle does not imply an existing resource;
+    	 * you need to invoke {@link Resource#exists} to check for existence.
+    	 * @param uri the resource location, represented as an {@link URI}
+    	 * @return the corresponding Resource handle (never {@code null})
+       */
+      public HttpResource getResource(URI uri)
+      {
+        HttpData data = fetcher.fetch(uri, HttpData.NOT_FETCHED);
+        return new HttpResource(this, fetcher, clock, uri, data);
+      }
+
+
+      public static URI convert(String url)
+      {
+        return HttpResources.normalize(URI.create(url));
+      }
+
+      public static URI normalize(URI uri)
+      {
+        uri = uri.normalize();
+
+        // An URI is opaque, if it is absolute and the scheme-specific part does
+        // not start with a slash. A HTTP-URL cannot be opaque in this meaning!
+        if (uri.isOpaque())
+          throw new IllegalArgumentException("An opaque URI is no valid HTTP-URL: " + uri);
+
+        String scheme = null;
+        if (uri.isAbsolute())
+        {
+          // Enforce scheme "HTTP" or "HTTPS"
+          switch (uri.getScheme().toLowerCase())
+          {
+            case "http":
+              scheme = "http";
+              break;
+            case "https":
+              scheme = "https";
+              break;
+            default:
+              throw new IllegalArgumentException("Unallowed scheme: " + uri);
+          }
+        }
+
+        String host = uri.getHost();
+        String path = uri.getRawPath();
+
+        if (host == null)
+        {
+          if (scheme != null)
+            throw new IllegalArgumentException("Host is missing, although scheme is not empty: " + scheme);
+        }
+        else
+        {
+          host = host.toLowerCase();
+          path = path == null || path.isEmpty() ? "/" : path;
+        }
+
+        try
+        {
+          return new URI(
+              scheme,
+              uri.getUserInfo(),
+              host,
+              uri.getPort(),
+              path,
+              uri.getQuery(),
+              uri.getFragment()
+              );
+        }
+        catch (URISyntaxException e)
+        {
+          throw new IllegalArgumentException("Invalid HTTP-URL: ", e);
+        }
+      }
+
+      public static URI resolve(URI relative, URI uri) throws IOException
+      {
+        if (relative.getAuthority() != null)
+          throw new IOException("URI is not relative: " + relative);
+
+        URI cleaned;
+        try
+        {
+          String path = relative.getRawPath();
+          int length = path == null ? -1 : path.length();
+          int i = 0;
+
+          while (i < length)
+          {
+            switch (path.charAt(i))
+            {
+              case '.':
+              case '/':
+                i++;
+                break;
+              default:
+                length = -1;
+            }
+          }
+
+          cleaned = i > 0
+                  ? new URI(
+                  null,
+                  null,
+                  null,
+                  0,
+                  i == path.length() ? null : path.substring(i),
+                  relative.getQuery(),
+                  relative.getFragment()
+          )
+                  : relative;
+
+          path = uri.getPath();
+          if (path == null || path.length() == 0)
+            uri = uri.resolve(ABSOLUTE_PATH);
+        }
+        catch (URISyntaxException e)
+        {
+          throw new IOException("Invalid relative path: " + relative, e);
+        }
+
+        URI resolved = uri.resolve(cleaned);
+        LOG.trace("resolved {} as {} in context {}", relative, resolved, uri);
+        return resolved;
+      }
+
+
+      public static boolean isHttpResource(String resourcePath)
+      {
+        return RESOURCE_PATH_PATTERN.matcher(resourcePath).find();
+      }
+    }
+