Java中URI,URL和URN的使用

URI、URL和URN是识别、定位和命名网上资源的标准途径。本文分析了URI、URL和URN的概念，以及Java的URI和URL类（以及与URL相关的类），并演示了如何在程序中使用这些类。

Internet被认为是全球的实际和抽象的资源的集合。实际的资源包括从文件（file）到人(person)，抽象的资源包括数据库查询等。因为要通过多样的方式识别资源，所以需要标准的识别Internet资源的途径。为了满足这种需要，引入了URI、URL和URN。

URI、URL和URN的概念
URI

 

URI = Uniform Resource Identifier

 

There are two types of URIs: URLs and URNs.

 

See RFC 1630: Universal Resource Identifiers in WWW: A Unifying Syntax for the Expression of Names and Addresses of Objects on the Network as used in the WWW.

 

URL

 

URL = Uniform Resource Locator

 

See RFC 1738: Uniform Resource Locators (URL)

 

URN

 

URN = Uniform Resource Name.

 

URI、URL和URN是彼此关联的。URI位于顶层，URL和URN的范畴位于底层。URL和URN都是URI的子范畴。

URI翻译为统一资源标识，它是以某种标准化的方式标识资源的字符串。这种字符串以scheme开头，语法如下：

[scheme:] scheme-specific-part

URI以scheme和冒号开头。冒号把scheme与scheme-specific-part分开，并且scheme-specific-part的语法由URI的scheme决定。例如http://www.cnn.com，其中http是scheme，//www.cnn.com是 scheme-specific-part。

 

URI分为绝对（absolute）或相对（relative）两类。绝对URI指以scheme（后面跟着冒号）开头的URI。前面提到的http://www.cnn.com就是绝对的URI的一个例子，其它的例子还有mailto:[e-mail]、news:comp.lang.java.help和xyz://whatever。可以把绝对URI看作是以某种方式引用某种资源，而对环境没有依赖。如果使用文件系统作类比，绝对URI类似于从根目录开始的某个文件的路径。相对URI不以scheme开始，一个例子是articles/articles.html。可以把相对URI看作是以某种方式引用某种资源，而这种方式依赖于标识符出现的环境。如果用文件系统作类比，相对URI类似于从当前目录开始的文件路径。

 

 

 

URI可以进一步分为不透明的（opaque）和分层（hierarchical）的两类。不透明的URI指scheme-specific-part不是以‘/’开头的绝对的URI。其例子有news:comp.lang.java和前面的mailto:[e-mail]。不透明的URI不能做进一步的解析，不需要验证scheme-specific-part的有效性。与它不同的是，分层的URI是以‘/’开头的绝对的URI或相对的URL。分层的URI的scheme-specific-part必须被分解为几个组成部分。分层的URI的scheme-specific-part必须符合下面的语法：

[//authority] [path] [?query] [#fragment]

可选的授权机构（authority）标识了该URI名字空间的命名机构。如果有这一部分则以‘//’开始。它可以是基于服务器或基于授权机构的。基于授权机构有特定的语法（本文没有讨论，因为很少使用它），而基于服务器的语法如下：

[userinfo@] host [:port]

基于服务器的authority以用户信息（例如用户名）开始，后面跟着一个@符号，紧接着是主机的名称，以及冒号和端口号。例如[e-mail]:90就是一个基于服务器的authority，其中jeff为用户信息，x.com为主机，90为端口。

可选的path根据authority（如果提供了）或schema（如果没有authority）定义资源的位置。路径（path）可以分成一系列的路径片断（path segment），每个路径片断使用‘/’与其它片断隔开。如果第一个路径片断以‘/’开始，该路径就被认为是绝对的，否则路径就被认为是相对的。例如，/a/b/c由三个路径片断a、b和c组成，此外这个路径是绝对的，因为第一个路径片断（a）的前缀是‘/’。

可选的query定义要传递给资源的查询信息。资源使用该信息获取或生成其它的的数据传递回调用者。例如，http://www.somesite.net/a?x=y, x=y就是一个query，在这个查询中x是某种实体的名称，y是该实体的值。

最后一个部分是fragment。当使用URI进行某种检索操作时，后面执行操作的软件使用fragment聚焦于软件感兴趣的资源部分。

分析一个例子ftp://[e-mail]:90/public/notes?text=shakespeare#hamlet

上面的URI把ftp识别为schema，把[e-mail]:90识别为基于服务器的authority（其中george是用户信息，x.com是主机，90是端口），把/public/notes识别为路径，把text=shakespeare识别为查询，把hamlet识别为片断。本质上它是一个叫做george的用户希望通过/public/notes路径在服务器x.com的90端口上检索shakespeare文本的hamlet信息。

 

 

 

URI的标准化（normalize）

 

标准化可以通过目录术语来理解。假定目录x直接位于根目录之下，x有子目录a和b，b有文件memo.txt，a是当前目录。为了显示memo.txt中的内容，你可能输入type \x\.\b\memo.txt。你也可能输入type \x\a\..\b\memo.txt，在这种情况下，a和..的出现是没有必要的。这两种形式都不是最简单的。但是如果输入\x\b\memo.txt，你就指定了最简单的路径了，从根目录开始访问memo.txt。最简单的\x\b\memo.txt路径就是标准化的路径。

通常通过base + relative URI访问资源。Base URI是绝对URI，而Relative URI标识了与Base URI相对的资源。因此有必要把两种URI通过解析过程合并，相反地从合并的URI中提取Relative URI也是可行的。

假定把x://a/作为Base URI，并把b/c作为Relative URI。Resolve这个相对URI将产生x://a/b/c。根据x://a/相对化（Relative）x://a/b/c将产生b/c。

URI不能读取/写入资源，这是统一的资源定位器（URL）的任务。URL是一种URI，它的schema是已知的网络协议，并且它把URI与某种协议处理程序联系起来（一种与资源通讯的读/写机制）。

URI一般不能为资源提供持久不变的名称。这是统一的资源命名（URN）的任务。URN也是一种URI，但是全球唯一的、持久不便的，即使资源不再存在或不再使用。

 

 

 

使用URI

Java API通过提供URI类（位于java.net包中），使我们在代码中使用URI成为可能。URI的构造函数建立URI对象，并且分析URI字符串，提取URI组件。URI的方法提供了如下功能：1）决定URI对象的URI是绝对的还是相对的；2）决定URI对象是opaque还是hierarchical；3）比较两个URI对象；4）标准化（normalize）URI对象；5）根据Base URI解析某个Relative URI；6）根据Base URI计算某个URI的相对URI；7）把URI对象转换为URL对象。

 

在URI里面有多个构造函数，最简单的是URI(String uri)。这个构造函数把String类型的参数URI分解为组件，并把这些组件存储在新的URI对象中。如果String对象的URI违反了RFC 2396的语法规则，将会产生一个java.net.URISyntaxException。

下面的代码演示了使用URI(String uri)建立URI对象：

 

URI uri = new URI ("http://www.cnn.com");

 

如果知道URI是有效的，不会产生URISyntaxException，可以使用静态的create(String uri)方法。这个方法分解uri，如果没有违反语法规则就建立URI对象，否则将捕捉到一个内部URISyntaxException，并把该对象包装在一个IllegalArgumentException中抛出。

 

下面的代码片断演示了create(String uri)：

 

URI uri = URI.create ("http://www.cnn.com");

 

URI构造函数和create(String uri)方法试图分解出URI的authority的用户信息、主机和端口部分。对于正确形式的字符串会成功，对于错误形式的字符串，他们将会失败。如果想确认某个URI的authority是基于服务器的，并且能分解出用户信息、主机和端口，这时候可以调用URI的parseServerAuthority()方法。如果成功分解出URI，该方法将返回包含用户信息、主机和端口部分的新URI对象，否则该方法将产生一个URISyntaxException。

下面的代码片断演示了parseServerAuthority()：

 

// 下面的parseServerAuthority()调用出现后会发生什么情况？
URI uri = new URI ("//foo:bar").parseServerAuthority();

 

 

 

一旦拥有了URI对象，你就可以通过调用getAuthority()、getFragment()、getHost()、getPath()、getPort()、getQuery()、getScheme()、getSchemeSpecificPart()和 getUserInfo()方法提取信息。以及isAbsolute()、isOpaque()等方法。

程序1: URIDemo1.java

 

import java.net.*;

public class URIDemo1 {
  public static void main (String [] args) throws Exception {
    if (args.length != 1) {
      System.err.println ("usage: java URIDemo1 uri");
      return;
    }
    URI uri = new URI (args [0]);

    System.out.println ("Authority = " +uri.getAuthority ());
    System.out.println ("Fragment = " +uri.getFragment ());
    System.out.println ("Host = " +uri.getHost ());
    System.out.println ("Path = " +uri.getPath ());
    System.out.println ("Port = " +uri.getPort ());
    System.out.println ("Query = " +uri.getQuery ());
    System.out.println ("Scheme = " +uri.getScheme ());
    System.out.println ("Scheme-specific part = " + uri.getSchemeSpecificPart ());
    System.out.println ("User Info = " +uri.getUserInfo ());
    System.out.println ("URI is absolute: " +uri.isAbsolute ());
    System.out.println ("URI is opaque: " +uri.isOpaque ());
  }
}

 

输入java URIDemo1命令后，输出结果如下：

 

query://[e-mail]:9000/public/manuals/appliances?stove#ge
Authority = [e-mail]:9000
Fragment = ge
Host = books.com
Path = /public/manuals/appliances
Port = 9000
Query = stove
Scheme = query
Scheme-specific part = //[e-mail]:9000/public/manuals/appliances?stove
User Info = jeff
URI is absolute: true
URI is opaque: false

 

URI类支持基本的操作，包括标准化（normalize）、分解（resolution）和相对化（relativize）。下例演示了normalize()方法。

 

程序2: URIDemo2.java

 

import java.net.*;

class URIDemo2 {
  public static void main (String [] args) throws Exception {
    if (args.length != 1) {
      System.err.println ("usage: java URIDemo2 uri");
      return;
    }
    URI uri = new URI (args [0]);
    System.out.println ("Normalized URI = " + uri.normalize());
  }
}

 

在命令行输入java URIDemo2 x/y/../z/./q，将看到下面的输出：
Normalized URI = x/z/q

上面的输出显示y、..和.消失了。

 

URI通过提供resolve(String uri)、resolve(URI uri)和relativize(URI uri)方法支持反向解析和相对化操作。如果指定的URI违反了RFC 2396语法规则，resolve(String uri)通过的内部的create(String uri)调用间接地产生一个IllegalArgumentException。下面的代码演示了resolve(String uri)和relativize(URI uri)。

程序3: URIDemo3.java

 

import java.net.*;

class URIDemo3 {
  public static void main (String [] args) throws Exception {
    if (args.length != 2) {
      System.err.println ("usage: " + "java URIDemo3 uriBase uriRelative");
      return;
    }

    URI uriBase = new URI (args [0]);
    System.out.println ("Base URI = " +uriBase);

    URI uriRelative = new URI (args [1]);
    System.out.println ("Relative URI = " +uriRelative);

    URI uriResolved = uriBase.resolve (uriRelative);
    System.out.println ("Resolved URI = " +uriResolved);

    URI uriRelativized = uriBase.relativize (uriResolved);
    System.out.println ("Relativized URI = " +uriRelativized);
  }
}

 

编译URIDemo3后，在命令行输入java URIDemo3 http://www.somedomain.com/ x/../y，输出如下：

 

Base URI = http://www.somedomain.com/
Relative URI = x/../y
Resolved URI = http://www.somedomain.com/y
Relativized URI = y

 

 

使用URL

Java提供了URL类，每一个URL对象都封装了资源标识符和协议处理程序。获得URL对象的途径之一是调用URI的toURL()方法，也可以直接调用URL的构造函数来建立URL对象。

 

URL类有多个构造函数。其中最简单的是URL(String url)，它有一个String类型的参数。如果某个URL没有包含协议处理程序或该URL的协议是未知的，其它的构造函数会产生一个java.net.MalformedURLException。
下面的代码片断演示了使用URL(String url)建立一个URL对象，该对象封装了一个简单的URL组件和http协议处理程序。

 

URL url = new URL ("http://www.informit.com");

 

一旦拥有了URL对象，就可以使用getAuthority()、getDefaultPort()、 getFile()、 getHost()、 getPath()、getPort()、 getProtocol()、getQuery()、getRef()、getUserInfo()、getDefaultPort()等方法提取各种组件。如果URL中没有指定端口，getDefaultPort()方法返回URL对象的协议默认端口。getFile()方法返回路径和查询组件的结合体。getProtocol()方法返回资源的连接类型（例如http、mailto、ftp）。getRef()方法返回URL的片断。最后，getUserInfo()方法返回Authority的用户信息部分。还可以调用openStream()方法得到java.io.InputStream引用。使用这种引用，可以用面向字节的方式读取资源。

 

 

 

 

 

下面是URLDemo1的代码。该程序建立一个URL对象，调用URL的各种方法来检索该URL的信息，调用URL的openStream()方法打开与资源的连接并读取/打印这些字节。

程序4: URLDemo1.java

 

import java.io.*;
import java.net.*;

class URLDemo1 {
  public static void main (String [] args) throws IOException {
    if (args.length != 1) {
    System.err.println ("usage: java URLDemo1 url");
    return;
    }

    URL url = new URL (args [0]);

    System.out.println ("Authority = "+ url.getAuthority ());
    System.out.println ("Default port = " +url.getDefaultPort ());
    System.out.println ("File = " +url.getFile ());
    System.out.println ("Host = " +url.getHost ());
    System.out.println ("Path = " +url.getPath ());
    System.out.println ("Port = " +url.getPort ());
    System.out.println ("Protocol = " +url.getProtocol ());
    System.out.println ("Query = " +url.getQuery ());
    System.out.println ("Ref = " +url.getRef ());
    System.out.println ("User Info = " +url.getUserInfo ());

    System.out.print ('\n');

    InputStream is = url.openStream ();

    int ch;
    while ((ch = is.read ()) != -1) {
      System.out.print ((char) ch);
    }
    is.close ();
  }
}

 

在命令行输入java URLDemo1 http://www.javajeff.com/articles/articles/html后，上面的代码的输出如下：

 

Authority = http://www.javajeff.com
Default port = 80
File = /articles/articles.html
Host = http://www.javajeff.com
Path = /articles/articles.html
Port = -1
Protocol = http
Query = null
Ref = null
User Info = null

<html>

…

</html>

 

URL的openStream()方法返回的InputStream类型，这意味着你必须按字节次序读取资源数据，这种做法是恰当的，因为你不知道将要读取的数据是什么类型。如果你事先知道要读取的数据是文本，并且每一行以换行符（\n）结束，你就可以按行读取而不是按字节读取数据了。

下面的代码片断演示了把一个InputStream对象包装进InputStreamReader以从8位过渡到16位字符，进而把结果对象包装进BufferedReader以调用其readLine()方法。

 

 

 

InputStream is = url.openStream ();
BufferedReader br = new BufferedReader (new InputStreamReader (is));
String line;
while ((line = br.readLine ()) != null) {

System.out.println (line);
}

is.close ();

 

有时候按字节的次序读取数据并不方便。例如，如果资源是JPEG文件，那么获取一个图像处理过程并向该过程注册一个用户使用数据的方法更好。如果出现这种情况，你就有必要使用getContent()方法。

当调用getContent()方法时，它会返回某种对象的引用，而你可以调用该对象的方法（在转换成适当的类型后），采用更方便的方式取得数据。但是在调用该方法前，最好使用instanceof验证对象的类型，防止类产生异常。

对于JPEG资源，getContent()返回一个对象，该对象实现了java.awt.Image.ImageProducer接口。下面的代码演示了使用如何getContent()。

 

URL url = new URL (args [0]);
Object o = url.getContent ();
if (o instanceof ImageProducer) {
  ImageProducer ip = (ImageProducer) o;
  // ...
}

 

查看一下getContent()方法的源代码，你会找到openConnection().getContent()。URL的openConnection()方法返回一个java.net.URLConnection对象。URLConnection的方法反映了资源和连接的细节信息，使我们能编写代码访问资源。

下面的URLDemo2代码演示了openConnection()，以及如何调用URLConnection的方法。

程序5: URLDemo2.java

 

import java.io.*;
import java.net.*;
import java.util.*;

class URLDemo2 {
  public static void main (String [] args) throws IOException {
    if (args.length != 1) {
      System.err.println ("usage: java URLDemo2 url");
      return;
    }

    URL url = new URL (args [0]);

    // 返回代表某个资源的连接的新的特定协议对象的引用
    URLConnection uc = url.openConnection ();

    // 进行连接
    uc.connect ();

    // 打印header的内容
    Map m = uc.getHeaderFields ();
    Iterator i = m.entrySet ().iterator ();
    while (i.hasNext ()) {
      System.out.println (i.next ());
    }
    // 检查是否资源允许输入和输出操作
    System.out.println ("Input allowed = " +uc.getDoInput ());
    System.out.println ("Output allowed = " +uc.getDoOutput ());
  }
}

 

 

 

 

 

URLConnection的getHeaderFields()方法返回一个java.util.Map。该map包含header名称和值的集合。header是基于文本的名称/值对，它识别资源数据的类型、数据的长度等等。

编译URLDemo2后，在命令行输入java URLDemo2 http://www.javajeff.com，输出如下：

 

Date=[Sun, 17 Feb 2002 17:49:32 GMT]
Connection=[Keep-Alive]
Content-Type=[text/html; charset=iso-8859-1]
Accept-Ranges=[bytes]
Content-Length=[7214]
null=[HTTP/1.1 200 OK]
ETag=["4470e-1c2e-3bf29d5a"]
Keep-Alive=[timeout=15, max=100]
Server=[Apache/1.3.19 (Unix) Debian/GNU]
Last-Modified=[Wed, 14 Nov 2001 16:35:38 GMT]
Input allowed = true
Output allowed = false

 

仔细看一下前面的输出，会看到叫做Content-Type的东西。Content-Type识别了资源数据的类型是text/html。text部分叫做类型，html部分叫做子类型。如果内容是普通的文本，Content-Type的值可能是text/plain。text/html表明内容是文本的但是html格式的。

 

 

 

Content-Type是多用途Internet邮件扩展（MIME）的一部分。MIME是传统的传输消息的7位ASCII标准的一种扩展。通过引入了多种header，MIME使视频、声音、图像、不同字符集的文本与7位ASCII结合起来。当使用URLConnection类的时候，你会遇到getContentType()和getContentLength()。这些方法返回的值是Content-Type和Content-Length的信息。

使用URL提交HTTP请求

 

你也许听说过HTML的<form>。它使我们能够从某种资源得到（GET）数据并按后来的处理把<form>的字段数据发送（POST）到某种资源。

 

假设你想把<form>数据发送（POST）到某个服务器程序。首先，<form>的数据必须组织为名称/值对（name/value pair），其次每个对必须指定为name=value格式，再次如果发送多个名称/值对，必须使用 & 符号把每对分开。最后name内容和value的内容必须使用application/x-www-form-urlencoded MIME类型编码。

 

 

 

为了辅助编码，Java提供了java.net.URLEncoder类，它声明了一对静态的encode()方法。每个方法有一个String参数并返回包含已编码的内容。例如，如果encode()发现参数中有空格，它在结果中用加号代替空格。

下面的代码演示了调用URLEncoder的encode(String s)方法，对‘a空格b’进行编码。结果a+b存储在一个新的String对象中。

 

String result = URLEncoder.encode ("a b");

 

另一个必须完成的事务是调用URLConnection的setDoOutput(boolean doOutput)方法，其参数的值必须为true。这种事务是必要的，因为URLConnection对象在默认情况下不支持输出。下面是URLDemo3的源代码，它演示了把窗体数据发送给某个资源。它实现了前面提到的各种事务。

程序6: URLDemo3.java

 

import java.io.*;
import java.net.*;

class URLDemo3 {
  public static void main (String [] args) throws IOException {
    if (args.length < 2 || args.length % 2 != 0) {
      System.err.println ("usage: java URLDemo3 name value " + "[name value ...]");
      return;
    }

    URL url = new URL("http://banshee.cs.uow.edu.au:2000/~nabg/echo.cgi");
    URLConnection uc = url.openConnection ();

    // 验证连接的类型，必须是HttpURLConnection的
    if (!(uc instanceof HttpURLConnection)) {
      System.err.println ("Wrong connection type");
      return;
    }

    // 必须能把名/值对输出到服务器程序资源
    uc.setDoOutput (true);

    // 不使用cache
    uc.setUseCaches (false);

    //设置Content-Type指示指定MIME类型
    uc.setRequestProperty ("Content-Type", "application/x-www-form-urlencoded");

    // 建立名/值对内容发送给服务器
    String content = buildContent (args);

    //设置Content-Length
    uc.setRequestProperty ("Content-Length", "" + content.length ());

    // 连接的适当类型
    HttpURLConnection hc = (HttpURLConnection) uc;

    // 把HTTP请求方法设置为POST（默认的是GET）
    hc.setRequestMethod ("POST");

    // 输出内容
    OutputStream os = uc.getOutputStream ();
    DataOutputStream dos = new DataOutputStream (os);
    dos.writeBytes (content);
    dos.flush ();
    dos.close ();

    // 从服务器程序资源输入和显示内容
    InputStream is = uc.getInputStream ();

    int ch;
    while ((ch = is.read ()) != -1)
      System.out.print ((char) ch);

    is.close ();
  }

  static String buildContent (String [] args) {
    StringBuffer sb = new StringBuffer ();

    for (int i = 0; i < args.length; i++) {
      // 对参数编码
      String encodedItem = URLEncoder.encode (args [i]);
      sb.append (encodedItem);
 
      if (i % 2 == 0)
        sb.append ("="); // 分离名称和值
      else
        sb.append ("&"); // 分离名称/值对
    } // end for

    // 删除最后的 & 间隔符
    sb.setLength (sb.length () - 1);
    return sb.toString ();
  }
}

 

 

 

URLDemo3编译后，在命令行输入java URLDemo3 name1 value1 name2 value2 name3 value3，你可以看到下面的输出：

 

<html>

<head>
<title>Echoing your name value pairs</title>
</head>
<body>
<ol>
<li>name1 : value1
<li>name2 : value2
<li>name3 : value3
</ol>
<hr>
Mon Feb 18 08:58:45 2002
</body>
</html>

 

   URL和URLConnection类封装了大量的复杂的实现细节，这些细节涉及到怎样从远程站点获取信息。

例如：我们可以通过传递一个字符串来构建一个URL对象

URL url = new URL("urlString");

       如果只是想要从该资源获取内容，可以用URL类提供的openStream方法。返回一个InputStream对象。

然后按照一般的方法进行获取，比如：

InputStream inStream = url.openStream();

Scanner in = new Scanner(inStream);

       java.net包对统一资源定位符（uniform resource locator，URL）和统一资源标识符（uniform resource identifier,URI）

作了非常有用的区分。

       URI是个纯粹的句法结构，用于指定标识web资源的字符串的各个不同部分。URL是URI的一个特例，它包含了用于定位

web资源的足够信息。其它URI，如：  mailto:****@163.com 则不属于定位符，因为根据该标识符我们无法定位任何数据。

像这样的URI我们称为URN（uniform resource name ,统一资源名称）。

        java的类库中，URI类不包含任何用于访问资源的方法，它的唯一作用就是解析。相反的是URL类可以打开一个到达资源的

流。因此，URL类只能作用于java类库知道该如何处理的模式，如：http:。https:.tfp:本地文件系统（file:）和jar文件（jar:）。为了

解对URI进行解析并不是可有可无的，要考虑它也许会变得非常复杂。如：

http://maps.yahoo.com/py/maps.py?csz=Cupertino+CA

ftp://username:[e-mail]/pub/file.txt

URI规范出了标记这些标识符的规则。一个URI具有以下句法：

[scheme:]schemeSpecificPart[#fragment]

上面的式子中[...]表示可行部分，它与:和#可以被包含在标识符内。它包含scheme:部分的URI被称为绝对URI。否则，被称为相对URI。

如果绝对的透明URI的schemeSpecificPart不是以/开头的，我们就称它不是透明的。例如：

mailto:***@163.com   所以绝对的透明URI和所有相对URI都是分层的（hierarchical）。例如：

http://ipc.me.index.html

../../java/net/socket.html#Socket()

一个分层的URI的schemeSpecificPart具有以下的结构：[//authority][path][?query] 在这里，[....]同样表示可选。

对于那些基于服务器的URI，authority部分采用以下的形式:[user-info@]host[:port]  port表示服务器中的端口必须是一个整数。

 

         URI的作用之一是：解析标识符并将它分解成各种不同的组成部分。可用以下的方法读取各个部分：

getScheme    getSchemeSpecificPart      getAuthority    getUserInfo      getHost

getPort           getPath                              getQuery         getFragment

URI的另一个作用是：处理绝对标识符和相对标识符。如果存在一个如下的绝对URI：

http://docs.mycompany.com/api/java/net/ServerSocket.html

和一个如下的相对URI：

../../java/net/Socket.html#Socket()

那么可以把它们合并成一个绝对的URI：

http://doc.mycompany.com/api/java/net/Socket.html#Socket()

这个过程被 称为相对URL的转换。（resolving）

与此相反的过程被称为“相对化”。例如，有一个基本的URI：

http://docs.mycompany.com/api 和另一个URI:

http://doc.mycompany.com/api/java/lang/String.html 那么它们相对化之后的URI就是

java/lang/Stirng.htlml

URI类同时支持以下两个操作：

relative = base.relativize(combined);

combined = base.resolve(relative);

评论

1 楼 倚在哈密路 2017-02-16  

文章写的太棒了，非常有用，谢谢。