/**
* Same as {@link #openConnection()}, except that the connection will be made through the
* specified proxy; Protocol handlers that do not support proxing will ignore the proxy parameter
* and make a normal connection.
*
* <p>Invoking this method preempts the system's default ProxySelector settings.
*
* @param proxy the Proxy through which this connection will be made. If direct connection is
* desired, Proxy.NO_PROXY should be specified.
* @return a <code>URLConnection</code> to the URL.
* @exception IOException if an I/O exception occurs.
* @exception SecurityException if a security manager is present and the caller doesn't have
* permission to connect to the proxy.
* @exception IllegalArgumentException will be thrown if proxy is null, or proxy has the wrong
* type
* @exception UnsupportedOperationException if the subclass that implements the protocol handler
* doesn't support this method.
* @see java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)
* @see java.net.URLConnection
* @see java.net.URLStreamHandler#openConnection(java.net.URL, java.net.Proxy)
* @since 1.5
*/
public URLConnection openConnection(Proxy proxy) throws java.io.IOException {
if (proxy == null) {
throw new IllegalArgumentException("proxy can not be null");
}
SecurityManager sm = System.getSecurityManager();
if (proxy.type() != Proxy.Type.DIRECT && sm != null) {
InetSocketAddress epoint = (InetSocketAddress) proxy.address();
if (epoint.isUnresolved()) sm.checkConnect(epoint.getHostName(), epoint.getPort());
else sm.checkConnect(epoint.getAddress().getHostAddress(), epoint.getPort());
}
return handler.openConnection(this, proxy);
}
/**
* Constructs a string representation of this <code>URL</code>. The string is created by calling
* the <code>toExternalForm</code> method of the stream protocol handler for this object.
*
* @return a string representation of this object.
* @see java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)
* @see java.net.URLStreamHandler#toExternalForm(java.net.URL)
*/
public String toExternalForm() {
return handler.toExternalForm(this);
}
/**
* Returns a {@link java.net.URLConnection URLConnection} instance that represents a connection to
* the remote object referred to by the {@code URL}.
*
* <p>A new instance of {@linkplain java.net.URLConnection URLConnection} is created every time
* when invoking the {@linkplain java.net.URLStreamHandler#openConnection(URL)
* URLStreamHandler.openConnection(URL)} method of the protocol handler for this URL.
*
* <p>It should be noted that a URLConnection instance does not establish the actual network
* connection on creation. This will happen only when calling {@linkplain
* java.net.URLConnection#connect() URLConnection.connect()}.
*
* <p>If for the URL's protocol (such as HTTP or JAR), there exists a public, specialized
* URLConnection subclass belonging to one of the following packages or one of their subpackages:
* java.lang, java.io, java.util, java.net, the connection returned will be of that subclass. For
* example, for HTTP an HttpURLConnection will be returned, and for JAR a JarURLConnection will be
* returned.
*
* @return a {@link java.net.URLConnection URLConnection} linking to the URL.
* @exception IOException if an I/O exception occurs.
* @see java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)
*/
public URLConnection openConnection() throws java.io.IOException {
return handler.openConnection(this);
}
/**
* Creates an integer suitable for hash table indexing.
*
* <p>The hash code is based upon all the URL components relevant for URL comparison. As such,
* this operation is a blocking operation.
*
* <p>
*
* @return a hash code for this <code>URL</code>.
*/
public synchronized int hashCode() {
if (hashCode != -1) return hashCode;
hashCode = handler.hashCode(this);
return hashCode;
}
/**
* Compares two URLs, excluding the fragment component.
*
* <p>Returns <code>true</code> if this <code>URL</code> and the <code>other</code> argument are
* equal without taking the fragment component into consideration.
*
* @param other the <code>URL</code> to compare against.
* @return <code>true</code> if they reference the same remote object; <code>false</code>
* otherwise.
*/
public boolean sameFile(URL other) {
return handler.sameFile(this, other);
}
/**
* Gets the default port number of the protocol associated with this <code>URL</code>. If the URL
* scheme or the URLStreamHandler for the URL do not define a default port number, then -1 is
* returned.
*
* @return the port number
* @since 1.4
*/
public int getDefaultPort() {
return handler.getDefaultPort();
}
/**
* Compares this URL for equality with another object.
*
* <p>If the given object is not a URL then this method immediately returns <code>false</code>.
*
* <p>Two URL objects are equal if they have the same protocol, reference equivalent hosts, have
* the same port number on the host, and the same file and fragment of the file.
*
* <p>Two hosts are considered equivalent if both host names can be resolved into the same IP
* addresses; else if either host name can't be resolved, the host names must be equal without
* regard to case; or both host names equal to null.
*
* <p>Since hosts comparison requires name resolution, this operation is a blocking operation.
*
* <p>Note: The defined behavior for <code>equals</code> is known to be inconsistent with virtual
* hosting in HTTP.
*
* @param obj the URL to compare against.
* @return <code>true</code> if the objects are the same; <code>false</code> otherwise.
*/
public boolean equals(Object obj) {
if (!(obj instanceof URL)) return false;
URL u2 = (URL) obj;
return handler.equals(this, u2);
}
/**
* Returns a String representing this URL. Identical to toExternalForm(). The value returned is
* created by the protocol handler's toExternalForm method. Overrides Object.toString()
*
* @return A string for this URL
*/
public String toString() {
// Identical to toExternalForm().
return ph.toExternalForm(this);
}
/**
* Creates a URL by parsing the given spec with the specified handler within a specified context.
* If the handler is null, the parsing occurs as with the two argument constructor.
*
* @param context the context in which to parse the specification.
* @param spec the <code>String</code> to parse as a URL.
* @param handler the stream handler for the URL.
* @exception MalformedURLException if no protocol is specified, or an unknown protocol is found,
* or <tt>spec</tt> is <tt>null</tt>.
* @exception SecurityException if a security manager exists and its <code>checkPermission</code>
* method doesn't allow specifying a stream handler.
* @see java.net.URL#URL(java.lang.String, java.lang.String, int, java.lang.String)
* @see java.net.URLStreamHandler
* @see java.net.URLStreamHandler#parseURL(java.net.URL, java.lang.String, int, int)
*/
public URL(URL context, String spec, URLStreamHandler handler) throws MalformedURLException {
String original = spec;
int i, limit, c;
int start = 0;
String newProtocol = null;
boolean aRef = false;
boolean isRelative = false;
// Check for permission to specify a handler
if (handler != null) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkSpecifyHandler(sm);
}
}
try {
limit = spec.length();
while ((limit > 0) && (spec.charAt(limit - 1) <= ' ')) {
limit--; // eliminate trailing whitespace
}
while ((start < limit) && (spec.charAt(start) <= ' ')) {
start++; // eliminate leading whitespace
}
if (spec.regionMatches(true, start, "url:", 0, 4)) {
start += 4;
}
if (start < spec.length() && spec.charAt(start) == '#') {
/* we're assuming this is a ref relative to the context URL.
* This means protocols cannot start w/ '#', but we must parse
* ref URL's like: "hello:there" w/ a ':' in them.
*/
aRef = true;
}
for (i = start; !aRef && (i < limit) && ((c = spec.charAt(i)) != '/'); i++) {
if (c == ':') {
String s = spec.substring(start, i).toLowerCase();
if (isValidProtocol(s)) {
newProtocol = s;
start = i + 1;
}
break;
}
}
// Only use our context if the protocols match.
protocol = newProtocol;
if ((context != null)
&& ((newProtocol == null) || newProtocol.equalsIgnoreCase(context.protocol))) {
// inherit the protocol handler from the context
// if not specified to the constructor
if (handler == null) {
handler = context.handler;
}
// If the context is a hierarchical URL scheme and the spec
// contains a matching scheme then maintain backwards
// compatibility and treat it as if the spec didn't contain
// the scheme; see 5.2.3 of RFC2396
if (context.path != null && context.path.startsWith("/")) newProtocol = null;
if (newProtocol == null) {
protocol = context.protocol;
authority = context.authority;
userInfo = context.userInfo;
host = context.host;
port = context.port;
file = context.file;
path = context.path;
isRelative = true;
}
}
if (protocol == null) {
throw new MalformedURLException("no protocol: " + original);
}
// Get the protocol handler if not specified or the protocol
// of the context could not be used
if (handler == null && (handler = getURLStreamHandler(protocol)) == null) {
throw new MalformedURLException("unknown protocol: " + protocol);
}
this.handler = handler;
i = spec.indexOf('#', start);
if (i >= 0) {
ref = spec.substring(i + 1, limit);
limit = i;
}
/*
* Handle special case inheritance of query and fragment
* implied by RFC2396 section 5.2.2.
*/
if (isRelative && start == limit) {
query = context.query;
if (ref == null) {
ref = context.ref;
}
}
handler.parseURL(this, spec, start, limit);
} catch (MalformedURLException e) {
throw e;
} catch (Exception e) {
MalformedURLException exception = new MalformedURLException(e.getMessage());
exception.initCause(e);
throw exception;
}
}
/**
* Tests whether or not another URL refers to the same "file" as this one. This will be true if
* and only if the passed object is not null, is a URL, and matches all fields but the ref (ie,
* protocol, host, port, and file);
*
* @param url The URL object to test with
* @return true if URL matches this URL's file, false otherwise
*/
public boolean sameFile(URL url) {
return ph.sameFile(this, url);
}
/**
* Returns a URLConnection object that represents a connection to the remote object referred to by
* the URL. The URLConnection is created by calling the openConnection() method of the protocol
* handler
*
* @return A URLConnection for this URL
* @exception IOException If an error occurs
*/
public URLConnection openConnection() throws IOException {
return ph.openConnection(this);
}
/**
* Returns a hashcode computed by the URLStreamHandler of this URL
*
* @return The hashcode for this URL.
*/
public int hashCode() {
if (hashCode != 0) return hashCode; // Use cached value if available.
else return ph.hashCode(this);
}
/**
* Returns the default port of the URL. If the StreamHandler for the URL protocol does not define
* a default port it returns -1.
*
* @return The default port of the current protocol.
*/
public int getDefaultPort() {
return ph.getDefaultPort();
}
/**
* Test another URL for equality with this one. This will be true only if the argument is non-null
* and all of the fields in the URL's match exactly (ie, protocol, host, port, file, and ref).
* Overrides Object.equals(), implemented by calling the equals method of the handler.
*
* @param obj The URL to compare with
* @return true if the URL is equal, false otherwise
*/
public boolean equals(Object obj) {
if (!(obj instanceof URL)) return false;
return ph.equals(this, (URL) obj);
}
