Java 的基本网络支持

Java 为网络支持提供了 java.net 包，该包下的 URL 和 URLConnection 等类提供了以编程方式访问 Web 服务的功能，而 URLDecoder 和 URLEncoder 则提供了普通字符串和 application/x-www-form-urlencoded MIME 字符串相互转换的静态方法。

使用 InetAddress

Java 提供了 InetAddress 类来代表 IP 地址，InetAddress 下还有两个子类；Inet4Address、Inet6Address，它们分别代表 Internet Protocol version4 (IPv4) 地址和 Internet Protocol version6 (IPv6) 地址。InetAddress 类没有提供构造器，而是提供了如下两个静态方法来获取 InetAddress 实例。

• getByName(String host)：根据主机获取对应的 InetAddress 对象。
• getByAddress(byte[] addr)：根据原始 IP 地址来获取对应的 InetAddress 对象。

InetAddress 还提供了如下三个方法来获取 InetAddress 实例对应的 IP 地址和主机名。

• String getCanonicalHostName()：获取此 IP 地址的全限定域名。
• String getHostAddress()：返回该实例对应的 IP 地址字符串（以字符串形式）。
• String getHostName()：获取此 IP 地址的主机名。

除此之外，InetAddress 类还提供了一个 getLocalHost() 方法来获取本机 IP 地址对应的 InetAddress 实例。
InetAddress 类还提供了一个 isReachable() 方法，用于测试是否可以到达该地址。该方法将尽最大努力试图到达主机，但防火墙和服务器配置可能阻塞请求，使得它在访问某些特定的端囗时处于不可达状态。如果可以获得权限，典型的实现将使用 ICMP ECHO REQUEST；否则它将试图在目标主机的端口 7（Echo）上建立 TCP 连接。下面程序测试了 InetAddress 类的简单用法。

import java.net.*;

public class InetAddressTest {
    public static void main(String[] args) throws Exception {
        // 根据主机名来获取对应的InetAddress实例
        InetAddress ip = InetAddress.getByName("www.crazyit.org");
        // 判断是否可达
        System.out.println("crazyit是否可达：" + ip.isReachable(2000));
        // 获取该InetAddress实例的IP字符串
        System.out.println(ip.getHostAddress());
        // 根据原始IP地址来获取对应的InetAddress实例
        InetAddress local = InetAddress.getByAddress(new byte[] { 127, 0, 0, 1 });
        System.out.println("本机是否可达：" + local.isReachable(5000));
        // 获取该InetAddress实例对应的全限定域名
        System.out.println(local.getCanonicalHostName());
    }
}

上面程序简单地示范了 InetAddress 类的几个方法的用法，InetAddress 类本身并没有提供太多功能，它代表一个 IP 地址对象，是网络通信的基础，在后面介绍中将大量使用该类。

使用 URLDecoder 和 URLEncoder

URLDecoder 和 URLEncoder 用于完成普通字符串和 application/x-www-form-urlencoded MIME 字符串之间的相互转换。可能有读者觉得后一个字符串非常专业，以为又是什么特别高深的知识，其实不是。当 URL 地址里包含非西欧字符的字符串时，系统会将这些非西欧字符串转换成特殊字符串。编程过程中可能涉及普通字符串和这种特殊字符串的相关转换，这就需要使用 URLDecoder和 URLEncoder 类。

• URLDecoder 类包含一个 decode(String s, String enc)  静态方法，它可以将看上去是乱码的特殊字符串转换成普通字符串。
• URLEncoder 类包含一个 encode(String s, String enc）静态方法，它可以将普通字符串转换成 application/x-www-form-urlencoded MIME字符串。

下面程序示范了如何将地址栏中的“乱码”转换成普通字符串，并示范了如何将普通字符串转换成 application/x-www-form-urlencoded MIME字符串。

public class URLDecoderTest {
    public static void main(String[] args) throws Exception {
        // 将application/x-www-form-urlencoded字符串
        // 转换成普通字符串
        // 其中的字符串直接从图17.3所示窗口复制过来
        String keyWord = URLDecoder.decode("%E7%96%AF%E7%8B%82java", "utf-8");
        System.out.println(keyWord);
        // 将普通字符串转换成
        // application/x-www-form-urlencoded字符串
        String urlStr = URLEncoder.encode("疯狂Android讲义", "GBK");
        System.out.println(urlStr);
    }
}

上面程序中的粗体字代码用于完成普通字符串和 application/x-www-form-urlencoded MIME 字符串之间的转换。运行上而程序，将看到如下输出：

疯狂java
%B7%E8%BF%F1Android%BD%B2%D2%E5

提示：仅包含西欧字符的普通字符串和 application/x-www-form-urlencoded MIME 字符串无须转换，而包含中文字符的普通字符串则需要转换，转换方法是每个中文字符占两个字节，每个字节可以转换成两个十六进制的数字，所以每个中文字符将转换成 “%XX%XX” 的形式，当然，采用不同的字符集时，每个中文字符对应的字节数并不完全相同，所以使用 URLEncoder 和 URLDecoder 进行转换时也需要指定字集。

URL、URLConnection 和 URLPermission

URL（Uniform Resource Locator）对象代表统一资源定位器，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂对象的引用，例如对数据库或搜索引擎的查询。在通常情况下，URL可以由协议名、主机、端口和资源组成，即满足如下格式：

protocol://host:port/resourceName
例如如下的URL地址：
http://www.crazyit.org/index.php

提示：JDK 中还提供了一个 URI（Uniform Resource Identifiers）类，其实例代表一个统一资标识符，Java 的 URI 不能用于定位任何资源，它的唯一作用就是解析。与此对应的是，URL 则包含一个可打开到达该资源的输入流，可以将 URL 理解成 URI 的特例。

URL 类提供了多个构造器用于创建 URL 对象，一旦获得了 URL 对象之后，就可以调用如下方法来访问该 URL 对应的资源。

• String getFile()：获取该 URL 的资源名。
• String getHost()：获取该 URL 的主机名。
• String getPath()：获取该 URL 的路径部分。
• int getPort()：获取该 URL 的端口号。
• String getProtocol()：获取该 URL 的协议名称。
• String getQuery()：获取该 URL 的查询字符串部分。
• URLConnection openConnection()：返回一个 URLConnection 对象，它代表了与 URL 所引用的远程对象的连接。
• InputStream openStream()：打开与此 URL 的连接，并返回一个用于读取该 URL 资源的 InputStream。

URL 对象中的前面几个方法都非常容易理解，而该对象提供的 openStream() 方法可以读取该 URL 资源的 InputStream，通过该方法可以非常方便地读取远程资源一一甚至实现多线程下载。如下程序实现了一个多线程下载工具类。

import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.*;


public class DownUtil {
    // 定义下载资源的路径
    private String path;
    // 指定所下载的文件的保存位置
    private String targetFile;
    // 定义需要使用多少线程下载资源
    private int threadNum;
    // 定义下载的线程对象
    private DownThread[] threads;
    // 定义下载的文件的总大小
    private int fileSize;

    public DownUtil(String path, String targetFile, int threadNum) {
        this.path = path;
        this.threadNum = threadNum;
        // 初始化threads数组
        threads = new DownThread[threadNum];
        this.targetFile = targetFile;
    }

    public void download() throws Exception {
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(5 * 1000);
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Accept",
                "image/gif, image/jpeg, image/pjpeg, image/pjpeg, "
                        + "application/x-shockwave-flash, application/xaml+xml, "
                        + "application/vnd.ms-xpsdocument, application/x-ms-xbap, "
                        + "application/x-ms-application, application/vnd.ms-excel, "
                        + "application/vnd.ms-powerpoint, application/msword, */*");
        conn.setRequestProperty("Accept-Language", "zh-CN");
        conn.setRequestProperty("Charset", "UTF-8");
        conn.setRequestProperty("Connection", "Keep-Alive");
        // 得到文件大小
        fileSize = conn.getContentLength();
        conn.disconnect();
        int currentPartSize = fileSize / threadNum + 1;
        RandomAccessFile file = new RandomAccessFile(targetFile, "rw");
        // 设置本地文件的大小
        file.setLength(fileSize);
        file.close();
        for (int i = 0; i < threadNum; i++) {
            // 计算每条线程的下载的开始位置
            int startPos = i * currentPartSize;
            // 每个线程使用一个RandomAccessFile进行下载
            RandomAccessFile currentPart = new RandomAccessFile(targetFile, "rw");
            // 定位该线程的下载位置
            currentPart.seek(startPos);
            // 创建下载线程
            threads[i] = new DownThread(startPos, currentPartSize, currentPart);
            // 启动下载线程
            threads[i].start();
        }
    }

    // 获取下载的完成百分比
    public double getCompleteRate() {
        // 统计多条线程已经下载的总大小
        int sumSize = 0;
        for (int i = 0; i < threadNum; i++) {
            sumSize += threads[i].length;
        }
        // 返回已经完成的百分比
        return sumSize * 1.0 / fileSize;
    }

    private class DownThread extends Thread {
        // 当前线程的下载位置
        private int startPos;
        // 定义当前线程负责下载的文件大小
        private int currentPartSize;
        // 当前线程需要下载的文件块
        private RandomAccessFile currentPart;
        // 定义已经该线程已下载的字节数
        public int length;

        public DownThread(int startPos, int currentPartSize, RandomAccessFile currentPart) {
            this.startPos = startPos;
            this.currentPartSize = currentPartSize;
            this.currentPart = currentPart;
        }

        @Override
        public void run() {
            try {
                URL url = new URL(path);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setConnectTimeout(5 * 1000);
                conn.setRequestMethod("GET");
                conn.setRequestProperty("Accept",
                        "image/gif, image/jpeg, image/pjpeg, image/pjpeg, "
                                + "application/x-shockwave-flash, application/xaml+xml, "
                                + "application/vnd.ms-xpsdocument, application/x-ms-xbap, "
                                + "application/x-ms-application, application/vnd.ms-excel, "
                                + "application/vnd.ms-powerpoint, application/msword, */*");
                conn.setRequestProperty("Accept-Language", "zh-CN");
                conn.setRequestProperty("Charset", "UTF-8");
                InputStream inStream = conn.getInputStream();
                // 跳过startPos个字节，表明该线程只下载自己负责哪部分文件。
                inStream.skip(this.startPos);
                byte[] buffer = new byte[1024];
                int hasRead = 0;
                // 读取网络数据，并写入本地文件
                while (length < currentPartSize && (hasRead = inStream.read(buffer)) != -1) {
                    currentPart.write(buffer, 0, hasRead);
                    // 累计该线程下载的总大小
                    length += hasRead;
                }
                currentPart.close();
                inStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

上面程序中定义了 DownThread 线程类，该线程负责读取从 start 开始，到 end 结束的所有字节数据，并写入 RandomAccessFile 对象。这个 DownThread 线程类的 run() 方法就是一个简单的输入、输出实现。

程序中 DownUtils 类中的 download() 方法负责按如下步骤来实现多线程下载。

①创建 URL 对象。

②获取指定 URL 对象所指向资源的大小（通过 getContentLength() 方法获得），此处用到了 URLConnection 类，该类代表 Java 应用程序和 URL 之间的通信链接。后面还有关于 URLConnection 更详细的介绍。

③在本地磁盘上创建一个与网络资源具有相同大小的空文件。

④计算每个线程应该下载网络资源的哪个部分（从哪个字节开始，到哪个字节结束）。

⑤依次创建、启动多个线程来下载网络资源的指定部分。

提示：上面程序已经实现了多线程下载的核心代码，如果要实现断点下载，则需要额外增加一个配置文件（读者可以发现，所有的断点下载工具都会在下载开始时生成两个文件：一个是与网络资源具有相同大小的空文件，一个是配置文件），该配置文件分别记录每个线程已经下载到哪个字节，当网络断开后再次开始下载时，每个线程根据配置文件里记录的位置向后下载即可。

有了上面的 DownUtil 工具类之后，接下来就可以在主程序中调用该工具类的 down() 方法执行下载，如下程序所示。

package com.jwen.demo17_2;

public class MultiThreadDown {
    public static void main(String[] args) throws Exception {
        // 初始化DownUtil对象
        final DownUtil downUtil = new DownUtil(
                "http://www.crazyit.org/" + "attachments/month_1403/1403202355ff6cc9a4fbf6f14a.png", "ios.png", 4);
        // 开始下载
        downUtil.download();
        new Thread(() -> {
            while (downUtil.getCompleteRate() < 1) {
                // 每隔0.1秒查询一次任务的完成进度，
                // GUI程序中可根据该进度来绘制进度条
                System.out.println("已完成：" + downUtil.getCompleteRate());
                try {
                    Thread.sleep(1000);
                } catch (Exception ex) {
                }
            }
        }).start();
    }
}

运行上面程序，即可看到程序从 www.crazyit.org 下载得到一份名为 ios.png 的图片文件。

上面程序还用到 URLConnection 和 HttpURLConnection 对象，其中前者表示应用程序和 URL 之间的通信连接，后者表示与 URL 之间的 HTTP 连接。程序可以通过 URLConnection 实例向该 URL 发送请求、读取 URL 引用的资源。

Java 8 新增了一个 URLPermission 工具类，用于管理 HttpURLConnection 的权限问题，如果在 HttpURLConnection 安装了安全管理器，通过该对象打开连接时就需要先获得权限。

通常创建一个和 URL 的连接，并发送请求、读取此 URL 引用的资源需要如下几个步骤。

①通过调用 URL 对象的 openConnection() 方法来创建 URLConnection 对象。

②设置 URLConnection 的参数和普通请求属性。

③如果只是发送 GET 方式请求，则使用 connect() 方法建立和远程资源之间的实际连接即可：如果需要发送 POST 方式的请求，则需要获取 URLConnection 实例对应的输出流来发送请求参数。

④远程资源变为可用，程序可以访问远程资源的头字段或通过输入流读取远程资源的数据。

在建立和远程资源的实际连接之前，程序可以通过如下方法来设置请求头字段。

• setAllowUserInteraction()：设置该 URLConnection 的 allowUserInteraction 请求头字段的值。
• setDoInput()：设置该 URLConnection 的 doInput 请求头字段的值。
• setDoOutput()：设置该 URLConnection 的 doOutput 请求头字段的值。
• setIfModifiedSince()：设置该 URLConnection 的 ifModifiedSince 请求头字段的值。
• setUseCaches()：设置该 URLConnection 的 useCaches 请求头字段的值。

除此之外，还可以使用如下方法来设置或增加通用头字段。

• setRequestProperty(String key, String value)：设置该 URLConnection 的 key 请求头字段的值为 value。如下代码所示：conn.setRequestProperty("accept", "*/*");
• addRequestProperty(String key, String value)：为该 URLConnection 的 key 请求头字段增加 value 值，该方法并不会覆盖原请求头字段的值，而是将新值追加到原请求头字段中。

当远程资源可用之后，程序可以使用以下方法来访问头字段和内容。

• Object getContent()：获取该 URLConnection 的内容。
• String getHeaderField(String name)：获取指定响应头字段的值。
• getInputStream()：返回该 URLConnection 对应的输入流，用于获取 URLConnection 响应的内容。
• getOutputStream()：返回该 URLConnection 对应的输出流，用于向 URLConnection 发送请求参数。

getHeaderField() 方法用于根据响应头字段来返回对应的值。而某些头字段由于经常需要访问，所以 Java 提供了以下方法来访问特定响应头字段的值。

• getContentEncoding()：获取 content-encoding 响应头字段的值。
• getContentLength()：获取 content-length 响应头字段的值。
• getContentType()：获取 content-type 响应头字段的值。
• getDate()：获取date响应头字段的值。
• getExpiration()：获取 expires 响应头字段的值。
• getLastModified()：获取 last-modified 响应头字段的值。

注意：如果既要使用输入流读取 URLConnection 响应的内容，又要使用输出流发送请求参数，则一定要先使用输出流，再使用输入流。

下面程序示范了如何向 web 站点发送 GET 请求、POST 请求，并从 web 站点取得响应。

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

public class GetPostTest {
    /**
     * 向指定URL发送GET方法的请求
     * 
     * @param url   发送请求的URL
     * @param param 请求参数，格式满足name1=value1&name2=value2的形式。
     * @return URL所代表远程资源的响应
     */
    public static String sendGet(String url, String param) {
        String result = "";
        String urlName = url + "?" + param;
        try {
            URL realUrl = new URL(urlName);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            // 建立实际的连接
            conn.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = conn.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet()) {
                System.out.println(key + "--->" + map.get(key));
            }
            try (
                    // 定义BufferedReader输入流来读取URL的响应
                    BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"))) {
                String line;
                while ((line = in.readLine()) != null) {
                    result += "
" + line;
                }
            }
        } catch (Exception e) {
            System.out.println("发送GET请求出现异常！" + e);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 向指定URL发送POST方法的请求
     * 
     * @param url   发送请求的URL
     * @param param 请求参数，格式应该满足name1=value1&name2=value2的形式。
     * @return URL所代表远程资源的响应
     */
    public static String sendPost(String url, String param) {
        String result = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            try (
                // 获取URLConnection对象对应的输出流
                PrintWriter out = new PrintWriter(conn.getOutputStream())) {
                // 发送请求参数
                out.print(param);
                // flush输出流的缓冲
                out.flush();
            }
            try (
                // 定义BufferedReader输入流来读取URL的响应
                BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"))) {
                String line;
                while ((line = in.readLine()) != null) {
                    result += "
" + line;
                }
            }
        } catch (Exception e) {
            System.out.println("发送POST请求出现异常！" + e);
            e.printStackTrace();
        }
        return result;
    }

    // 提供主方法，测试发送GET请求和POST请求
    public static void main(String args[]) {
        // 发送GET请求
        String s = GetPostTest.sendGet("http://localhost:8888/abc/a.jsp", null);
        System.out.println(s);
        // 发送POST请求
        String s1 = GetPostTest.sendPost("http://localhost:8888/abc/login.jsp", "name=crazyit.org&pass=leegang");
        System.out.println(s1);
    }
}

上面程序中发送 GET 请求时只需将请求参数放在 URL 字符串之后，以？隔开，程序直接调用 URLConnection 对象的 connect() 方法即可，如 sendGet() 方法中粗体字代码所示；如果程序要发送 POST 请求，则需要先设置 doIn 和 doOut 两个请求头字段的值，再使用 URLConnection 对应的输出流来发送请求参数，如 sendPost() 方法中粗体字代码所示。

不管是发送 GET 请求，还是发送 POST 请求，程序获取 URLConnection 响应的方式完全一样如果程序可以确定远程响应是字符流，则可以使用字符流来读取；如果程序无法确定远程响应是字符流，则使用字节流读取即可。