url.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 814 行 · 第 1/2 页

	 * If the protocol parsed out of the URL is different 
	 * from the context URL's protocol, then then URL String is also
	 * expected to be a complete URL.
	 * <p>
	 * Additionally, this method allows the caller to specify a protocol handler
	 * to use instead of  the default.  If this handler is specified, the caller
	 * must have the "specifyStreamHandler" permission
	 * (see <code>NetPermission</code>) or a <code>SecurityException</code>
	 * will be thrown.
	 *
	 * @param context The context in which to parse the specification
	 * @param spec The string to parse as an URL
	 * @param handler The stream handler for the URL
	 *
	 * @exception MalformedURLException If a protocol handler cannot be found
	 * or the URL cannot be parsed
	 * @exception SecurityException If the <code>SecurityManager</code> exists
	 * and does not allow the caller to specify its own protocol handler.
	 *
	 * @since 1.2
	 */
	public URL(URL context, String spec, URLStreamHandler handler)
		throws MalformedURLException {
		/* A protocol is defined by the doc as the substring before a ':'
		 * as long as the ':' occurs before any '/'.
		 *
		 * If context is null, then spec must be an absolute URL.
		 *
		 * The relative URL need not specify all the components of a URL.
		 * If the protocol, host name, or port number is missing, the value
		 * is inherited from the context.  A bare file component is appended
		 * to the context's file.  The optional anchor is not inherited. 
		 */

		// If this is an absolute URL, then ignore context completely.
		// An absolute URL must have chars prior to "://" but cannot have a colon
		// right after the "://".  The second colon is for an optional port value
		// and implies that the host from the context is used if available.
		int colon;
		if ((colon = spec.indexOf("://", 1)) > 0
			&& !spec.regionMatches(colon, "://:", 0, 4))
			context = null;

		int slash;
		if ((colon = spec.indexOf(':')) > 0
			&& (colon < (slash = spec.indexOf('/')) || slash < 0)) {
			// Protocol specified in spec string.
			protocol = spec.substring(0, colon).toLowerCase();
			if (context != null && context.protocol.equals(protocol)) {
				// The 1.2 doc specifically says these are copied to the new URL.
				host = context.host;
				port = context.port;
				file = context.file;
				authority = context.authority;
			}
		} else if (context != null) {
			// Protocol NOT specified in spec string.
			// Use context fields (except ref) as a foundation for relative URLs.
			colon = -1;
			protocol = context.protocol;
			host = context.host;
			port = context.port;
			file = context.file;
			authority = context.authority;
		} else // Protocol NOT specified in spec. and no context available.
			throw new MalformedURLException("Absolute URL required with null context");

		if (handler != null) {
			SecurityManager s = System.getSecurityManager();
			if (s != null)
				s.checkPermission(new NetPermission("specifyStreamHandler"));

			this.handler = handler;
		} else
			this.handler = getURLStreamHandler(protocol);

		if (this.handler == null)
			throw new MalformedURLException(
				"Protocol handler not found: " + protocol);

		// JDK 1.2 doc for parseURL specifically states that any '#' ref
		// is to be excluded by passing the 'limit' as the indexOf the '#'
		// if one exists, otherwise pass the end of the string.
		int hashAt = spec.indexOf('#', colon + 1);
		this.handler.parseURL(
			this,
			spec,
			colon + 1,
			hashAt < 0 ? spec.length() : hashAt);
		if (hashAt >= 0)
			ref = spec.substring(hashAt + 1);

		hashCode = hashCode(); // Used for serialization.
	}

	/**
	 * 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 == null || !(obj instanceof URL))
			return false;

		URL uObj = (URL)obj;

		return handler.equals(this, uObj);
	}

	/**
	 * Returns the contents of this URL as an object by first opening a
	 * connection, then calling the getContent() method against the connection
	 *
	 * @return A content object for this URL
	 * @exception IOException If opening the connection or getting the
	 * content fails.
	 *
	 * @since 1.3
	 */
	public final Object getContent() throws IOException {
		return openConnection().getContent();
	}

	/**
	 * Gets the contents of this URL
	 *
	 * @exception IOException If an error occurs
	 */
	public final Object getContent(Class[] classes) throws IOException {
		// FIXME: implement this
		return getContent();
	}

	/**
	 * Returns the file portion of the URL.
	 * Defined as <code>path[?query]</code>.
	 * Returns the empty string if there is no file portion.
	 */
	public String getFile() {
		return file == null ? "" : file;
	}

	/**
	 * Returns the path of the URL. This is the part of the file before any '?'
	 * character.
	 *
	 * @since 1.3
	 */
	public String getPath() {
		int quest = (file == null) ? -1 : file.indexOf('?');
		return quest < 0 ? getFile() : file.substring(0, quest);
	}

	/**
	 * Returns the authority of the URL
	 * 
	 * @since 1.3
	 */
	public String getAuthority() {
		return authority;
	}

	/**
	 * Returns the host of the URL
	 */
	public String getHost() {
		int at = (host == null) ? -1 : host.indexOf('@');
		return at < 0 ? host : host.substring(at + 1, host.length());
	}

	/**
	 * Returns the port number of this URL or -1 if the default port number is
	 * being used.
	 *
	 * @return The port number
	 *
	 * @see #getDefaultPort()
	 */
	public int getPort() {
		return port;
	}

	/**
	 * Returns the default port of the URL. If the StreamHandler for the URL
	 * protocol does not define a default port it returns -1.
	 */
	public int getDefaultPort() {
		return handler.getDefaultPort();
	}

	/**
	 * Returns the protocol of the URL
	 */
	public String getProtocol() {
		return protocol;
	}

	/**
	 * Returns the ref (sometimes called the "# reference" or "anchor") portion
	 * of the URL.
	 *
	 * @return The ref
	 */
	public String getRef() {
		return ref;
	}

	/**
	 * Returns the user information of the URL. This is the part of the host
	 * name before the '@'.
	 *
	 * @return the user at a particular host or null when no user defined.
	 */
	public String getUserInfo() {
		int at = (host == null) ? -1 : host.indexOf('@');
		return at < 0 ? null : host.substring(0, at);
	}

	/**
	 * Returns the query of the URL. This is the part of the file before the
	 * '?'.
	 *
	 * @ return the query part of the file, or null when there is no query part.
	 */
	public String getQuery() {
		int quest = (file == null) ? -1 : file.indexOf('?');
		return quest < 0 ? null : file.substring(quest + 1, file.length());
	}

	/**
	 * Returns a hashcode computed by the URLStreamHandler of this URL
	 */
	public int hashCode() {
		if (hashCode != 0)
			return hashCode; // Use cached value if available.
		else
			return handler.hashCode(this);
	}

	/**
	 * 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 handler.openConnection(this);
	}

	/**
	 * Opens a connection to this URL and returns an InputStream for reading
	 * from that connection
	 *
	 * @exception IOException If an error occurs
	 */
	public final InputStream openStream() throws IOException {
		return openConnection().getInputStream();
	}

	/**
	 * 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 other The URL object to test with
	 *
	 * @return true if URL matches this URL's file, false otherwise
	 */
	public boolean sameFile(URL other) {
		return handler.sameFile(this, other);
	}

	/**
	 * Sets the specified fields of the URL. This is not a public method so
	 * that only URLStreamHandlers can modify URL fields. This might be called
	 * by the <code>parseURL()</code> method in that class. URLs are otherwise
	 * constant.
	 *
	 * @param protocol The protocol name for this URL
	 * @param host The hostname or IP address for this URL
	 * @param port The port number of this URL
	 * @param file The "file" portion of this URL.
	 * @param ref The anchor portion of this URL.
	 */
	protected void set(
		String protocol,
		String host,
		int port,
		String file,
		String ref) {
		// TBD: Theoretically, a poorly written StreamHandler could pass an
		// invalid protocol.  It will cause the handler to be set to null
		// thus overriding a valid handler.  Callers of this method should
		// be aware of this.
		this.handler = getURLStreamHandler(protocol);
		this.protocol = protocol.toLowerCase();
		this.authority = null;
		this.port = port;
		this.host = host;
		this.file = file;
		this.ref = ref;
		hashCode = hashCode(); // Used for serialization.
	}

	/**
	 * Sets the specified fields of the URL. This is not a public method so
	 * that only URLStreamHandlers can modify URL fields. URLs are otherwise
	 * constant.
	 *
	 * @since 1.3
	 */
	protected void set(
		String protocol,
		String host,
		int port,
		String authority,
		String userInfo,
		String path,
		String query,
		String ref) {
		// TBD: Theoretically, a poorly written StreamHandler could pass an
		// invalid protocol.  It will cause the handler to be set to null
		// thus overriding a valid handler.  Callers of this method should
		// be aware of this.
		this.handler = getURLStreamHandler(protocol);
		this.protocol = protocol.toLowerCase();
		if (userInfo == null)
			this.host = host;
		else
			this.host = userInfo + "@" + host;
		this.port = port;
		if (query == null)
			this.file = path;
		else
			this.file = path + "?" + query;
		this.ref = ref;
		hashCode = hashCode(); // Used for serialization.
	}

	/**
	 * Sets the URLStreamHandlerFactory for this class.  This factory is
	 * responsible for returning the appropriate protocol handler for
	 * a given URL.
	 *
	 * @param fac The URLStreamHandlerFactory class to use
	 *
	 * @exception Error If the factory is alread set.
	 * @exception SecurityException If a security manager exists and its
	 * checkSetFactory method doesn't allow the operation
	 */
	public static synchronized void setURLStreamHandlerFactory(URLStreamHandlerFactory fac) {
		if (factory != null)
			throw new Error("URLStreamHandlerFactory already set");

		// Throw an exception if an extant security mgr precludes
		// setting the factory.
		SecurityManager s = System.getSecurityManager();
		if (s != null)
			s.checkSetFactory();
		factory = fac;
	}

	/**
	 * Returns a String representing this URL.  The String returned is
	 * created by calling the protocol handler's toExternalForm() method.
	 *
	 * @return A string for this URL
	 */
	public String toExternalForm() {
		// Identical to toString().
		return handler.toExternalForm(this);
	}

	/**
	 * 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 handler.toExternalForm(this);
	}

	private void readObject(ObjectInputStream ois)
		throws IOException, ClassNotFoundException {
		ois.defaultReadObject();
		this.handler = getURLStreamHandler(protocol);
		if (this.handler == null)
			throw new IOException(
				"Handler for protocol " + protocol + " not found");
	}

	private void writeObject(ObjectOutputStream oos) throws IOException {
		oos.defaultWriteObject();
	}
}