Java tutorial
/* * Copyright (c) 2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package ca.simplegames.micro.utils; import org.apache.commons.lang3.StringUtils; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.net.MalformedURLException; import java.net.URI; import java.net.URL; import java.net.URLConnection; import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; import java.util.List; /** * {@link Resource} implementation for <code>java.net.URL</code> locators. * Obviously supports resolution as URL, and also as File in case of * the "file:" protocol. * * @author Juergen Hoeller * @see java.net.URL * @since 28.12.2003 */ public class UrlResource extends AbstractResource { private static final String FOLDER_SEPARATOR = "/"; private static final String WINDOWS_FOLDER_SEPARATOR = "\\"; private static final String TOP_PATH = ".."; private static final String CURRENT_PATH = "."; private static final char EXTENSION_SEPARATOR = '.'; /** * Original URL, used for actual access. */ private final URL url; /** * Cleaned URL (with normalized path), used for comparisons. */ private final URL cleanedUrl; /** * Original URI, if available; used for URI and File access. */ private final URI uri; /** * Create a new UrlResource. * * @param url a URL */ public UrlResource(URL url) { Assert.notNull(url, "URL must not be null"); this.url = url; this.cleanedUrl = getCleanedUrl(this.url, url.toString()); this.uri = null; } /** * Create a new UrlResource. * * @param uri a URI * @throws MalformedURLException if the given URL path is not valid */ public UrlResource(URI uri) throws MalformedURLException { Assert.notNull(uri, "URI must not be null"); this.url = uri.toURL(); this.cleanedUrl = getCleanedUrl(this.url, uri.toString()); this.uri = uri; } /** * Create a new UrlResource. * * @param path a URL path * @throws MalformedURLException if the given URL path is not valid */ public UrlResource(String path) throws MalformedURLException { Assert.notNull(path, "Path must not be null"); this.url = new URL(path); this.cleanedUrl = getCleanedUrl(this.url, path); this.uri = null; } /** * Determine a cleaned URL for the given original URL. * * @param originalUrl the original URL * @param originalPath the original URL path * @return the cleaned URL */ private URL getCleanedUrl(URL originalUrl, String originalPath) { try { return new URL(cleanPath(originalPath)); } catch (MalformedURLException ex) { // Cleaned URL path cannot be converted to URL // -> take original URL. return originalUrl; } } /** * This implementation opens an InputStream for the given URL. * It sets the "UseCaches" flag to <code>false</code>, * mainly to avoid jar file locking on Windows. * * @see java.net.URL#openConnection() * @see java.net.URLConnection#setUseCaches(boolean) * @see java.net.URLConnection#getInputStream() */ public InputStream getInputStream() throws IOException { URLConnection con = this.url.openConnection(); con.setUseCaches(false); return con.getInputStream(); } /** * This implementation returns the underlying URL reference. */ public URL getURL() throws IOException { return this.url; } /** * This implementation returns the underlying URI directly, * if possible. */ public URI getURI() throws IOException { if (this.uri != null) { return this.uri; } else { return super.getURI(); } } /** * This implementation returns a File reference for the underlying URL/URI, * provided that it refers to a file in the file system. */ public File getFile() throws IOException { if (this.uri != null) { return ResourceUtils.getFile(this.uri, getDescription()); } else { return ResourceUtils.getFile(this.url, getDescription()); } } /** * This implementation creates a UrlResource, applying the given path * relative to the path of the underlying URL of this resource descriptor. * * @see java.net.URL#URL(java.net.URL, String) */ public Resource createRelative(String relativePath) throws MalformedURLException { if (relativePath.startsWith("/")) { relativePath = relativePath.substring(1); } return new UrlResource(new URL(this.url, relativePath)); } /** * This implementation returns the name of the file that this URL refers to. * * @see java.net.URL#getFile() * @see java.io.File#getName() */ public String getFilename() { return new File(this.url.getFile()).getName(); } /** * This implementation returns a description that includes the URL. */ public String getDescription() { return "URL [" + this.url + "]"; } /** * This implementation compares the underlying URL references. */ public boolean equals(Object obj) { return (obj == this || (obj instanceof UrlResource && this.cleanedUrl.equals(((UrlResource) obj).cleanedUrl))); } /** * This implementation returns the hash code of the underlying URL reference. */ public int hashCode() { return this.cleanedUrl.hashCode(); } /** * Normalize the path by suppressing sequences like "path/.." and * inner simple dots. * <p>The result is convenient for path comparison. For other uses, * notice that Windows separators ("\") are replaced by simple slashes. * * @param path the original path * @return the normalized path */ public static String cleanPath(String path) { String pathToUse = StringUtils.replace(path, WINDOWS_FOLDER_SEPARATOR, FOLDER_SEPARATOR); // Strip prefix from path to analyze, to not treat it as part of the // first path element. This is necessary to correctly parse paths like // "file:core/../core/io/Resource.class", where the ".." should just // strip the first "core" directory while keeping the "file:" prefix. int prefixIndex = pathToUse.indexOf(":"); String prefix = ""; if (prefixIndex != -1) { prefix = pathToUse.substring(0, prefixIndex + 1); pathToUse = pathToUse.substring(prefixIndex + 1); } String[] pathArray = StringUtils.split(pathToUse, FOLDER_SEPARATOR); List pathElements = new LinkedList(); int tops = 0; for (int i = pathArray.length - 1; i >= 0; i--) { if (CURRENT_PATH.equals(pathArray[i])) { // Points to current directory - drop it. } else if (TOP_PATH.equals(pathArray[i])) { // Registering top path found. tops++; } else { if (tops > 0) { // Merging path element with corresponding to top path. tops--; } else { // Normal path element found. pathElements.add(0, pathArray[i]); } } } // Remaining top paths need to be retained. for (int i = 0; i < tops; i++) { pathElements.add(0, TOP_PATH); } return prefix + collectionToDelimitedString(pathElements, FOLDER_SEPARATOR); } /** * Convenience method to return a Collection as a delimited (e.g. CSV) * String. E.g. useful for <code>toString()</code> implementations. * * @param coll the Collection to display * @param delim the delimiter to use (probably a ",") * @param prefix the String to start each element with * @param suffix the String to end each element with * @return the delimited String */ public static String collectionToDelimitedString(Collection coll, String delim, String prefix, String suffix) { if (coll == null || coll.isEmpty()) { return ""; } StringBuffer sb = new StringBuffer(); Iterator it = coll.iterator(); while (it.hasNext()) { sb.append(prefix).append(it.next()).append(suffix); if (it.hasNext()) { sb.append(delim); } } return sb.toString(); } /** * Convenience method to return a Collection as a delimited (e.g. CSV) * String. E.g. useful for <code>toString()</code> implementations. * * @param coll the Collection to display * @param delim the delimiter to use (probably a ",") * @return the delimited String */ public static String collectionToDelimitedString(Collection coll, String delim) { return collectionToDelimitedString(coll, delim, "", ""); } /** * Convenience method to return a Collection as a CSV String. * E.g. useful for <code>toString()</code> implementations. * * @param coll the Collection to display * @return the delimited String */ public static String collectionToCommaDelimitedString(Collection coll) { return collectionToDelimitedString(coll, ","); } /** * Convenience method to return a String array as a delimited (e.g. CSV) * String. E.g. useful for <code>toString()</code> implementations. * * @param arr the array to display * @param delim the delimiter to use (probably a ",") * @return the delimited String */ public static String arrayToDelimitedString(Object[] arr, String delim) { if (arr == null || arr.length == 0) { return ""; } StringBuilder sb = new StringBuilder(); for (int i = 0; i < arr.length; i++) { if (i > 0) { sb.append(delim); } sb.append(arr[i]); } return sb.toString(); } }