The java.net.URL class cannot be used to parse URIs since it * requires the installation of URL stream handlers that may not be * available. * *
The {@linkplain ParseMode#STRICT strict} parsing mode uses * the java.net.URI class to syntactically validate URI strings. * The {@linkplain ParseMode#COMPAT compat} mode validate the * URI authority and rejects URI fragments, but doesn't perform any * additional validation on path and query, other than that * which may be implemented in the concrete the Uri subclasses. * The {@linkplain ParseMode#LEGACY legacy} mode should not be * used unless the application is capable of validating all URI * strings before any constructors of this class is invoked. * *
The format of an absolute URI (see the RFCs mentioned above) is: *
* absoluteURI = scheme ":" ( hier_part | opaque_part )
*
* scheme = alpha *( alpha | digit | "+" | "-" | "." )
*
* hier_part = ( net_path | abs_path ) [ "?" query ]
* opaque_part = uric_no_slash *uric
*
* net_path = "//" authority [ abs_path ]
* abs_path = "/" path_segments
*
* authority = server | reg_name
* reg_name = 1*( unreserved | escaped | "$" | "," |
* ";" | ":" | "@" | "&" | "=" | "+" )
* server = [ [ userinfo "@" ] hostport ]
* userinfo = *( unreserved | escaped |
* ";" | ":" | "&" | "=" | "+" | "$" | "," )
*
* hostport = host [ ":" port ]
* host = hostname | IPv4address | IPv6reference
* port = *digit
*
* IPv6reference = "[" IPv6address "]"
* IPv6address = hexpart [ ":" IPv4address ]
* IPv4address = 1*3digit "." 1*3digit "." 1*3digit "." 1*3digit
* hexpart = hexseq | hexseq "::" [ hexseq ] | "::" [ hexseq ]
* hexseq = hex4 *( ":" hex4)
* hex4 = 1*4hex
*
* path = [ abs_path | opaque_part ]
* path_segments = segment *( "/" segment )
* segment = *pchar *( ";" param )
* param = *pchar
* pchar = unreserved | escaped |
* ":" | "@" | "&" | "=" | "+" | "$" | ","
*
* query = *uric
*
* uric = reserved | unreserved | escaped
* uric_no_slash = unreserved | escaped | ";" | "?" | ":" | "@" |
* "&" | "=" | "+" | "$" | ","
* reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
* "$" | "," | "[" | "]"
* unreserved = alphanum | mark
* mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
* escaped = "%" hex hex
* unwise = "{" | "}" | "|" | "\" | "^" | "`"
* Currently URIs containing userinfo or reg_name
* are not supported.
* The opaque_part of a non-hierarchical URI is treated as if
* if were a path without a leading slash.
*/
public class Uri {
// three parsing modes
public enum ParseMode {
/**
* Strict validation mode.
* Validate the URI syntactically using {@link java.net.URI}.
* Rejects URI fragments unless explicitly supported by the
* subclass.
*/
STRICT,
/**
* Compatibility mode. The URI authority is syntactically validated.
* Rejects URI fragments unless explicitly supported by the
* subclass.
* This is the default.
*/
COMPAT,
/**
* Legacy mode. In this mode, no validation is performed.
*/
LEGACY
}
protected String uri;
protected String scheme;
protected String host = null;
protected int port = -1;
protected boolean hasAuthority;
protected String path;
protected String query = null;
protected String fragment;
/**
* Creates a Uri object given a URI string.
*/
public Uri(String uri) throws MalformedURLException {
init(uri);
}
/**
* Creates an uninitialized Uri object. The init() method must
* be called before any other Uri methods.
*/
protected Uri() {
}
/**
* The parse mode for parsing this URI.
* The default is {@link ParseMode#COMPAT}.
* @return the parse mode for parsing this URI.
*/
protected ParseMode parseMode() {
return ParseMode.COMPAT;
}
/**
* Initializes a Uri object given a URI string.
* This method must be called exactly once, and before any other Uri
* methods.
*/
protected void init(String uri) throws MalformedURLException {
this.uri = uri;
parse(uri, parseMode());
}
/**
* Returns the URI's scheme.
*/
public String getScheme() {
return scheme;
}
/**
* Returns the host from the URI's authority part, or null
* if no host is provided. If the host is an IPv6 literal, the
* delimiting brackets are part of the returned value (see
* {@link java.net.URI#getHost}).
*/
public String getHost() {
return host;
}
/**
* Returns the port from the URI's authority part, or -1 if
* no port is provided.
*/
public int getPort() {
return port;
}
/**
* Returns the URI's path. The path is never null. Note that a
* slash following the authority part (or the scheme if there is
* no authority part) is part of the path. For example, the path
* of "http://host/a/b" is "/a/b".
*/
public String getPath() {
return path;
}
/**
* Returns the URI's query part, or null if no query is provided.
* Note that a query always begins with a leading "?".
*/
public String getQuery() {
return query;
}
/**
* Returns the URI as a string.
*/
public String toString() {
return uri;
}
private void parse(String uri, ParseMode mode) throws MalformedURLException {
switch (mode) {
case STRICT:
parseStrict(uri);
break;
case COMPAT:
parseCompat(uri);
break;
case LEGACY:
parseLegacy(uri);
break;
}
}
/*
* Parses a URI string and sets this object's fields accordingly.
* Use java.net.URI to validate the uri string syntax
*/
private void parseStrict(String uri) throws MalformedURLException {
try {
if (!isSchemeOnly(uri)) {
URI u = new URI(uri);
scheme = u.getScheme();
if (scheme == null) throw new MalformedURLException("Invalid URI: " + uri);
String auth = u.getRawAuthority();
hasAuthority = auth != null;
if (hasAuthority) {
String host = u.getHost();
int port = u.getPort();
if (host != null) this.host = host;
if (port != -1) this.port = port;
String hostport = (host == null ? "" : host)
+ (port == -1 ? "" : (":" + port));
if (!hostport.equals(auth)) {
// throw if we have user info or regname
throw new MalformedURLException("unsupported authority: " + auth);
}
}
path = u.getRawPath();
if (u.getRawQuery() != null) {
query = "?" + u.getRawQuery();
}
if (u.getRawFragment() != null) {
if (!acceptsFragment()) {
throw new MalformedURLException("URI fragments not supported: " + uri);
}
fragment = "#" + u.getRawFragment();
}
} else {
// scheme-only URIs are not supported by java.net.URI
// validate the URI by appending "/" to the uri string.
String s = uri.substring(0, uri.indexOf(':'));
URI u = new URI(uri + "/");
if (!s.equals(u.getScheme())
|| !checkSchemeOnly(uri, u.getScheme())) {
throw newInvalidURISchemeException(uri);
}
scheme = s;
path = "";
}
} catch (URISyntaxException e) {
MalformedURLException mue = new MalformedURLException(e.getMessage());
mue.initCause(e);
throw mue;
}
}
/*
* Parses a URI string and sets this object's fields accordingly.
* Compatibility mode. Use java.net.URI to validate the syntax of
* the uri string authority.
*/
private void parseCompat(String uri) throws MalformedURLException {
int i; // index into URI
i = uri.indexOf(':'); // parse scheme
int slash = uri.indexOf('/');
int qmark = uri.indexOf('?');
int fmark = uri.indexOf('#');
if (i < 0 || slash > 0 && i > slash || qmark > 0 && i > qmark || fmark > 0 && i > fmark) {
throw new MalformedURLException("Invalid URI: " + uri);
}
if (fmark > -1) {
if (!acceptsFragment()) {
throw new MalformedURLException("URI fragments not supported: " + uri);
}
}
if (i == uri.length() - 1) {
if (!isSchemeOnly(uri)) {
throw newInvalidURISchemeException(uri);
}
}
scheme = uri.substring(0, i);
i++; // skip past ":"
hasAuthority = uri.startsWith("//", i);
if (fmark > -1 && qmark > fmark) qmark = -1;
int endp = qmark > -1 ? qmark : fmark > -1 ? fmark : uri.length();
if (hasAuthority) { // parse "//host:port"
i += 2; // skip past "//"
int starta = i;
// authority ends at the first appearance of /, ?, or #
int enda = uri.indexOf('/', i);
if (enda == -1 || qmark > -1 && qmark < enda) enda = qmark;
if (enda == -1 || fmark > -1 && fmark < enda) enda = fmark;
if (enda < 0) {
enda = uri.length();
}
if (uri.startsWith(":", i)) {
// LdapURL supports empty host.
i++;
host = "";
if (enda > i) {
port = Integer.parseInt(uri.substring(i, enda));
}
} else {
// Use URI to parse authority
try {
// URI requires at least one char after authority:
// we use "/" and expect that the resulting URI path
// will be exactly "/".
URI u = new URI(uri.substring(0, enda) + "/");
String auth = uri.substring(starta, enda);
host = u.getHost();
port = u.getPort();
String p = u.getRawPath();
String q = u.getRawQuery();
String f = u.getRawFragment();
String ui = u.getRawUserInfo();
if (ui != null) {
throw new MalformedURLException("user info not supported in authority: " + ui);
}
if (!"/".equals(p)) {
throw new MalformedURLException("invalid authority: " + auth);
}
if (q != null) {
throw new MalformedURLException("invalid trailing characters in authority: ?" + q);
}
if (f != null) {
throw new MalformedURLException("invalid trailing characters in authority: #" + f);
}
String hostport = (host == null ? "" : host)
+ (port == -1?"":(":" + port));
if (!auth.equals(hostport)) {
// throw if we have user info or regname
throw new MalformedURLException("unsupported authority: " + auth);
}
} catch (URISyntaxException e) {
MalformedURLException mue = new MalformedURLException(e.getMessage());
mue.initCause(e);
throw mue;
}
}
i = enda;
}
path = uri.substring(i, endp);
// look for query
if (qmark > -1) {
if (fmark > -1) {
query = uri.substring(qmark, fmark);
} else {
query = uri.substring(qmark);
}
}
if (fmark > -1) {
fragment = uri.substring(fmark);
}
}
/**
* A subclass of {@code Uri} that supports scheme only
* URIs can override this method and return true in the
* case where the URI string is a scheme-only URI that
* the subclass supports.
* @implSpec
* The default implementation of this method returns false,
* always.
* @param uri An URI string
* @return if this is a scheme-only URI supported by the subclass
*/
protected boolean isSchemeOnly(String uri) {
return false;
}
/**
* Checks whether the given uri string should be considered
* as a scheme-only URI. For some protocols - e.g. DNS, we
* might accept "dns://" as a valid URL denoting default DNS.
* For others - we might only accept "scheme:".
* @implSpec
* The default implementation of this method returns true if
* the URI is of the form {@code "