Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you 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 org.apache.shindig.common.uri; import org.apache.commons.lang.StringUtils; import com.google.common.base.Objects; import com.google.common.collect.Maps; import com.google.inject.Inject; import java.net.URI; import java.net.URISyntaxException; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; /** * Represents a Uniform Resource Identifier (URI) reference as defined by <a * href="http://tools.ietf.org/html/rfc3986">RFC 3986</a>. * * Assumes that all url components are UTF-8 encoded. */ public final class Uri { private final String text; private final String scheme; private final String authority; private final String path; private final String query; private final String fragment; private final Map<String, List<String>> queryParameters; private final Map<String, List<String>> fragmentParameters; private static UriParser parser = new DefaultUriParser(); @Inject(optional = true) public static void setUriParser(UriParser uriParser) { parser = uriParser; } Uri(UriBuilder builder) { scheme = builder.getScheme(); authority = builder.getAuthority(); path = builder.getPath(); query = builder.getQuery(); fragment = builder.getFragment(); queryParameters = Collections.unmodifiableMap(Maps.newLinkedHashMap(builder.getQueryParameters())); fragmentParameters = Collections.unmodifiableMap(Maps.newLinkedHashMap(builder.getFragmentParameters())); StringBuilder out = new StringBuilder(); if (scheme != null) { out.append(scheme).append(':'); } if (authority != null) { out.append("//").append(authority); // insure that there's a separator between authority/path if (path != null && path.length() > 1 && !path.startsWith("/")) { out.append('/'); } } if (path != null) { out.append(path); } if (query != null) { out.append('?').append(query); } if (fragment != null) { out.append('#').append(fragment); } text = out.toString(); } /** * Produces a new Uri from a text representation. * * @param text The text uri. * @return A new Uri, parsed into components. */ public static Uri parse(String text) { try { return parser.parse(text); } catch (IllegalArgumentException e) { // This occurs all the time. Wrap the exception in a Uri-specific // exception, yet one that remains a RuntimeException, so that // callers may catch a specific exception rather than a blanket // Exception, as a compromise between throwing a checked exception // here (forcing wide-scale refactoring across the code base) and // forcing users to simply catch abstract Exceptions here and there. throw new UriException(e); } } /** * Convert a java.net.URI to a Uri. */ public static Uri fromJavaUri(URI uri) { if (uri.isOpaque()) { throw new UriException("No support for opaque Uris " + uri.toString()); } return new UriBuilder().setScheme(uri.getScheme()).setAuthority(uri.getRawAuthority()) .setPath(uri.getRawPath()).setQuery(uri.getRawQuery()).setFragment(uri.getRawFragment()).toUri(); } /** * @return a java.net.URI equal to this Uri. */ public URI toJavaUri() { try { return new URI(toString()); } catch (URISyntaxException e) { // Shouldn't ever happen. throw new UriException(e); } } /** * Derived from Harmony * Resolves a given url relative to this url. Resolution rules are the same as for * {@code java.net.URI.resolve(URI)} */ public Uri resolve(Uri relative) { if (relative == null) { return null; } if (relative.isAbsolute()) { return relative; } UriBuilder result; if (StringUtils.isEmpty(relative.path) && relative.scheme == null && relative.authority == null && relative.query == null && relative.fragment != null) { // if the relative URI only consists of fragment, // the resolved URI is very similar to this URI, // except that it has the fragement from the relative URI. result = new UriBuilder(this); result.setFragment(relative.fragment); } else if (relative.scheme != null) { result = new UriBuilder(relative); } else if (relative.authority != null) { // if the relative URI has authority, // the resolved URI is almost the same as the relative URI, // except that it has the scheme of this URI. result = new UriBuilder(relative); result.setScheme(scheme); } else { // since relative URI has no authority, // the resolved URI is very similar to this URI, // except that it has the query and fragment of the relative URI, // and the path is different. result = new UriBuilder(this); result.setFragment(relative.fragment); result.setQuery(relative.query); String relativePath = Objects.firstNonNull(relative.path, ""); if (relativePath.startsWith("/")) { //$NON-NLS-1$ result.setPath(relativePath); } else { // resolve a relative reference String basePath = path != null ? path : "/"; int endindex = basePath.lastIndexOf('/') + 1; result.setPath(normalizePath(basePath.substring(0, endindex) + relativePath)); } } Uri resolved = result.toUri(); validate(resolved); return resolved; } private static void validate(Uri uri) { if (StringUtils.isEmpty(uri.authority) && StringUtils.isEmpty(uri.path) && StringUtils.isEmpty(uri.query)) { throw new UriException("Invalid scheme-specific part"); } } /** * Dervived from harmony * normalize path, and return the resulting string */ private static String normalizePath(String path) { // count the number of '/'s, to determine number of segments int index = -1; int pathlen = path.length(); int size = 0; if (pathlen > 0 && path.charAt(0) != '/') { size++; } while ((index = path.indexOf('/', index + 1)) != -1) { if (index + 1 < pathlen && path.charAt(index + 1) != '/') { size++; } } String[] seglist = new String[size]; boolean[] include = new boolean[size]; // break the path into segments and store in the list int current = 0; int index2 = 0; index = (pathlen > 0 && path.charAt(0) == '/') ? 1 : 0; while ((index2 = path.indexOf('/', index + 1)) != -1) { seglist[current++] = path.substring(index, index2); index = index2 + 1; } // if current==size, then the last character was a slash // and there are no more segments if (current < size) { seglist[current] = path.substring(index); } // determine which segments get included in the normalized path for (int i = 0; i < size; i++) { include[i] = true; if (seglist[i].equals("..")) { //$NON-NLS-1$ int remove = i - 1; // search back to find a segment to remove, if possible while (remove > -1 && !include[remove]) { remove--; } // if we find a segment to remove, remove it and the ".." // segment if (remove > -1 && !seglist[remove].equals("..")) { //$NON-NLS-1$ include[remove] = false; include[i] = false; } } else if (seglist[i].equals(".")) { //$NON-NLS-1$ include[i] = false; } } // put the path back together StringBuilder newpath = new StringBuilder(); if (path.startsWith("/")) { //$NON-NLS-1$ newpath.append('/'); } for (int i = 0; i < seglist.length; i++) { if (include[i]) { newpath.append(seglist[i]); newpath.append('/'); } } // if we used at least one segment and the path previously ended with // a slash and the last segment is still used, then delete the extra // trailing '/' if (!path.endsWith("/") && seglist.length > 0 //$NON-NLS-1$ && include[seglist.length - 1]) { newpath.deleteCharAt(newpath.length() - 1); } String result = newpath.toString(); // check for a ':' in the first segment if one exists, // prepend "./" to normalize index = result.indexOf(':'); index2 = result.indexOf('/'); if (index != -1 && (index < index2 || index2 == -1)) { newpath.insert(0, "./"); //$NON-NLS-1$ result = newpath.toString(); } return result; } /** * @return True if the Uri is absolute. */ public boolean isAbsolute() { return scheme != null && authority != null; } /** * @return The scheme part of the uri, or null if none was specified. */ public String getScheme() { return scheme; } /** * @return The authority part of the uri, or null if none was specified. */ public String getAuthority() { return authority; } /** * @return The path part of the uri, or null if none was specified. */ public String getPath() { return path; } /** * @return The query part of the uri, or null if none was specified. */ public String getQuery() { return query; } /** * @return The query part of the uri, separated into component parts. */ public Map<String, List<String>> getQueryParameters() { return queryParameters; } /** * @return All query parameters with the given name. */ public Collection<String> getQueryParameters(String name) { return queryParameters.get(name); } /** * @return The first query parameter value with the given name. */ public String getQueryParameter(String name) { Collection<String> values = queryParameters.get(name); if (values == null || values.isEmpty()) { return null; } return values.iterator().next(); } /** * @return The uri fragment. */ public String getFragment() { return fragment; } /** * @return The fragment part of the uri, separated into component parts. */ public Map<String, List<String>> getFragmentParameters() { return fragmentParameters; } /** * @return All query parameters with the given name. */ public Collection<String> getFragmentParameters(String name) { return fragmentParameters.get(name); } /** * @return The first query parameter value with the given name. */ public String getFragmentParameter(String name) { Collection<String> values = fragmentParameters.get(name); if (values == null || values.isEmpty()) { return null; } return values.iterator().next(); } @Override public String toString() { return text; } @Override public int hashCode() { return text.hashCode(); } @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Uri)) { return false; } return Objects.equal(text, ((Uri) obj).text); } /** * Interim typed, but not checked, exception facilitating migration * of Uri methods to throwing a checked UriException later. */ public static final class UriException extends IllegalArgumentException { private UriException(Exception e) { super(e); } private UriException(String msg) { super(msg); } } }