java网络编程

原创 2007年10月06日 13:12:00
 
历史上的网络编程都倾向于困难、复杂,而且极易出错。
程序员必须掌握与网络有关的大量细节,有时甚至要对硬件有深刻的认识。一般地,我们需要理解连网协议中不同的“层”(Layer)。而且对于每个连网库,一般都包含了数量众多的函数,分别涉及信息块的连接、打包和拆包;这些块的来回运输;以及握手等等。这是一项令人痛苦的工作。
但是,连网本身的概念并不是很难。我们想获得位于其他地方某台机器上的信息,并把它们移到这儿;或者相反。这与读写文件非常相似,只是文件存在于远程机器上,而且远程机器有权决定如何处理我们请求或者发送的数据。
Java最出色的一个地方就是它的“无痛苦连网”概念。有关连网的基层细节已被尽可能地提取出去,并隐藏在JVM以及Java的本机安装系统里进行控制。我们使用的编程模型是一个文件的模型;事实上,网络连接(一个“套接字”)已被封装到系统对象里,所以可象对其他数据流那样采用同样的方法调用。除此以外,在我们处理另一个连网问题——同时控制多个网络连接——的时候,Java内建的多线程机制也是十分方便的。
本章将用一系列易懂的例子解释Java的连网支持。

15.1 机器的标识
当然,为了分辨来自别处的一台机器,以及为了保证自己连接的是希望的那台机器,必须有一种机制能独一无二地标识出网络内的每台机器。早期网络只解决了如何在本地网络环境中为机器提供唯一的名字。但Java面向的是整个因特网,这要求用一种机制对来自世界各地的机器进行标识。为达到这个目的,我们采用了IP(互联网地址)的概念。IP以两种形式存在着:
(1) 大家最熟悉的DNS(域名服务)形式。我自己的域名是bruceeckel.com。所以假定我在自己的域内有一台名为Opus的计算机,它的域名就可以是Opus.bruceeckel.com。这正是大家向其他人发送电子函件时采用的名字,而且通常集成到一个万维网(WWW)地址里。
(2) 此外,亦可采用“四点”格式,亦即由点号(.)分隔的四组数字,比如202.98.32.111。
不管哪种情况,IP地址在内部都表达成一个由32个二进制位(bit)构成的数字(注释①),所以IP地址的每一组数字都不能超过255。利用由java.net提供的static InetAddress.getByName(),我们可以让一个特定的Java对象表达上述任何一种形式的数字。结果是类型为InetAddress的一个对象,可用它构成一个“套接字”(Socket),大家在后面会见到这一点。

①:这意味着最多只能得到40亿左右的数字组合,全世界的人很快就会把它用光。但根据目前正在研究的新IP编址方案,它将采用128 bit的数字,这样得到的唯一性IP地址也许在几百年的时间里都不会用完。

作为运用InetAddress.getByName()一个简单的例子,请考虑假设自己有一家拨号连接因特网服务提供者(ISP),那么会发生什么情况。每次拨号连接的时候,都会分配得到一个临时IP地址。但在连接期间,那个IP地址拥有与因特网上其他IP地址一样的有效性。如果有人按照你的IP地址连接你的机器,他们就有可能使用在你机器上运行的Web或者FTP服务器程序。当然这有个前提,对方必须准确地知道你目前分配到的IP。由于每次拨号连接获得的IP都是随机的,怎样才能准确地掌握你的IP呢?
下面这个程序利用InetAddress.getByName()来产生你的IP地址。为了让它运行起来,事先必须知道计算机的名字。该程序只在Windows 95中进行了测试,但大家可以依次进入自己的“开始”、“设置”、“控制面板”、“网络”,然后进入“标识”卡片。其中,“计算机名称”就是应在命令行输入的内容。
//: WhoAmI.java
// Finds out your network address when you're
// connected to the Internet.
package c15;
import java.net.*;
 
publicclass WhoAmI {
 publicstaticvoid main(String[] args)
      throws Exception {
    if(args.length != 1) {
      System.err.println(
        "Usage: WhoAmI MachineName");
      System.exit(1);
    }
    InetAddress a =
      InetAddress.getByName(args[0]);
    System.out.println(a);
 }
} ///:~

就我自己的情况来说,机器的名字叫作“Colossus”(来自同名电影,“巨人”的意思。我在这台机器上有一个很大的硬盘)。所以一旦连通我的ISP,就象下面这样执行程序:
java whoAmI Colossus
得到的结果象下面这个样子(当然,这个地址可能每次都是不同的):
Colossus/202.98.41.151
假如我把这个地址告诉一位朋友,他就可以立即登录到我的个人Web服务器,只需指定目标地址http://202.98.41.151即可(当然,我此时不能断线)。有些时候,这是向其他人发送信息或者在自己的Web站点正式出台以前进行测试的一种方便手段。

15.1.1 服务器和客户机
网络最基本的精神就是让两台机器连接到一起,并相互“交谈”或者“沟通”。一旦两台机器都发现了对方,就可以展开一次令人愉快的双向对话。但它们怎样才能“发现”对方呢?这就象在游乐园里那样:一台机器不得不停留在一个地方,侦听其他机器说:“嘿,你在哪里呢?”
“停留在一个地方”的机器叫作“服务器”(Server);到处“找人”的机器则叫作“客户机”(Client)或者“客户”。它们之间的区别只有在客户机试图同服务器连接的时候才显得非常明显。一旦连通,就变成了一种双向通信,谁来扮演服务器或者客户机便显得不那么重要了。
所以服务器的主要任务是侦听建立连接的请求,这是由我们创建的特定服务器对象完成的。而客户机的任务是试着与一台服务器建立连接,这是由我们创建的特定客户机对象完成的。一旦连接建好,那么无论在服务器端还是客户机端,连接只是魔术般地变成了一个IO数据流对象。从这时开始,我们可以象读写一个普通的文件那样对待连接。所以一旦建好连接,我们只需象第10章那样使用自己熟悉的IO命令即可。这正是Java连网最方便的一个地方。

1. 在没有网络的前提下测试程序
由于多种潜在的原因,我们可能没有一台客户机、服务器以及一个网络来测试自己做好的程序。我们也许是在一个课堂环境中进行练习,或者写出的是一个不十分可靠的网络应用,还能拿到网络上去。IP的设计者注意到了这个问题,并建立了一个特殊的地址——localhost——来满足非网络环境中的测试要求。在Java中产生这个地址最一般的做法是:
InetAddress addr = InetAddress.getByName(null);
如果向getByName()传递一个null(空)值,就默认为使用localhost。我们用InetAddress对特定的机器进行索引,而且必须在进行进一步的操作之前得到这个InetAddress(互联网地址)。我们不可以操纵一个InetAddress的内容(但可把它打印出来,就象下一个例子要演示的那样)。创建InetAddress的唯一途径就是那个类的static(静态)成员方法getByName()(这是最常用的)、getAllByName()或者getLocalHost()。
为得到本地主机地址,亦可向其直接传递字串"localhost":
InetAddress.getByName("localhost");
或者使用它的保留IP地址(四点形式),就象下面这样:
InetAddress.getByName("127.0.0.1");
这三种方法得到的结果是一样的。

15.1.2 端口:机器内独一无二的场所
有些时候,一个IP地址并不足以完整标识一个服务器。这是由于在一台物理性的机器中,往往运行着多个服务器(程序)。由IP表达的每台机器也包含了“端口”(Port)。我们设置一个客户机或者服务器的时候,必须选择一个无论客户机还是服务器都认可连接的端口。就象我们去拜会某人时,IP地址是他居住的房子,而端口是他在的那个房间。
注意端口并不是机器上一个物理上存在的场所,而是一种软件抽象(主要是为了表述的方便)。客户程序知道如何通过机器的IP地址同它连接,但怎样才能同自己真正需要的那种服务连接呢(一般每个端口都运行着一种服务,一台机器可能提供了多种服务,比如HTTP和FTP等等)?端口编号在这里扮演了重要的角色,它是必需的一种二级定址措施。也就是说,我们请求一个特定的端口,便相当于请求与那个端口编号关联的服务。“报时”便是服务的一个典型例子。通常,每个服务都同一台特定服务器机器上的一个独一无二的端口编号关联在一起。客户程序必须事先知道自己要求的那项服务的运行端口号。
系统服务保留了使用端口1到端口1024的权力,所以不应让自己设计的服务占用这些以及其他任何已知正在使用的端口。本书的第一个例子将使用端口8080(为追忆我的第一台机器使用的老式8位Intel 8080芯片,那是一部使用CP/M操作系统的机子)。

15.2 套接字
“套接字”或者“插座”(Socket)也是一种软件形式的抽象,用于表达两台机器间一个连接的“终端”。针对一个特定的连接,每台机器上都有一个“套接字”,可以想象它们之间有一条虚拟的“线缆”。线缆的每一端都插入一个“套接字”或者“插座”里。当然,机器之间的物理性硬件以及电缆连接都是完全未知的。抽象的基本宗旨是让我们尽可能不必知道那些细节。
在Java中,我们创建一个套接字,用它建立与其他机器的连接。从套接字得到的结果是一个InputStream以及OutputStream(若使用恰当的转换器,则分别是Reader和Writer),以便将连接作为一个IO流对象对待。有两个基于数据流的套接字类:ServerSocket,服务器用它“侦听”进入的连接;以及Socket,客户用它初始一次连接。一旦客户(程序)申请建立一个套接字连接,ServerSocket就会返回(通过accept()方法)一个对应的服务器端套接字,以便进行直接通信。从此时起,我们就得到了真正的“套接字-套接字”连接,可以用同样的方式对待连接的两端,因为它们本来就是相同的!此时可以利用getInputStream()以及getOutputStream()从每个套接字产生对应的InputStream和OutputStream对象。这些数据流必须封装到缓冲区内。可按第10章介绍的方法对类进行格式化,就象对待其他任何流对象那样。
对于Java库的命名机制,ServerSocket(服务器套接字)的使用无疑是容易产生混淆的又一个例证。大家可能认为ServerSocket最好叫作“ServerConnector”(服务器连接器),或者其他什么名字,只是不要在其中安插一个“Socket”。也可能以为ServerSocket和Socket都应从一些通用的基础类继承。事实上,这两种类确实包含了几个通用的方法,但还不够资格把它们赋给一个通用的基础类。相反,ServerSocket的主要任务是在那里耐心地等候其他机器同它连接,再返回一个实际的Socket。这正是“ServerSocket”这个命名不恰当的地方,因为它的目标不是真的成为一个Socket,而是在其他人同它连接的时候产生一个Socket对象。
然而,ServerSocket确实会在主机上创建一个物理性的“服务器”或者侦听用的套接字。这个套接字会侦听进入的连接,然后利用accept()方法返回一个“已建立”套接字(本地和远程端点均已定义)。容易混淆的地方是这两个套接字(侦听和已建立)都与相同的服务器套接字关联在一起。侦听套接字只能接收新的连接请求,不能接收实际的数据包。所以尽管ServerSocket对于编程并无太大的意义,但它确实是“物理性”的。
创建一个ServerSocket时,只需为其赋予一个端口编号。不必把一个IP地址分配它,因为它已经在自己代表的那台机器上了。但在创建一个Socket时,却必须同时赋予IP地址以及要连接的端口编号(另一方面,从ServerSocket.accept()返回的Socket已经包含了所有这些信息)。

15.2.1 一个简单的服务器和客户机程序
这个例子将以最简单的方式运用套接字对服务器和客户机进行操作。服务器的全部工作就是等候建立一个连接,然后用那个连接产生的Socket创建一个InputStream以及一个OutputStream。在这之后,它从InputStream读入的所有东西都会反馈给OutputStream,直到接收到行中止(END)为止,最后关闭连接。
客户机连接与服务器的连接,然后创建一个OutputStream。文本行通过OutputStream发送。客户机也会创建一个InputStream,用它收听服务器说些什么(本例只不过是反馈回来的同样的字句)。
服务器与客户机(程序)都使用同样的端口号,而且客户机利用本地主机地址连接位于同一台机器中的服务器(程序),所以不必在一个物理性的网络里完成测试(在某些配置环境中,可能需要同真正的网络建立连接,否则程序不能工作——尽管实际并不通过那个网络通信)。
下面是服务器程序:
//: JabberServer.java
// Very simple server that just
// echoes whatever the client sends.
import java.io.*;
import java.net.*;
 
publicclass JabberServer { 
 // Choose a port outside of the range 1-1024:
 publicstaticfinalint PORT = 8080;
 publicstaticvoid main(String[] args)
      throws IOException {
    ServerSocket s = new ServerSocket(PORT);
    System.out.println("Started: " + s);
    try {
      // Blocks until a connection occurs:
      Socket socket = s.accept();
      try {
        System.out.println(
          "Connection accepted: "+ socket);
        BufferedReader in =
          new BufferedReader(
            new InputStreamReader(
              socket.getInputStream()));
        // Output is automatically flushed
        // by PrintWriter:
        PrintWriter out =
          new PrintWriter(
            new BufferedWriter(
              new OutputStreamWriter(
                socket.getOutputStream())),true);
        while (true) { 
          String str = in.readLine();
          if (str.equals("END")) break;
          System.out.println("Echoing: " + str);
          out.println(str);
        }
      // Always close the two sockets...
      } finally {
        System.out.println("closing...");
        socket.close();
      }
    } finally {
      s.close();
    }
 }
} ///:~

可以看到,ServerSocket需要的只是一个端口编号,不需要IP地址(因为它就在这台机器上运行)。调用accept()时,方法会暂时陷入停顿状态(堵塞),直到某个客户尝试同它建立连接。换言之,尽管它在那里等候连接,但其他进程仍能正常运行(参考第14章)。建好一个连接以后,accept()就会返回一个Socket对象,它是那个连接的代表。
清除套接字的责任在这里得到了很艺术的处理。假如ServerSocket构建器失败,则程序简单地退出(注意必须保证ServerSocket的构建器在失败之后不会留下任何打开的网络套接字)。针对这种情况,main()会“掷”出一个IOException违例,所以不必使用一个try块。若ServerSocket构建器成功执行,则其他所有方法调用都必须到一个try-finally代码块里寻求保护,以确保无论块以什么方式留下,ServerSocket都能正确地关闭。
同样的道理也适用于由accept()返回的Socket。若accept()失败,那么我们必须保证Socket不再存在或者含有任何资源,以便不必清除它们。但假若执行成功,则后续的语句必须进入一个try-finally块内,以保障在它们失败的情况下,Socket仍能得到正确的清除。由于套接字使用了重要的非内存资源,所以在这里必须特别谨慎,必须自己动手将它们清除(Java中没有提供“破坏器”来帮助我们做这件事情)。
无论ServerSocket还是由accept()产生的Socket都打印到System.out里。这意味着它们的toString方法会得到自动调用。这样便产生了:
ServerSocket[addr=0.0.0.0,PORT=0,localport=8080]
Socket[addr=127.0.0.1,PORT=1077,localport=8080]

大家不久就会看到它们如何与客户程序做的事情配合。
程序的下一部分看来似乎仅仅是打开文件,以便读取和写入,只是InputStream和OutputStream是从Socket对象创建的。利用两个“转换器”类InputStreamReader和OutputStreamWriter,InputStream和OutputStream对象已经分别转换成为Java 1.1的Reader和Writer对象。也可以直接使用Java1.0的InputStream和OutputStream类,但对输出来说,使用Writer方式具有明显的优势。这一优势是通过PrintWriter表现出来的,它有一个过载的构建器,能获取第二个参数——一个布尔值标志,指向是否在每一次println()结束的时候自动刷新输出(但不适用于print()语句)。每次写入了输出内容后(写进out),它的缓冲区必须刷新,使信息能正式通过网络传递出去。对目前这个例子来说,刷新显得尤为重要,因为客户和服务器在采取下一步操作之前都要等待一行文本内容的到达。若刷新没有发生,那么信息不会进入网络,除非缓冲区满(溢出),这会为本例带来许多问题。
编写网络应用程序时,需要特别注意自动刷新机制的使用。每次刷新缓冲区时,必须创建和发出一个数据包(数据封)。就目前的情况来说,这正是我们所希望的,因为假如包内包含了还没有发出的文本行,服务器和客户机之间的相互“握手”就会停止。换句话说,一行的末尾就是一条消息的末尾。但在其他许多情况下,消息并不是用行分隔的,所以不如不用自动刷新机制,而用内建的缓冲区判决机制来决定何时发送一个数据包。这样一来,我们可以发出较大的数据包,而且处理进程也能加快。
注意和我们打开的几乎所有数据流一样,它们都要进行缓冲处理。本章末尾有一个练习,清楚展现了假如我们不对数据流进行缓冲,那么会得到什么样的后果(速度会变慢)。
无限while循环从BufferedReader in内读取文本行,并将信息写入System.out,然后写入PrintWriter.out。注意这可以是任何数据流,它们只是在表面上同网络连接。
客户程序发出包含了"END"的行后,程序会中止循环,并关闭Socket。
下面是客户程序的源码:
//: JabberClient.java
// Very simple client that just sends
// lines to the server and reads lines
// that the server sends.
import java.net.*;
import java.io.*;
 
publicclass JabberClient {
 publicstaticvoid main(String[] args)
      throws IOException {
    // Passing null to getByName() produces the
    // special "Local Loopback" IP address, for
    // testing on one machine w/o a network:
    InetAddress addr =
      InetAddress.getByName(null);
    // Alternatively, you can use
    // the address or name:
    // InetAddress addr =
    //    InetAddress.getByName("127.0.0.1");
    // InetAddress addr =
    //    InetAddress.getByName("localhost");
    System.out.println("addr = " + addr);
    Socket socket =
      new Socket(addr, JabberServer.PORT);
    // Guard everything in a try-finally to make
    // sure that the socket is closed:
    try {
      System.out.println("socket = " + socket);
      BufferedReader in =
        new BufferedReader(
          new InputStreamReader(
            socket.getInputStream()));
      // Output is automatically flushed
      // by PrintWriter:
      PrintWriter out =
        new PrintWriter(
          new BufferedWriter(
            new OutputStreamWriter(
              socket.getOutputStream())),true);
      for(int i = 0; i < 10; i ++) {
        out.println("howdy " + i);
        String str = in.readLine();
        System.out.println(str);
      }
      out.println("END");
    } finally {
      System.out.println("closing...");
      socket.close();
    }
 }
} ///:~

在main()中,大家可看到获得本地主机IP地址的InetAddress的三种途径:使用null,使用localhost,或者直接使用保留地址127.0.0.1。当然,如果想通过网络同一台远程主机连接,也可以换用那台机器的IP地址。打印出InetAddress addr后(通过对toString()方法的自动调用),结果如下:
localhost/127.0.0.1
通过向getByName()传递一个null,它会默认寻找localhost,并生成特殊的保留地址127.0.0.1。注意在名为socket的套接字创建时,同时使用了InetAddress以及端口号。打印这样的某个Socket对象时,为了真正理解它的含义,请记住一次独一无二的因特网连接是用下述四种数据标识的:clientHost(客户主机)、clientPortNumber(客户端口号)、serverHost(服务主机)以及serverPortNumber(服务端口号)。服务程序启动后,会在本地主机(127.0.0.1)上建立为它分配的端口(8080)。一旦客户程序发出请求,机器上下一个可用的端口就会分配给它(这种情况下是1077),这一行动也在与服务程序相同的机器(127.0.0.1)上进行。现在,为了使数据能在客户及服务程序之间来回传送,每一端都需要知道把数据发到哪里。所以在同一个“已知”服务程序连接的时候,客户会发出一个“返回地址”,使服务器程序知道将自己的数据发到哪儿。我们在服务器端的示范输出中可以体会到这一情况:
Socket[addr=127.0.0.1,port=1077,localport=8080]
这意味着服务器刚才已接受了来自127.0.0.1这台机器的端口1077的连接,同时监听自己的本地端口(8080)。而在客户端:
Socket[addr=localhost/127.0.0.1,PORT=8080,localport=1077]
这意味着客户已用自己的本地端口1077与127.0.0.1机器上的端口8080建立了 连接。
大家会注意到每次重新启动客户程序的时候,本地端口的编号都会增加。这个编号从1025(刚好在系统保留的1-1024之外)开始,并会一直增加下去,除非我们重启机器。若重新启动机器,端口号仍然会从1025开始增值(在Unix机器中,一旦超过保留的套按字范围,数字就会再次从最小的可用数字开始)。
创建好Socket对象后,将其转换成BufferedReader和PrintWriter的过程便与在服务器中相同(同样地,两种情况下都要从一个Socket开始)。在这里,客户通过发出字串"howdy",并在后面跟随一个数字,从而初始化通信。注意缓冲区必须再次刷新(这是自动发生的,通过传递给PrintWriter构建器的第二个参数)。若缓冲区没有刷新,那么整个会话(通信)都会被挂起,因为用于初始化的“howdy”永远不会发送出去(缓冲区不够满,不足以造成发送动作的自动进行)。从服务器返回的每一行都会写入System.out,以验证一切都在正常运转。为中止会话,需要发出一个"END"。若客户程序简单地挂起,那么服务器会“掷”出一个违例。
大家在这里可以看到我们采用了同样的措施来确保由Socket代表的网络资源得到正确的清除,这是用一个try-finally块实现的。
套接字建立了一个“专用”连接,它会一直持续到明确断开连接为止(专用连接也可能间接性地断开,前提是某一端或者中间的某条链路出现故障而崩溃)。这意味着参与连接的双方都被锁定在通信中,而且无论是否有数据传递,连接都会连续处于开放状态。从表面看,这似乎是一种合理的连网方式。然而,它也为网络带来了额外的开销。本章后面会介绍进行连网的另一种方式。采用那种方式,连接的建立只是暂时的。

15.3 服务多个客户
JabberServer可以正常工作,但每次只能为一个客户程序提供服务。在典型的服务器中,我们希望同时能处理多个客户的请求。解决这个问题的关键就是多线程处理机制。而对于那些本身不支持多线程的语言,达到这个要求无疑是异常困难的。通过第14章的学习,大家已经知道Java已对多线程的处理进行了尽可能的简化。由于Java的线程处理方式非常直接,所以让服务器控制多名客户并不是件难事。
最基本的方法是在服务器(程序)里创建单个ServerSocket,并调用accept()来等候一个新连接。一旦accept()返回,我们就取得结果获得的Socket,并用它新建一个线程,令其只为那个特定的客户服务。然后再调用accept(),等候下一次新的连接请求。
对于下面这段服务器代码,大家可发现它与JabberServer.java例子非常相似,只是为一个特定的客户提供服务的所有操作都已移入一个独立的线程类中:
//: MultiJabberServer.java
// A server that uses multithreading to handle
// any number of clients.
import java.io.*;
import java.net.*;
 
class ServeOneJabber extends Thread {
 private Socket socket;
 private BufferedReader in;
 private PrintWriter out;
 public ServeOneJabber(Socket s)
      throws IOException {
    socket = s;
    in =
      new BufferedReader(
        new InputStreamReader(
          socket.getInputStream()));
    // Enable auto-flush:
    out =
      new PrintWriter(
        new BufferedWriter(
          new OutputStreamWriter(
            socket.getOutputStream())), true);
    // If any of the above calls throw an
    // exception, the caller is responsible for
    // closing the socket. Otherwise the thread
    // will close it.
    start(); // Calls run()
 }
 publicvoid run() {
    try {
      while (true) { 
        String str = in.readLine();
        if (str.equals("END")) break;
        System.out.println("Echoing: " + str);
        out.println(str);
      }
      System.out.println("closing...");
    } catch (IOException e) {
    } finally {
      try {
        socket.close();
      } catch(IOException e) {}
    }
 }
}
 
publicclass MultiJabberServer { 
 staticfinalint PORT = 8080;
 publicstaticvoid main(String[] args)
      throws IOException {
    ServerSocket s = new ServerSocket(PORT);
    System.out.println("Server Started");
    try {
      while(true) {
        // Blocks until a connection occurs:
        Socket socket = s.accept();
        try {
          new ServeOneJabber(socket);
        } catch(IOException e) {
          // If it fails, close the socket,
          // otherwise the thread will close it:
          socket.close();
        }
      }
    } finally {
      s.close();
    }
 }
} ///:~

每次有新客户请求建立一个连接时,ServeOneJabber线程都会取得由accept()在main()中生成的Socket对象。然后和往常一样,它创建一个BufferedReader,并用Socket自动刷新PrintWriter对象。最后,它调用Thread的特殊方法start(),令其进行线程的初始化,然后调用run()。这里采取的操作与前例是一样的:从套扫字读入某些东西,然后把它原样反馈回去,直到遇到一个特殊的"END"结束标志为止。
同样地,套接字的清除必须进行谨慎的设计。就目前这种情况来说,套接字是在ServeOneJabber外部创建的,所以清除工作可以“共享”。若ServeOneJabber构建器失败,那么只需向调用者“掷”出一个违例即可,然后由调用者负责线程的清除。但假如构建器成功,那么必须由ServeOneJabber对象负责线程的清除,这是在它的run()里进行的。
请注意MultiJabberServer有多么简单。和以前一样,我们创建一个ServerSocket,并调用accept()允许一个新连接的建立。但这一次,accept()的返回值(一个套接字)将传递给用于ServeOneJabber的构建器,由它创建一个新线程,并对那个连接进行控制。连接中断后,线程便可简单地消失。
如果ServerSocket创建失败,则再一次通过main()掷出违例。如果成功,则位于外层的try-finally代码块可以担保正确的清除。位于内层的try-catch块只负责防范ServeOneJabber构建器的失败;若构建器成功,则ServeOneJabber线程会将对应的套接字关掉。
为了证实服务器代码确实能为多名客户提供服务,下面这个程序将创建许多客户(使用线程),并同相同的服务器建立连接。每个线程的“存在时间”都是有限的。一旦到期,就留出空间以便创建一个新线程。允许创建的线程的最大数量是由final int maxthreads决定的。大家会注意到这个值非常关键,因为假如把它设得很大,线程便有可能耗尽资源,并产生不可预知的程序错误。
//: MultiJabberClient.java
// Client that tests the MultiJabberServer
// by starting up multiple clients.
import java.net.*;
import java.io.*;
 
class JabberClientThread extends Thread {
 private Socket socket;
 private BufferedReader in;
 private PrintWriter out;
 privatestaticint counter = 0;
 privateint id = counter++;
 privatestaticint threadcount = 0;
 publicstaticint threadCount() {
    return threadcount;
 }
 public JabberClientThread(InetAddress addr) {
    System.out.println("Making client " + id);
    threadcount++;
    try {
      socket =
        new Socket(addr, MultiJabberServer.PORT);
    } catch(IOException e) {
      // If the creation of the socket fails,
      // nothing needs to be cleaned up.
    }
    try {   
      in =
        new BufferedReader(
          new InputStreamReader(
            socket.getInputStream()));
      // Enable auto-flush:
      out =
        new PrintWriter(
          new BufferedWriter(
            new OutputStreamWriter(
              socket.getOutputStream())), true);
      start();
    } catch(IOException e) {
      // The socket should be closed on any
      // failures other than the socket
      // constructor:
      try {
        socket.close();
      } catch(IOException e2) {}
    }
    // Otherwise the socket will be closed by
    // the run() method of the thread.
 }
 publicvoid run() {
    try {
      for(int i = 0; i < 25; i++) {
        out.println("Client " + id + ": " + i);
        String str = in.readLine();
        System.out.println(str);
      }
      out.println("END");
    } catch(IOException e) {
    } finally {
      // Always close it:
      try {
        socket.close();
      } catch(IOException e) {}
      threadcount--; // Ending this thread
    }
 }
}
 
publicclass MultiJabberClient {
 staticfinalint MAX_THREADS = 40;
 publicstaticvoid main(String[] args)
      throws IOException, InterruptedException {
    InetAddress addr =
      InetAddress.getByName(null);
    while(true) {
      if(JabberClientThread.threadCount()
         < MAX_THREADS)
        new JabberClientThread(addr);
      Thread.currentThread().sleep(100);
    }
 }
} ///:~

JabberClientThread
构建器获取一个InetAddress,并用它打开一个套接字。大家可能已看出了这样的一个套路:Socket肯定用于创建某种Reader以及/或者Writer(或者InputStream和/或OutputStream)对象,这是运用Socket的唯一方式(当然,我们可考虑编写一、两个类,令其自动完成这些操作,避免大量重复的代码编写工作)。同样地,start()执行线程的初始化,并调用run()。在这里,消息发送给服务器,而来自服务器的信息则在屏幕上回显出来。然而,线程的“存在时间”是有限的,最终都会结束。注意在套接字创建好以后,但在构建器完成之前,假若构建器失败,套接字会被清除。否则,为套接字调用close()的责任便落到了run()方法的头上。
threadcount跟踪计算目前存在的JabberClientThread对象的数量。它将作为构建器的一部分增值,并在run()退出时减值(run()退出意味着线程中止)。在MultiJabberClient.main()中,大家可以看到线程的数量会得到检查。若数量太多,则多余的暂时不创建。方法随后进入“休眠”状态。这样一来,一旦部分线程最后被中止,多作的那些线程就可以创建了。大家可试验一下逐渐增大MAX_THREADS,看看对于你使用的系统来说,建立多少线程(连接)才会使您的系统资源降低到危险程度。

15.4 数据报
大家迄今看到的例子使用的都是“传输控制协议”(TCP),亦称作“基于数据流的套接字”。根据该协议的设计宗旨,它具有高度的可靠性,而且能保证数据顺利抵达目的地。换言之,它允许重传那些由于各种原因半路“走失”的数据。而且收到字节的顺序与它们发出来时是一样的。当然,这种控制与可靠性需要我们付出一些代价:TCP具有非常高的开销。
还有另一种协议,名为“用户数据报协议”(UDP),它并不刻意追求数据包会完全发送出去,也不能担保它们抵达的顺序与它们发出时一样。我们认为这是一种“不可靠协议”(TCP当然是“可靠协议”)。听起来似乎很糟,但由于它的速度快得多,所以经常还是有用武之地的。对某些应用来说,比如声音信号的传输,如果少量数据包在半路上丢失了,那么用不着太在意,因为传输的速度显得更重要一些。大多数互联网游戏,如Diablo,采用的也是UDP协议通信,因为网络通信的快慢是游戏是否流畅的决定性因素。也可以想想一台报时服务器,如果某条消息丢失了,那么也真的不必过份紧张。另外,有些应用也许能向服务器传回一条UDP消息,以便以后能够恢复。如果在适当的时间里没有响应,消息就会丢失。
Java对数据报的支持与它对TCP套接字的支持大致相同,但也存在一个明显的区别。对数据报来说,我们在客户和服务器程序都可以放置一个DatagramSocket(数据报套接字),但与ServerSocket不同,前者不会干巴巴地等待建立一个连接的请求。这是由于不再存在“连接”,取而代之的是一个数据报陈列出来。另一项本质的区别的是对TCP套接字来说,一旦我们建好了连接,便不再需要关心谁向谁“说话”——只需通过会话流来回传送数据即可。但对数据报来说,它的数据包必须知道自己来自何处,以及打算去哪里。这意味着我们必须知道每个数据报包的这些信息,否则信息就不能正常地传递。
DatagramSocket用于收发数据包,而DatagramPacket包含了具体的信息。准备接收一个数据报时,只需提供一个缓冲区,以便安置接收到的数据。数据包抵达时,通过DatagramSocket,作为信息起源地的因特网地址以及端口编号会自动得到初化。所以一个用于接收数据报的DatagramPacket构建器是:
DatagramPacket(buf, buf.length)
其中,buf是一个字节数组。既然buf是个数组,大家可能会奇怪为什么构建器自己不能调查出数组的长度呢?实际上我也有同感,唯一能猜到的原因就是C风格的编程使然,那里的数组不能自己告诉我们它有多大。
可以重复使用数据报的接收代码,不必每次都建一个新的。每次用它的时候(再生),缓冲区内的数据都会被覆盖。
缓冲区的最大容量仅受限于允许的数据报包大小,这个限制位于比64KB稍小的地方。但在许多应用程序中,我们都宁愿它变得还要小一些,特别是在发送数据的时候。具体选择的数据包大小取决于应用程序的特定要求。
发出一个数据报时,DatagramPacket不仅需要包含正式的数据,也要包含因特网地址以及端口号,以决定它的目的地。所以用于输出DatagramPacket的构建器是:
DatagramPacket(buf, length, inetAddress, port)
这一次,buf(一个字节数组)已经包含了我们想发出的数据。length可以是buf的长度,但也可以更短一些,意味着我们只想发出那么多的字节。另两个参数分别代表数据包要到达的因特网地址以及目标机器的一个目标端口(注释②)。

②:我们认为TCP和UDP端口是相互独立的。也就是说,可以在端口8080同时运行一个TCP和UDP服务程序,两者之间不会产生冲突。

大家也许认为两个构建器创建了两个不同的对象:一个用于接收数据报,另一个用于发送它们。如果是好的面向对象的设计方案,会建议把它们创建成两个不同的类,而不是具有不同的行为的一个类(具体行为取决于我们如何构建对象)。这也许会成为一个严重的问题,但幸运的是,DatagramPacket的使用相当简单,我们不需要在这个问题上纠缠不清。这一点在下例里将有很明确的说明。该例类似于前面针对TCP套接字的MultiJabberServer和MultiJabberClient例子。多个客户都会将数据报发给服务器,后者会将其反馈回最初发出消息的同样的客户。
为简化从一个String里创建DatagramPacket的工作(或者从DatagramPacket里创建String),这个例子首先用到了一个工具类,名为Dgram:
//: Dgram.java
// A utility class to convert back and forth
// Between Strings and DataGramPackets.
import java.net.*;
 
publicclass Dgram {
 publicstatic DatagramPacket toDatagram(
    String s, InetAddress destIA, int destPort) {
    // Deprecated in Java 1.1, but it works:
    byte[] buf = newbyte[s.length() + 1];
    s.getBytes(0, s.length(), buf, 0);
    // The correct Java 1.1 approach, but it's
    // Broken (it truncates the String):
    // byte[] buf = s.getBytes();
    returnnew DatagramPacket(buf, buf.length,
      destIA, destPort);
 }
 publicstatic String toString(DatagramPacket p){
    // The Java 1.0 approach:
    // return new String(p.getData(),
    // 0, 0, p.getLength());
    // The Java 1.1 approach:
    return
      new String(p.getData(), 0, p.getLength());
 }
} ///:~

Dgram
的第一个方法采用一个String、一个InetAddress以及一个端口号作为自己的参数,将String的内容复制到一个字节缓冲区,再将缓冲区传递进入DatagramPacket构建器,从而构建一个DatagramPacket。注意缓冲区分配时的"+1"——这对防止截尾现象是非常重要的。String的getByte()方法属于一种特殊操作,能将一个字串包含的char复制进入一个字节缓冲。该方法现在已被“反对”使用;Java 1.1有一个“更好”的办法来做这个工作,但在这里却被当作注释屏蔽掉了,因为它会截掉String的部分内容。所以尽管我们在Java 1.1下编译该程序时会得到一条“反对”消息,但它的行为仍然是正确无误的(这个错误应该在你读到这里的时候修正了)。
Dgram.toString()方法同时展示了Java 1.0的方法和Java 1.1的方法(两者是不同的,因为有一种新类型的String构建器)。
下面是用于数据报演示的服务器代码:
//: ChatterServer.java
// A server that echoes datagrams
import java.net.*;
import java.io.*;
import java.util.*;
 
publicclass ChatterServer {
 staticfinalint INPORT = 1711;
 privatebyte[] buf = newbyte[1000];
 private DatagramPacket dp =
    new DatagramPacket(buf, buf.length);
 // Can listen & send on the same socket:
 private DatagramSocket socket;
 
 public ChatterServer() {
    try {
      socket = new DatagramSocket(INPORT);
      System.out.println("Server started");
      while(true) {
        // Block until a datagram appears:
        socket.receive(dp);
        String rcvd = Dgram.toString(dp) +
          ", from address: " + dp.getAddress() +
          ", port: " + dp.getPort();
        System.out.println(rcvd);
        String echoString =
          "Echoed: " + rcvd;
        // Extract the address and port from the
        // received datagram to find out where to
        // send it back:
        DatagramPacket echo =
          Dgram.toDatagram(echoString,
            dp.getAddress(), dp.getPort());
        socket.send(echo);
      }
    } catch(SocketException e) {
      System.err.println("Can't open socket");
      System.exit(1);
    } catch(IOException e) {
      System.err.println("Communication error");
      e.printStackTrace();
    }
 }
 publicstaticvoid main(String[] args) {
    new ChatterServer();
 }
} ///:~

ChatterServer
创建了一个用来接收消息的DatagramSocket(数据报套接字),而不是在我们每次准备接收一条新消息时都新建一个。这个单一的DatagramSocket可以重复使用。它有一个端口号,因为这属于服务器,客户必须确切知道自己把数据报发到哪个地址。尽管有一个端口号,但没有为它分配因特网地址,因为它就驻留在“这”台机器内,所以知道自己的因特网地址是什么(目前是默认的localhost)。在无限while循环中,套接字被告知接收数据(receive())。然后暂时挂起,直到一个数据报出现,再把它反馈回我们希望的接收人——DatagramPacket dp——里面。数据包(Packet)会被转换成一个字串,同时插入的还有数据包的起源因特网地址及套接字。这些信息会显示出来,然后添加一个额外的字串,指出自己已从服务器反馈回来了。
大家可能会觉得有点儿迷惑。正如大家会看到的那样,许多不同的因特网地址和端口号都可能是消息的起源地——换言之,客户程序可能驻留在任何一台机器里(就这一次演示来说,它们都驻留在localhost里,但每个客户使用的端口编号是不同的)。为了将一条消息送回它真正的始发客户,需要知道那个客户的因特网地址以及端口号。幸运的是,所有这些资料均已非常周到地封装到发出消息的DatagramPacket内部,所以我们要做的全部事情就是用getAddress()和getPort()把它们取出来。利用这些资料,可以构建DatagramPacket echo——它通过与接收用的相同的套接字发送回来。除此以外,一旦套接字发出数据报,就会添加“这”台机器的因特网地址及端口信息,所以当客户接收消息时,它可以利用getAddress()和getPort()了解数据报来自何处。事实上,getAddress()和getPort()唯一不能告诉我们数据报来自何处的前提是:我们创建一个待发送的数据报,并在正式发出之前调用了getAddress()和getPort()。到数据报正式发送的时候,这台机器的地址以及端口才会写入数据报。所以我们得到了运用数据报时一项重要的原则:不必跟踪一条消息的来源地!因为它肯定保存在数据报里。事实上,对程序来说,最可靠的做法是我们不要试图跟踪,而是无论如何都从目标数据报里提取出地址以及端口信息(就象这里做的那样)。
为测试服务器的运转是否正常,下面这程序将创建大量客户(线程),它们都会将数据报包发给服务器,并等候服务器把它们原样反馈回来。
//: ChatterServer.java
// A server that echoes datagrams
import java.net.*;
import java.io.*;
import java.util.*;
 
publicclass ChatterServer {
 staticfinalint INPORT = 1711;
 privatebyte[] buf = newbyte[1000];
 private DatagramPacket dp =
    new DatagramPacket(buf, buf.length);
 // Can listen & send on the same socket:
 private DatagramSocket socket;
 
 public ChatterServer() {
    try {
      socket = new DatagramSocket(INPORT);
      System.out.println("Server started");
      while(true) {
        // Block until a datagram appears:
        socket.receive(dp);
        String rcvd = Dgram.toString(dp) +
          ", from address: " + dp.getAddress() +
          ", port: " + dp.getPort();
        System.out.println(rcvd);
        String echoString =
          "Echoed: " + rcvd;
        // Extract the address and port from the
        // received datagram to find out where to
        // send it back:
        DatagramPacket echo =
          Dgram.toDatagram(echoString,
            dp.getAddress(), dp.getPort());
        socket.send(echo);
      }
    } catch(SocketException e) {
      System.err.println("Can't open socket");
      System.exit(1);
    } catch(IOException e) {
      System.err.println("Communication error");
      e.printStackTrace();
    }
 }
 publicstaticvoid main(String[] args) {
    new ChatterServer();
 }
} ///:~

ChatterClient
被创建成一个线程(Thread),所以可以用多个客户来“骚扰”服务器。从中可以看到,用于接收的DatagramPacket和用于ChatterServer的那个是相似的。在构建器中,创建DatagramPacket时没有附带任何参数(自变量),因为它不需要明确指出自己位于哪个特定编号的端口里。用于这个套接字的因特网地址将成为“这台机器”(比如localhost),而且会自动分配端口编号,这从输出结果即可看出。同用于服务器的那个一样,这个DatagramPacket将同时用于发送和接收。
hostAddress是我们想与之通信的那台机器的因特网地址。在程序中,如果需要创建一个准备传出去的DatagramPacket,那么必须知道一个准确的因特网地址和端口号。可以肯定的是,主机必须位于一个已知的地址和端口号上,使客户能启动与主机的“会话”。
每个线程都有自己独一无二的标识号(尽管自动分配给线程的端口号是也会提供一个唯一的标识符)。在run()中,我们创建了一个String消息,其中包含了线程的标识编号以及该线程准备发送的消息编号。我们用这个字串创建一个数据报,发到主机上的指定地址;端口编号则直接从ChatterServer内的一个常数取得。一旦消息发出,receive()就会暂时被“堵塞”起来,直到服务器回复了这条消息。与消息附在一起的所有信息使我们知道回到这个特定线程的东西正是从始发消息中投递出去的。在这个例子中,尽管是一种“不可靠”协议,但仍然能够检查数据报是否到去过了它们该去的地方(这在localhost和LAN环境中是成立的,但在非本地连接中却可能出现一些错误)。
运行该程序时,大家会发现每个线程都会结束。这意味着发送到服务器的每个数据报包都会回转,并反馈回正确的接收者。如果不是这样,一个或更多的线程就会挂起并进入“堵塞”状态,直到它们的输入被显露出来。
大家或许认为将文件从一台机器传到另一台的唯一正确方式是通过TCP套接字,因为它们是“可靠”的。然而,由于数据报的速度非常快,所以它才是一种更好的选择。我们只需将文件分割成多个数据报,并为每个包编号。接收机器会取得这些数据包,并重新“组装”它们;一个“标题包”会告诉机器应该接收多少个包,以及组装所需的另一些重要信息。如果一个包在半路“走丢”了,接收机器会返回一个数据报,告诉发送者重传。

15.5 一个Web应用
现在让我们想想如何创建一个应用,令其在真实的Web环境中运行,它将把Java的优势表现得淋漓尽致。这个应用的一部分是在Web服务器上运行的一个Java程序,另一部分则是一个“程序片”或“小应用程序”(Applet),从服务器下载至浏览器(即“客户”)。这个程序片从用户那里收集信息,并将其传回Web服务器上运行的应用程序。程序的任务非常简单:程序片会询问用户的E-mail地址,并在验证这个地址合格后(没有包含空格,而且有一个@符号),将该E-mail发送给Web服务器。服务器上运行的程序则会捕获传回的数据,检查一个包含了所有E-mail地址的数据文件。如果那个地址已包含在文件里,则向浏览器反馈一条消息,说明这一情况。该消息由程序片负责显示。若是一个新地址,则将其置入列表,并通知程序片已成功添加了电子函件地址。
若采用传统方式来解决这个问题,我们要创建一个包含了文本字段及一个“提交”(Submit)按钮的HTML页。用户可在文本字段里键入自己喜欢的任何内容,并毫无阻碍地提交给服务器(在客户端不进行任何检查)。提交数据的同时,Web页也会告诉服务器应对数据采取什么样的操作——知会“通用网关接口”(CGI)程序,收到这些数据后立即运行服务器。这种CGI程序通常是用Perl或C写的(有时也用C++,但要求服务器支持),而且必须能控制一切可能出现的情况。它首先会检查数据,判断是否采用了正确的格式。若答案是否定的,则CGI程序必须创建一个HTML页,对遇到的问题进行描述。这个页会转交给服务器,再由服务器反馈回用户。用户看到出错提示后,必须再试一遍提交,直到通过为止。若数据正确,CGI程序会打开数据文件,要么把电子函件地址加入文件,要么指出该地址已在数据文件里了。无论哪种情况,都必须格式化一个恰当的HTML页,以便服务器返回给用户。
作为Java程序员,上述解决问题的方法显得非常笨拙。而且很自然地,我们希望一切工作都用Java完成。首先,我们会用一个Java程序片负责客户端的数据有效性校验,避免数据在服务器和客户之间传来传去,浪费时间和带宽,同时减轻服务器额外构建HTML页的负担。然后跳过Perl CGI脚本,换成在服务器上运行一个Java应用。事实上,我们在这儿已完全跳过了Web服务器,仅仅需要从程序片到服务器上运行的Java应用之间建立一个连接即可。
正如大家不久就会体验到的那样,尽管看起来非常简单,但实际上有一些意想不到的问题使局面显得稍微有些复杂。用Java 1.1写程序片是最理想的,但实际上却经常行不通。到本书写作的时候,拥有Java 1.1能力的浏览器仍为数不多,而且即使这类浏览器现在非常流行,仍需考虑照顾一下那些升级缓慢的人。所以从安全的角度看,程序片代码最好只用Java 1.0编写。基于这一前提,我们不能用JAR文件来合并(压缩)程序片中的.class文件。所以,我们应尽可能减少.class文件的使用数量,以缩短下载时间。
好了,再来说说我用的Web服务器(写这个示范程序时用的就是它)。它确实支持Java,但仅限于Java 1.0!所以服务器应用也必须用Java 1.0编写。

15.5.1 服务器应用
现在讨论一下服务器应用(程序)的问题,我把它叫作NameCollecor(名字收集器)。假如多名用户同时尝试提交他们的E-mail地址,那么会发生什么情况呢?若NameCollector使用TCP/IP套接字,那么必须运用早先介绍的多线程机制来实现对多个客户的并发控制。但所有这些线程都试图把数据写到同一个文件里,其中保存了所有E-mail地址。这便要求我们设立一种锁定机制,保证多个线程不会同时访问那个文件。一个“信号机”可在这里帮助我们达到目的,但或许还有一种更简单的方式。
如果我们换用数据报,就不必使用多线程了。用单个数据报即可“侦听”进入的所有数据报。一旦监视到有进入的消息,程序就会进行适当的处理,并将答复数据作为一个数据报传回原先发出请求的那名接收者。若数据报半路上丢失了,则用户会注意到没有答复数据传回,所以可以重新提交请求。
服务器应用收到一个数据报,并对它进行解读的时候,必须提取出其中的电子函件地址,并检查本机保存的数据文件,看看里面是否已经包含了那个地址(如果没有,则添加之)。所以我们现在遇到了一个新的问题。Java 1.0似乎没有足够的能力来方便地处理包含了电子函件地址的文件(Java 1.1则不然)。但是,用C轻易就可以解决这个问题。因此,我们在这儿有机会学习将一个非Java程序同Java程序连接的最简便方式。程序使用的Runtime对象包含了一个名为exec()的方法,它会独立机器上一个独立的程序,并返回一个Process(进程)对象。我们可以取得一个OutputStream,它同这个单独程序的标准输入连接在一起;并取得一个InputStream,它则同标准输出连接到一起。要做的全部事情就是用任何语言写一个程序,只要它能从标准输入中取得自己的输入数据,并将输出结果写入标准输出即可。如果有些问题不能用Java简便与快速地解决(或者想利用原有代码,不想改写),就可以考虑采用这种方法。亦可使用Java的“固有方法”(Native Method),但那要求更多的技巧,大家可以参考一下附录A。

1. C程序
这个非Java应用是用C写成,因为Java不适合作CGI编程;起码启动的时间不能让人满意。它的任务是管理电子函件(E-mail)地址的一个列表。标准输入会接受一个E-mail地址,程序会检查列表中的名字,判断是否存在那个地址。若不存在,就将其加入,并报告操作成功。但假如名字已在列表里了,就需要指出这一点,避免重复加入。大家不必担心自己不能完全理解下列代码的含义。它仅仅是一个演示程序,告诉你如何用其他语言写一个程序,并从Java中调用它。在这里具体采用何种语言并不重要,只要能够从标准输入中读取数据,并能写入标准输出即可。
//: Listmgr.c
// Used by NameCollector.java to manage
// the email list file on the server
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BSIZE 250
 
int alreadyInList(FILE* list, char* name) {
 char lbuf[BSIZE];
 // Go to the beginning of the list:
 fseek(list, 0, SEEK_SET);
 // Read each line in the list:
 while(fgets(lbuf, BSIZE, list)) {
    // Strip off the newline:
    char * newline = strchr(lbuf, '/n');
    if(newline != 0)
      *newline = '/0';
    if(strcmp(lbuf, name) == 0)
      return 1;
 }
 return 0;
}
 
int main() {
 char buf[BSIZE];
 FILE* list = fopen("emlist.txt", "a+t");
 if(list == 0) {
    perror("could not open emlist.txt");
    exit(1);
 }
 while(1) {
    gets(buf); /* From stdin */
    if(alreadyInList(list, buf)) {
      printf("Already in list: %s", buf);
      fflush(stdout);
    }
    else {
      fseek(list, 0, SEEK_END);
      fprintf(list, "%s/n", buf);
      fflush(list);
      printf("%s added to list", buf);
      fflush(stdout);
    }
 }
} ///:~

该程序假设C编译器能接受'//'样式注释(许多编译器都能,亦可换用一个C++编译器来编译这个程序)。如果你的编译器不能接受,则简单地将那些注释删掉即可。
文件中的第一个函数检查我们作为第二个参数(指向一个char的指针)传递给它的名字是否已在文件中。在这儿,我们将文件作为一个FILE指针传递,它指向一个已打开的文件(文件是在main()中打开的)。函数fseek()在文件中遍历;我们在这儿用它移至文件开头。fgets()从文件list中读入一行内容,并将其置入缓冲区lbuf——不会超过规定的缓冲区长度BSIZE。所有这些工作都在一个while循环中进行,所以文件中的每一行都会读入。接下来,用strchr()找到新行字符,以便将其删掉。最后,用strcmp()比较我们传递给函数的名字与文件中的当前行。若找到一致的内容,strcmp()会返回0。函数随后会退出,并返回一个1,指出该名字已经在文件里了(注意这个函数找到相符内容后会立即返回,不会把时间浪费在检查列表剩余内容的上面)。如果找遍列表都没有发现相符的内容,则函数返回0。
在main()中,我们用fopen()打开文件。第一个参数是文件名,第二个是打开文件的方式;a+表示“追加”,以及“打开”(或“创建”,假若文件尚不存在),以便到文件的末尾进行更新。fopen()函数返回的是一个FILE指针;若为0,表示打开操作失败。此时需要用perror()打印一条出错提示消息,并用exit()中止程序运行。
如果文件成功打开,程序就会进入一个无限循环。调用gets(buf)的函数会从标准输入中取出一行(记住标准输入会与Java程序连接到一起),并将其置入缓冲区buf中。缓冲区的内容随后会简单地传递给alreadyInList()函数,如内容已在列表中,printf()就会将那条消息发给标准输出(Java程序正在监视它)。fflush()用于对输出缓冲区进行刷新。
如果名字不在列表中,就用fseek()移到列表末尾,并用fprintf()将名字“打印”到列表末尾。随后,用printf()指出名字已成功加入列表(同样需要刷新标准输出),无限循环返回,继续等候一个新名字的进入。
记住一般不能先在自己的计算机上编译此程序,再把编译好的内容上载到Web服务器,因为那台机器使用的可能是不同类的处理器和操作系统。例如,我的Web服务器安装的是Intel的CPU,但操作系统是Linux,所以必须先下载源码,再用远程命令(通过telnet)指挥Linux自带的C编译器,令其在服务器端编译好程序。

2. Java程序
这个程序先启动上述的C程序,再建立必要的连接,以便同它“交谈”。随后,它创建一个数据报套接字,用它“监视”或者“侦听”来自程序片的数据报包。
//: NameCollector.java
// Extracts email names from datagrams and stores
// them inside a file, using Java 1.02.
import java.net.*;
import java.io.*;
import java.util.*;
 
publicclass NameCollector {
 finalstaticint COLLECTOR_PORT = 8080;
 finalstaticint BUFFER_SIZE = 1000;
 byte[] buf = newbyte[BUFFER_SIZE];
 DatagramPacket dp =
    new DatagramPacket(buf, buf.length);
 // Can listen & send on the same socket:
 DatagramSocket socket;
 Process listmgr;
 PrintStream nameList;
 DataInputStream addResult;
 public NameCollector() {
    try {
      listmgr =
        Runtime.getRuntime().exec("listmgr.exe");
      nameList = new PrintStream(
        new BufferedOutputStream(
          listmgr.getOutputStream()));
      addResult = new DataInputStream(
        new BufferedInputStream(
          listmgr.getInputStream()));
 
    } catch(IOException e) {
      System.err.println(
        "Cannot start listmgr.exe");
      System.exit(1);
    }
    try {
      socket =
        new DatagramSocket(COLLECTOR_PORT);
      System.out.println(
        "NameCollector Server started");
      while(true) {
        // Block until a datagram appears:
        socket.receive(dp);
        String rcvd = new String(dp.getData(),
            0, 0, dp.getLength());
        // Send to listmgr.exe standard input:
        nameList.println(rcvd.trim());
        nameList.flush();
        byte[] resultBuf = newbyte[BUFFER_SIZE];
        int byteCount =
          addResult.read(resultBuf);
        if(byteCount != -1) {
          String result =
            new String(resultBuf, 0).trim();
          // Extract the address and port from
          // the received datagram to find out
          // where to send the reply:
          InetAddress senderAddress =
            dp.getAddress();
          int senderPort = dp.getPort();
          byte[] echoBuf = newbyte[BUFFER_SIZE];
          result.getBytes(
            0, byteCount, echoBuf, 0);
          DatagramPacket echo =
            new DatagramPacket(
              echoBuf, echoBuf.length,
              senderAddress, senderPort);
          socket.send(echo);
        }
        else
          System.out.println(
            "Unexpected lack of result from " +
            "listmgr.exe");
      }
    } catch(SocketException e) {
      System.err.println("Can't open socket");
      System.exit(1);
    } catch(IOException e) {
      System.err.println("Communication error");
      e.printStackTrace();
    }
 }
 publicstaticvoid main(String[] args) {
    new NameCollector();
 }
} ///:~

NameCollector
中的第一个定义应该是大家所熟悉的:选定端口,创建一个数据报包,然后创建指向一个DatagramSocket的句柄。接下来的三个定义负责与C程序的连接:一个Process对象是C程序由Java程序启动之后返回的,而且那个Process对象产生了InputStream和OutputStream,分别代表C程序的标准输出和标准输入。和Java IO一样,它们理所当然地需要“封装”起来,所以我们最后得到的是一个PrintStream和DataInputStream。
这个程序的所有工作都是在构建器内进行的。为启动C程序,需要取得当前的Runtime对象。我们用它调用exec(),再由后者返回Process对象。在Process对象中,大家可看到通过一简单的调用即可生成数据流:getOutputStream()和getInputStream()。从这个时候开始,我们需要考虑的全部事情就是将数据传给数据流nameList,并从addResult中取得结果。
和往常一样,我们将DatagramSocket同一个端口连接到一起。在无限while循环中,程序会调用receive()——除非一个数据报到来,否则receive()会一起处于“堵塞”状态。数据报出现以后,它的内容会提取到String rcvd里。我们首先将该字串两头的空格剔除(trim),再将其发给C程序。如下所示:
nameList.println(rcvd.trim());
之所以能这样编码,是因为Java的exec()允许我们访问任何可执行模块,只要它能从标准输入中读,并能向标准输出中写。还有另一些方式可与非Java代码“交谈”,这将在附录A中讨论。
从C程序中捕获结果就显得稍微麻烦一些。我们必须调用read(),并提供一个缓冲区,以便保存结果。read()的返回值是来自C程序的字节数。若这个值为-1,意味着某个地方出现了问题。否则,我们就将resultBuf(结果缓冲区)转换成一个字串,然后同样清除多余的空格。随后,这个字串会象往常一样进入一个DatagramPacket,并传回当初发出请求的那个同样的地址。注意发送方的地址也是我们接收到的DatagramPacket的一部分。
记住尽管C程序必须在Web服务器上编译,但Java程序的编译场所可以是任意的。这是由于不管使用的是什么硬件平台和操作系统,编译得到的字节码都是一样的。就就是Java的“跨平台”兼容能力。

15.5.2 NameSender程序片
正如早先指出的那样,程序片必须用Java 1.0编写,使其能与绝大多数的浏览器适应。也正是由于这个原因,我们产生的类数量应尽可能地少。所以我们在这儿不考虑使用前面设计好的Dgram类,而将数据报的所有维护工作都转到代码行中进行。此外,程序片要用一个线程监视由服务器传回的响应信息,而非实现Runnable接口,用集成到程序片的一个独立线程来做这件事情。当然,这样做对代码的可读性不利,但却能产生一个单类(以及单个服务器请求)程序片:
//: NameSender.java
// An applet that sends an email address
// as a datagram, using Java 1.02.
import java.awt.*;
import java.applet.*;
import java.net.*;
import java.io.*;
 
publicclass NameSender extends Applet
    implements Runnable {
 private Thread pl = null;
 private Button send = new Button(
    "Add email address to mailing list");
 private TextField t = new TextField(
    "type your email address here", 40);
 private String str = new String();
 private Label
    l = new Label(), l2 = new Label();
 private DatagramSocket s;
 private InetAddress hostAddress;
 privatebyte[] buf =
    newbyte[NameCollector.BUFFER_SIZE];
 private DatagramPacket dp =
    new DatagramPacket(buf, buf.length);
 privateint vcount = 0;
 publicvoid init() {
    setLayout(new BorderLayout());
    Panel p = new Panel();
    p.setLayout(new GridLayout(2, 1));
    p.add(t);
    p.add(send);
    add("North", p);
    Panel labels = new Panel();
    labels.setLayout(new GridLayout(2, 1));
    labels.add(l);
    labels.add(l2);
    add("Center", labels);
    try {
      // Auto-assign port number:
      s = new DatagramSocket();
      hostAddress = InetAddress.getByName(
        getCodeBase().getHost());
    } catch(UnknownHostException e) {
      l.setText("Cannot find host");
    } catch(SocketException e) {
      l.setText("Can't open socket");
    }
    l.setText("Ready to send your email address");
 }
 publicboolean action (Event evt, Object arg) {
    if(evt.target.equals(send)) {
      if(pl != null) {
        // pl.stop(); Deprecated in Java 1.2
        Thread remove = pl;
        pl = null;
        remove.interrupt();
      }
      l2.setText("");
      // Check for errors in email name:
      str = t.getText().toLowerCase().trim();
      if(str.indexOf(' ') != -1) {
        l.setText("Spaces not allowed in name");
        returntrue;
      }
      if(str.indexOf(',') != -1) {
        l.setText("Commas not allowed in name");
        returntrue;
      }
      if(str.indexOf('@') == -1) {
        l.setText("Name must include '@'");
        l2.setText("");
        returntrue;
      }
      if(str.indexOf('@') == 0) {
        l.setText("Name must preceed '@'");
        l2.setText("");
        returntrue;
      }
      String end =
        str.substring(str.indexOf('@'));
      if(end.indexOf('.') == -1) {
        l.setText("Portion after '@' must " +
          "have an extension, such as '.com'");
        l2.setText("");
        returntrue;
      }
      // Everything's OK, so send the name. Get a
      // fresh buffer, so it's zeroed. For some
      // reason you must use a fixed size rather
      // than calculating the size dynamically:
      byte[] sbuf =
        newbyte[NameCollector.BUFFER_SIZE];
      str.getBytes(0, str.length(), sbuf, 0);
      DatagramPacket toSend =
        new DatagramPacket(
          sbuf, 100, hostAddress,
          NameCollector.COLLECTOR_PORT);
      try {
        s.send(toSend);
      } catch(Exception e) {
        l.setText("Couldn't send datagram");
        returntrue;
      }
      l.setText("Sent: " + str);
      send.setLabel("Re-send");
      pl = new Thread(this);
      pl.start();
      l2.setText(
        "Waiting for verification " + ++vcount);
    }
    elsereturnsuper.action(evt, arg);
    returntrue;
 }
 // The thread portion of the applet watches for
 // the reply to come back from the server:
 publicvoid run() {
    try {
      s.receive(dp);
    } catch(Exception e) {
      l2.setText("Couldn't receive datagram");
      return;
    }
    l2.setText(new String(dp.getData(),
      0, 0, dp.getLength()));
 }
} ///:~

程序片的UI(用户界面)非常简单。它包含了一个TestField(文本字段),以便我们键入一个电子函件地址;以及一个Button(按钮),用于将地址发给服务器。两个Label(标签)用于向用户报告状态信息。
到现在为止,大家已能判断出DatagramSocket、InetAddress、缓冲区以及DatagramPacket都属于网络连接中比较麻烦的部分。最后,大家可看到run()方法实现了线程部分,使程序片能够“侦听”由服务器传回的响应信息。
init()方法用大家熟悉的布局工具设置GUI,然后创建DatagramSocket,它将同时用于数据报的收发。
action()方法只负责监视我们是否按下了“发送”(send)按钮。记住,我们已被限制在Java 1.0上面,所以不能再用较灵活的内部类了。按钮按下以后,采取的第一项行动便是检查线程pl,看看它是否为null(空)。如果不为null,表明有一个活动线程正在运行。消息首次发出时,会启动一个新线程,用它监视来自服务器的回应。所以假若有个线程正在运行,就意味着这并非用户第一次发送消息。pl句柄被设为null,同时中止原来的监视者(这是最合理的一种做法,因为stop()已被Java 1.2“反对”,这在前一章已解释过了)。
无论这是否按钮被第一次按下,I2中的文字都会清除。
下一组语句将检查E-mail名字是否合格。String.indexOf()方法的作用是搜索其中的非法字符。如果找到一个,就把情况报告给用户。注意进行所有这些工作时,都不必涉及网络通信,所以速度非常快,而且不会影响带宽和服务器的性能。
名字校验通过以后,它会打包到一个数据报里,然后采用与前面那个数据报示例一样的方式发到主机地址和端口编号。第一个标签会发生变化,指出已成功发送出去。而且按钮上的文字也会改变,变成“重发”(resend)。这时会启动线程,第二个标签则会告诉我们程序片正在等候来自服务器的回应。
线程的run()方法会利用NameSender中包含的DatagramSocket来接收数据(receive()),除非出现来自服务器的数据报包,否则receive()会暂时处于“堵塞”或者“暂停”状态。结果得到的数据包会放进NameSender的DatagramPacketdp中。数据会从包中提取出来,并置入NameSender的第二个标签。随后,线程的执行将中断,成为一个“死”线程。若某段时间里没有收到来自服务器的回应,用户可能变得不耐烦,再次按下按钮。这样做会中断当前线程(数据发出以后,会再建一个新的)。由于用一个线程来监视回应数据,所以用户在监视期间仍然可以自由使用UI。

1. Web页
当然,程序片必须放到一个Web页里。下面列出完整的Web页源码;稍微研究一下就可看出,我用它从自己开办的邮寄列表(Mailling List)里自动收集名字。
<HTML>
<HEAD>
<META CONTENT="text/html">
<TITLE>
Add Yourself to Bruce Eckel's Java Mailing List
</TITLE>
</HEAD>
<BODY LINK="#0000ff" VLINK="#800080" BGCOLOR="#ffffff">
<FONT SIZE=6><P>
Add Yourself to Bruce Eckel's Java Mailing List
</P></FONT>
The applet on this page will automatically add your email address to the mailing list, so you will receive update information about changes to the online version of "Thinking in Java," notification when the book is in print, information about upcoming Java seminars, and notification about the “Hands-on Java Seminar” Multimedia CD. Type in your email address and press the button to automatically add yourself to this mailing list. <HR>
<applet code=NameSender width=400 height=100>
</applet>
<HR>
If after several tries, you do not get verification it means that the Java application on the server is having problems. In thiscase, you can add yourself to the list by sending email to
<A HREF="mailto:Bruce@EckelObjects.com">
Bruce@EckelObjects.com</A>
</BODY>
</HTML>

程序片标记(<applet>)的使用非常简单,和第13章展示的那一个并没有什么区别。

15.5.3 要注意的问题
前面采取的似乎是一种完美的方法。没有CGI编程,所以在服务器启动一个CGI程序时不会出现延迟。数据报方式似乎能产生非常快的响应。此外,一旦Java 1.1得到绝大多数人的采纳,服务器端的那一部分就可完全用Java编写(尽管利用标准输入和输出同一个非Java程序连接也非常容易)。
但必须注意到一些问题。其中一个特别容易忽略:由于Java应用在服务器上是连续运行的,而且会把大多数时间花在Datagram.receive()方法的等候上面,这样便为CPU带来了额外的开销。至少,我在自己的服务器上便发现了这个问题。另一方面,那个服务器上不会发生其他更多的事情。而且假如我们使用一个任务更为繁重的服务器,启动程序用“nice”(一个Unix程序,用于防止进程贪吃CPU资源)或其他等价程序即可解决问题。在许多情况下,都有必要留意象这样的一些应用——一个堵塞的receive()完全可能造成CPU的瘫痪。
第二个问题涉及防火墙。可将防火墙理解成自己的本地网与因特网之间的一道墙(实际是一个专用机器或防火墙软件)。它监视进出因特网的所有通信,确保这些通信不违背预设的规则。
防火墙显得多少有些保守,要求严格遵守所有规则。假如没有遵守,它们会无情地把它们拒之门外。例如,假设我们位于防火墙后面的一个网络中,开始用Web浏览器同因特网连接,防火墙要求所有传输都用可以接受的http端口同服务器连接,这个端口是80。现在来了这个Java程序片NameSender,它试图将一个数据报传到端口8080,这是为了越过“受保护”的端口范围0-1024而设置的。防火墙很自然地把它想象成最坏的情况——有人使用病毒或者非法扫描端口——根本不允许传输的继续进行。
只要我们的客户建立的是与因特网的原始连接(比如通过典型的ISP接驳Internet),就不会出现此类防火墙问题。但也可能有一些重要的客户隐藏在防火墙后,他们便不能使用我们设计的程序。
在学过有关Java的这么多东西以后,这是一件使人相当沮丧的事情,因为看来必须放弃在服务器上使用Java,改为学习如何编写C或Perl脚本程序。但请大家不要绝望。
一个出色方案是由Sun公司提出的。如一切按计划进行,Web服务器最终都装备“小服务程序”或者“服务程序片”(Servlet)。它们负责接收来自客户的请求(经过防火墙允许的80端口)。而且不再是启动一个CGI程序,它们会启动小服务程序。根据Sun的设想,这些小服务程序都是用Java编写的,而且只能在服务器上运行。运行这种小程序的服务器会自动启动它们,令其对客户的请求进行处理。这意味着我们的所有程序都可以用Java写成(100%纯咖啡)。这显然是一种非常吸引人的想法:一旦习惯了Java,就不必换用其他语言在服务器上处理客户请求。
由于只能在服务器上控制请求,所以小服务程序API没有提供GUI功能。这对NameCollector.java来说非常适合,它本来就不需要任何图形界面。
在本书写作时,java.sun.com已提供了一个非常廉价的小服务程序专用服务器。Sun鼓励其他Web服务器开发者为他们的服务器软件产品加入对小服务程序的支持。

15.6 Java与CGI的沟通
Java程序可向一个服务器发出一个CGI请求,这与HTML表单页没什么两样。而且和HTML页一样,这个请求既可以设为GET(下载),亦可设为POST(上传)。除此以外,Java程序还可拦截CGI程序的输出,所以不必依赖程序来格式化一个新页,也不必在出错的时候强迫用户从一个页回转到另一个页。事实上,程序的外观可以做得跟以前的版本别无二致。
代码也要简单一些,毕竟用CGI也不是很难就能写出来(前提是真正地理解它)。所以在这一节里,我们准备办个CGI编程速成班。为解决常规问题,将用C++创建一些CGI工具,以便我们编写一个能解决所有问题的CGI程序。这样做的好处是移植能力特别强——即将看到的例子能在支持CGI的任何系统上运行,而且不存在防火墙的问题。
这个例子也阐示了如何在程序片(Applet)和CGI程序之间建立连接,以便将其方便地改编到自己的项目中。

15.6.1 CGI数据的编码
在这个版本中,我们将收集名字和电子函件地址,并用下述形式将其保存到文件中:
First Last <email@domain.com>;
这对任何E-mail程序来说都是一种非常方便的格式。由于只需收集两个字段,而且CGI为字段中的编码采用了一种特殊的格式,所以这里没有简便的方法。如果自己动手编制一个原始的HTML页,并加入下述代码行,即可正确地理解这一点:
<Form method="GET" ACTION="/cgi-bin/Listmgr2.exe">
<P>Name: <INPUT TYPE = "text" NAME = "name"
VALUE = "" size = "40"></p>
<P>Email Address: <INPUT TYPE = "text"
NAME = "email" VALUE = "" size = "40"></p>
<p><input type = "submit" name = "submit" > </p>
</Form>

上述代码创建了两个数据输入字段(区),名为name和email。另外还有一个submit(提交)按钮,用于收集数据,并将其发给CGI程序。Listmgr2.exe是驻留在特殊程序目录中的一个可执行文件。在我们的Web服务器上,该目录一般都叫作“cgi-bin”(注释③)。如果在那个目录里找不到该程序,结果就无法出现。填好这个表单,然后按下提交按钮,即可在浏览器的URL地址窗口里看到象下面这样的内容:
http://www.myhome.com/cgi-bin/Listmgr2.exe?name=First+Last&email=email@domain.com&submit=Submit

③:在Windows32平台下,可利用与Microsoft Office 97或其他产品配套提供的Microsoft Personal Web Server(微软个人Web服务器)进行测试。这是进行试验的最好方法,因为不必正式连入网络,可在本地环境中完成测试(速度也非常快)。如果使用的是不同的平台,或者没有Office 97或者FrontPage 98那样的产品,可到网上找一个免费的Web服务器供自己测试。

当然,上述URL实际显示时是不会拆行的。从中可稍微看出如何对数据编码并传给CGI。至少有一件事情能够肯定——空格是不允许的(因为它通常用于分隔命令行参数)。所有必需的空格都用“+”号替代,每个字段都包含了字段名(具体由HTML页决定),后面跟随一个“=”号以及正式的字段数据,最后用一个“&”结束。
到这时,大家也许会对“+”,“=”以及“&”的使用产生疑惑。假如必须在字段里使用这些字符,那么该如何声明呢?例如,我们可能使用“John & MarshaSmith”这个名字,其中的“&”代表“And”。事实上,它会编码成下面这个样子:
John+%26+Marsha+Smith
也就是说,特殊字符会转换成一个“%”,并在后面跟上它的十六进制ASCII编码。
幸运的是,Java有一个工具来帮助我们进行这种编码。这是URLEncoder类的一个静态方法,名为encode()。可用下述程序来试验这个方法:
//: EncodeDemo.java
// Demonstration of URLEncoder.encode()
import java.net.*;
 
publicclass EncodeDemo {
 publicstaticvoid main(String[] args) {
    String s = "";
    for(int i = 0; i < args.length; i++)
      s += args[i] + " ";
    s = URLEncoder.encode(s.trim());
    System.out.println(s);
 }
} ///:~

该程序将获取一些命令行参数,把它们合并成一个由多个词构成的字串,各词之间用空格分隔(最后一个空格用String.trim()剔除了)。随后对它们进行编码,并打印出来。
为调用一个CGI程序,程序片要做的全部事情就是从自己的字段或其他地方收集数据,将所有数据都编码成正确的URL样式,然后汇编到单独一个字串里。每个字段名后面都加上一个“=”符号,紧跟正式数据,再紧跟一个“&”。为构建完整的CGI命令,我们将这个字串置于CGI程序的URL以及一个“?”后。这是调用所有CGI程序的标准方法。大家马上就会看到,用一个程序片能够很轻松地完成所有这些编码与合并。

15.6.2 程序片
程序片实际要比NameSender.java简单一些。这部分是由于很容易即可发出一个GET请求。此外,也不必等候回复信息。现在有两个字段,而非一个,但大家会发现许多程序片都是熟悉的,请比较NameSender.java。
//: NameSender2.java
// An applet that sends an email address
// via a CGI GET, using Java 1.02.
import java.awt.*;
import java.applet.*;
import java.net.*;
import java.io.*;
 
publicclass NameSender2 extends Applet {
 final String CGIProgram = "Listmgr2.exe";
 Button send = new Button(
    "Add email address to mailing list");
 TextField name = new TextField(
    "type your name here", 40),
    email = new TextField(
    "type your email address here", 40);
 String str = new String();
 Label l = new Label(), l2 = new Label();
 int vcount = 0;
 publicvoid init() {
    setLayout(new BorderLayout());
    Panel p = new Panel();
    p.setLayout(new GridLayout(3, 1));
    p.add(name);
    p.add(email);
    p.add(send);
    add("North", p);
    Panel labels = new Panel();
    labels.setLayout(new GridLayout(2, 1));
    labels.add(l);
    labels.add(l2);
    add("Center", labels);
    l.setText("Ready to send email address");
 }
 publicboolean action (Event evt, Object arg) {
    if(evt.target.equals(send)) {
      l2.setText("");
      // Check for errors in data:
      if(name.getText().trim()
         .indexOf(' ') == -1) {
        l.setText(
          "Please give first and last name");
        l2.setText("");
        returntrue;
      }
      str = email.getText().trim();
      if(str.indexOf(' ') != -1) {
        l.setText(
          "Spaces not allowed in email name");
        l2.setText("");
        returntrue;
      }
      if(str.indexOf(',') != -1) {
        l.setText(
          "Commas not allowed in email name");
        returntrue;
      }
      if(str.indexOf('@') == -1) {
        l.setText("Email name must include '@'");
        l2.setText("");
        returntrue;
      }
      if(str.indexOf('@') == 0) {
        l.setText(
          "Name must preceed '@' in email name");
        l2.setText("");
        returntrue;
      }
      String end =
        str.substring(str.indexOf('@'));
      if(end.indexOf('.') == -1) {
        l.setText("Portion after '@' must " +
          "have an extension, such as '.com'");
        l2.setText("");
        returntrue;
      }
      // Build and encode the email data:
      String emailData =
        "name=" + URLEncoder.encode(
          name.getText().trim()) +
        "&email=" + URLEncoder.encode(
          email.getText().trim().toLowerCase()) +
        "&submit=Submit";
      // Send the name using CGI's GET process:
      try {
        l.setText("Sending...");
        URL u = new URL(
          getDocumentBase(), "cgi-bin/" +
          CGIProgram + "?" + emailData);
        l.setText("Sent: " + email.getText());
        send.setLabel("Re-send");
        l2.setText(
          "Waiting for reply " + ++vcount);
        DataInputStream server =
          new DataInputStream(u.openStream());
        String line;
        while((line = server.readLine()) != null)
          l2.setText(line);
      } catch(MalformedURLException e) {
        l.setText("Bad URl");
      } catch(IOException e) {
        l.setText("IO Exception");
      }
    }
    elsereturnsuper.action(evt, arg);
    returntrue;
 }
} ///:~

CGI
程序(不久即可看到)的名字是Listmgr2.exe。许多Web服务器都在Unix机器上运行(Linux也越来越受到青睐)。根据传统,它们一般不为自己的可执行程序采用.exe扩展名。但在Unix操作系统中,可以把自己的程序称呼为自己希望的任何东西。若使用的是.exe扩展名,程序毋需任何修改即可通过Unix和Win32的运行测试。
和往常一样,程序片设置了自己的用户界面(这次是两个输入字段,不是一个)。唯一显著的区别是在action()方法内产生的。该方法的作用是对按钮按下事件进行控制。名字检查过以后,大家会发现下述代码行:
      String emailData =
        "name=" + URLEncoder.encode(
          name.getText().trim()) +
        "&email=" + URLEncoder.encode(
          email.getText().trim().toLowerCase()) +
        "&submit=Submit";
      // Send the name using CGI's GET process:
      try {
        l.setText("Sending...");
        URL u = new URL(
          getDocumentBase(), "cgi-bin/" +
          CGIProgram + "?" + emailData);
        l.setText("Sent: " + email.getText());
        send.setLabel("Re-send");
        l2.setText(
          "Waiting for reply " + ++vcount);
        DataInputStream server =
          new DataInputStream(u.openStream());
        String line;
        while((line = server.readLine()) != null)
          l2.setText(line);
        // ...

name
和email数据都是它们对应的文字框里提取出来,而且两端多余的空格都用trim()剔去了。为了进入列表,email名字被强制换成小写形式,以便能够准确地对比(防止基于大小写形式的错误判断)。来自每个字段的数据都编码为URL形式,随后采用与HTML页中一样的方式汇编GET字串(这样一来,我们可将Java程序片与现有的任何CGI程序结合使用,以满足常规的HTML GET请求)。
到这时,一些Java的魔力已经开始发挥作用了:如果想同任何URL连接,只需创建一个URL对象,并将地址传递给构建器即可。构建器会负责建立同服务器的连接(对Web服务器来说,所有连接行动都是根据作为URL使用的字串来判断的)。就目前这种情况来说,URL指向的是当前Web站点的cgi-bin目录(当前Web站点的基础地址是用getDocumentBase()设定的)。一旦Web服务器在URL中看到了一个“cgi-bin”,会接着希望在它后面跟随了cgi-bin目录内的某个程序的名字,那是我们要运行的目标程序。程序名后面是一个问号以及CGI程序会在QUERY_STRING环境变量中查找的一个参数字串(马上就要学到)。
我们发出任何形式的请求后,一般都会得到一个回应的HTML页。但若使用Java的URL对象,我们可以拦截自CGI程序传回的任何东西,只需从URL对象里取得一个InputStream(输入数据流)即可。这是用URL对象的openStream()方法实现,它要封装到一个DataInputStream里。随后就可以读取数据行,若readLine()返回一个null(空值),就表明CGI程序已结束了它的输出。
我们即将看到的CGI程序返回的仅仅是一行,它是用于标志成功与否(以及失败的具体原因)的一个字串。这一行会被捕获并置放第二个Label字段里,使用户看到具体发生了什么事情。

1. 从程序片里显示一个Web页
程序亦可将CGI程序的结果作为一个Web页显示出来,就象它们在普通HTML模式中运行那样。可用下述代码做到这一点:
getAppletContext().showDocument(u);
其中,u代表URL对象。这是将我们重新定向于另一个Web页的一个简单例子。那个页凑巧是一个CGI程序的输出,但可以非常方便地进入一个原始的HTML页,所以可以构建这个程序片,令其产生一个由密码保护的网关,通过它进入自己Web站点的特殊部分:
//: ShowHTML.java
import java.awt.*;
import java.applet.*;
import java.net.*;
import java.io.*;
 
publicclass ShowHTML extends Applet {
 staticfinal String CGIProgram = "MyCGIProgram";
 Button send = new Button("Go");
 Label l = new Label();
 publicvoid init() {
    add(send);
    add(l);
 }
 publicboolean action (Event evt, Object arg) {
    if(evt.target.equals(send)) {
      try {
        // This could be an HTML page instead of
        // a CGI program. Notice that this CGI
        // program doesn't use arguments, but
        // you can add them in the usual way.
        URL u = new URL(
          getDocumentBase(),
          "cgi-bin/" + CGIProgram);
        // Display the output of the URL using
        // the Web browser, as an ordinary page:
        getAppletContext().showDocument(u);
      } catch(Exception e) {
        l.setText(e.toString());
      }
    }
    elsereturnsuper.action(evt, arg);
    returntrue;
 }
} ///:~

URL
类的最大的特点就是有效地保护了我们的安全。可以同一个Web服务器建立连接,毋需知道幕后的任何东西。

15.6.3 用C++写的CGI程序
经过前面的学习,大家应该能够根据例子用ANSI C为自己的服务器写出CGI程序。之所以选用ANSI C,是因为它几乎随处可见,是最流行的C语言标准。当然,现在的C++也非常流行了,特别是采用GNU C++编译器(g++)形式的那一些(注释④)。可从网上许多地方免费下载g++,而且可选用几乎所有平台的版本(通常与Linux那样的操作系统配套提供,且已预先安装好)。正如大家即将看到的那样,从CGI程序可获得面向对象程序设计的许多好处。

④:GNU的全称是“Gnu's Not Unix”。这最早是由“自由软件基金会”(FSF)负责开发的一个项目,致力于用一个免费的版本取代原有的Unix操作系统。现在的Linux似乎正在做前人没有做到的事情。但GNU工具在Linux的开发中扮演了至关重要的角色。事实上,Linux的整套软件包附带了数量非常多的GNU组件。

为避免第一次就提出过多的新概念,这个程序并未打算成为一个“纯”C++程序;有些代码是用普通C写成的——尽管还可选用C++的一些替用形式。但这并不是个突出的问题,因为该程序用C++制作最大的好处就是能够创建类。在解析CGI信息的时候,由于我们最关心的是字段的“名称/值”对,所以要用一个类(Pair)来代表单个名称/值对;另一个类(CGI_vector)则将CGI字串自动解析到它会容纳的Pair对象里(作为一个vector),这样即可在有空的时候把每个Pair(对)都取出来。
这个程序同时也非常有趣,因为它演示了C++与Java相比的许多优缺点。大家会看到一些相似的东西;比如class关键字。访问控制使用的是完全相同的关键字public和private,但用法却有所不同。它们控制的是一个块,而非单个方法或字段(也就是说,如果指定private:,后续的每个定义都具有private属性,直到我们再指定public:为止)。另外在创建一个类的时候,所有定义都自动默认为private。
在这儿使用C++的一个原因是要利用C++“标准模板库”(STL)提供的便利。至少,STL包含了一个vector类。这是一个C++模板,可在编译期间进行配置,令其只容纳一种特定类型的对象(这里是Pair对象)。和Java的Vector不同,如果我们试图将除Pair对象之外的任何东西置入vector,C++的vector模板都会造成一个编译期错误;而Java的Vector能够照单全收。而且从vector里取出什么东西的时候,它会自动成为一个Pair对象,毋需进行造型处理。所以检查在编译期进行,这使程序显得更为“健壮”。此外,程序的运行速度也可以加快,因为没有必要进行运行期间的造型。vector也会过载operator[],所以可以利用非常方便的语法来提取Pair对象。vector模板将在CGI_vector创建时使用;在那时,大家就可以体会到如此简短的一个定义居然蕴藏有那么巨大的能量。
若提到缺点,就一定不要忘记Pair在下列代码中定义时的复杂程度。与我们在Java代码中看到的相比,Pair的方法定义要多得多。这是由于C++的程序员必须提前知道如何用副本构建器控制复制过程,而且要用过载的operator=完成赋值。正如第12章解释的那样,我们有时也要在Java中考虑同样的事情。但在C++中,几乎一刻都不能放松对这些问题的关注。
这个项目首先创建一个可以重复使用的部分,由C++头文件中的Pair和CGI_vector构成。从技术角度看,确实不应把这些东西都塞到一个头文件里。但就目前的例子来说,这样做不会造成任何方面的损害,而且更具有Java风格,所以大家阅读理解代码时要显得轻松一些:
//: CGITools.h
// Automatically extracts and decodes data
// from CGI GETs and POSTs. Tested with GNU C++
// (available for most server machines).
#include <string.h>
#include <vector> // STL vector
using namespace std;
 
// A class to hold a single name-value pair from
// a CGI query. CGI_vector holds Pair objects and
// returns them from its operator[].
class Pair {
 char* nm;
 char* val;
public:
 Pair() { nm = val = 0; }
 Pair(char* name, char* value) {
    // Creates new memory:
    nm = decodeURLString(name);
    val = decodeURLString(value);
 }
 constchar* name() const { return nm; }
 constchar* value() const { return val; }
 // Test for "emptiness"
 bool empty() const {
    return (nm == 0) || (val == 0);
 }
 // Automatic type conversion for boolean test:
 operator bool() const {
    return (nm != 0) && (val != 0);
 }
 // The following constructors & destructor are
 // necessary for bookkeeping in C++.
 // Copy-constructor:
 Pair(const Pair& p) {
    if(p.nm == 0 || p.val == 0) {
      nm = val = 0;
    } else {
      // Create storage & copy rhs values:
      nm = newchar[strlen(p.nm) + 1];
      strcpy(nm, p.nm);
      val = newchar[strlen(p.val) + 1];
      strcpy(val, p.val);
    }
 }
 // Assignment operator:
 Pair& operator=(const Pair& p) {
    // Clean up old lvalues:
    delete nm;
    delete val;
    if(p.nm == 0 || p.val == 0) {
      nm = val = 0;
    } else {
      // Create storage & copy rhs values:
      nm = newchar[strlen(p.nm) + 1];
      strcpy(nm, p.nm);
      val = newchar[strlen(p.val) + 1];
      strcpy(val, p.val);
    }
    return *this;
 }
 ~Pair() { // Destructor
    delete nm; // 0 value OK
    delete val;
 }
 // If you use this method outide this class,
 // you're responsible for calling 'delete' on
 // the pointer that's returned:
 staticchar*
 decodeURLString(constchar* URLstr) {
    int len = strlen(URLstr);
    char* result = newchar[len + 1];
    memset(result, len + 1, 0);
    for(int i = 0, j = 0; i <= len; i++, j++) {
      if(URLstr[i] == '+')
        result[j] = ' ';
      elseif(URLstr[i] == '%') {
        result[j] =
          translateHex(URLstr[i + 1]) * 16 +
          translateHex(URLstr[i + 2]);
        i += 2; // Move past hex code
      } else// An ordinary character
        result[j] = URLstr[i];
    }
    return result;
 }
 // Translate a single hex character; used by
 // decodeURLString():
 staticchar translateHex(char hex) {
    if(hex >= 'A')
      return (hex & 0xdf) - 'A' + 10;
    else
      return hex - '0';
 }
};
 
// Parses any CGI query and turns it
// into an STL vector of Pair objects:
class CGI_vector : public vector<Pair> {
 char* qry;
 constchar* start; // Save starting position
 // Prevent assignment and copy-construction:
 void operator=(CGI_vector&);
 CGI_vector(CGI_vector&);
public:
 // const fields must be initialized in the C++
 // "Constructor initializer list":
 CGI_vector(char* query) :
      start(newchar[strlen(query) + 1]) {
    qry = (char*)start; // Cast to non-const
    strcpy(qry, query);
    Pair p;
    while((p = nextPair()) != 0)
      push_back(p);
 }
 // Destructor:
 ~CGI_vector() { delete start; }
private:
 // Produces name-value pairs from the query
 // string. Returns an empty Pair when there's
 // no more query string left:
 Pair nextPair() {
    char* name = qry;
    if(name == 0 || *name == '/0')
      return Pair(); // End, return null Pair
    char* value = strchr(name, '=');
   if(value == 0)
      return Pair(); // Error, return null Pair
    // Null-terminate name, move value to start
    // of its set of characters:
    *value = '/0';
    value++;
    // Look for end of value, marked by '&':
    qry = strchr(value, '&');
    if(qry == 0) qry = ""; // Last pair found
    else {
      *qry = '/0'; // Terminate value string
      qry++; // Move to next pair
    }
    return Pair(name, value);
 }
}; ///:~

在#include语句后,可看到有一行是:
using namespace std;
C++中的“命名空间”(Namespace)解决了由Java的package负责的一个问题:将库名隐藏起来。std命名空间引用的是标准C++库,而vector就在这个库中,所以这一行是必需的。
Pair类表面看异常简单,只是容纳了两个(private)字符指针而已——一个用于名字,另一个用于值。默认构建器将这两个指针简单地设为零。这是由于在C++中,对象的内存不会自动置零。第二个构建器调用方法decodeURLString(),在新分配的堆内存中生成一个解码过后的字串。这个内存区域必须由对象负责管理及清除,这与“破坏器”中见到的相同。name()和value()方法为相关的字段产生只读指针。利用empty()方法,我们查询Pair对象它的某个字段是否为空;返回的结果是一个bool——C++内建的基本布尔数据类型。operator bool()使用的是C++“运算符过载”的一种特殊形式。它允许我们控制自动类型转换。如果有一个名为p的Pair对象,而且在一个本来希望是布尔结果的表达式中使用,比如if(p){//...,那么编译器能辨别出它有一个Pair,而且需要的是个布尔值,所以自动调用operator bool(),进行必要的转换。
接下来的三个方法属于常规编码,在C++中创建类时必须用到它们。根据C++类采用的所谓“经典形式”,我们必须定义必要的“原始”构建器,以及一个副本构建器和赋值运算符——operator=(以及破坏器,用于清除内存)。之所以要作这样的定义,是由于编译器会“默默”地调用它们。在对象传入、传出一个函数的时候,需要调用副本构建器;而在分配对象时,需要调用赋值运算符。只有真正掌握了副本构建器和赋值运算符的工作原理,才能在C++里写出真正“健壮”的类,但这需要需要一个比较艰苦的过程(注释⑤)。

⑤:我的《Thinking in C++》(Prentice-Hall,1995)用了一整章的地方来讨论这个主题。若需更多的帮助,请务必看看那一章。

只要将一个对象按值传入或传出函数,就会自动调用副本构建器Pair(const Pair&)。也就是说,对于准备为其制作一个完整副本的那个对象,我们不准备在函数框架中传递它的地址。这并不是Java提供的一个选项,由于我们只能传递句柄,所以在Java里没有所谓的副本构建器(如果想制作一个本地副本,可以“克隆”那个对象——使用clone(),参见第12章)。类似地,如果在Java里分配一个句柄,它会简单地复制。但C++中的赋值意味着整个对象都会复制。在副本构建器中,我们创建新的存储空间,并复制原始数据。但对于赋值运算符,我们必须在分配新存储空间之前释放老存储空间。我们要见到的也许是C++类最复杂的一种情况,但那正是Java的支持者们论证Java比C++简单得多的有力证据。在Java中,我们可以自由传递句柄,善后工作则由垃圾收集器负责,所以可以轻松许多。
但事情并没有完。Pair类为nm和val使用的是char*,最复杂的情况主要是围绕指针展开的。如果用较时髦的C++ string类来代替char*,事情就要变得简单得多(当然,并不是所有编译器都提供了对string的支持)。那么,Pair的第一部分看起来就象下面这样:
class Pair {
 string nm;
 string val;
public:
 Pair() { }
 Pair(char* name, char* value) {
    nm = decodeURLString(name);
    val = decodeURLString(value);
 }
 constchar* name() const { return nm.c_str(); }
 constchar* value() const {
    return val.c_str();
 }
 // Test for "emptiness"
 bool empty() const {
    return (nm.length() == 0)
      || (val.length() == 0);
 }
 // Automatic type conversion for boolean test:
 operator bool() const {
    return (nm.length() != 0)
      && (val.length() != 0);
 }

(此外,对这个类decodeURLString()会返回一个string,而不是一个char*)。我们不必定义副本构建器、operator=或者破坏器,因为编译器已帮我们做了,而且做得非常好。但即使有些事情是自动进行的,C++程序员也必须了解副本构建以及赋值的细节。
Pair类剩下的部分由两个方法构成:decodeURLString()以及一个“帮助器”方法translateHex()——将由decodeURLString()使用。注意translateHex()并不能防范用户的恶意输入,比如“%1H”。分配好足够的存储空间后(必须由破坏器释放),decodeURLString()就会其中遍历,将所有“+”都换成一个空格;将所有十六进制代码(以一个“%”打头)换成对应的字符。
CGI_vector用于解析和容纳整个CGI GET命令。它是从STL vector里继承的,后者例示为容纳Pair。C++中的继承是用一个冒号表示,在Java中则要用extends。此外,继承默认为private属性,所以几乎肯定需要用到public关键字,就象这样做的那样。大家也会发现CGI_vector有一个副本构建器以及一个operator=,但它们都声明成private。这样做是为了防止编译器同步两个函数(如果不自己声明它们,两者就会同步)。但这同时也禁止了客户程序员按值或者通过赋值传递一个CGI_vector。
CGI_vector的工作是获取QUERY_STRING,并把它解析成“名称/值”对,这需要在Pair的帮助下完成。它首先将字串复制到本地分配的内存,并用常数指针start跟踪起始地址(稍后会在破坏器中用于释放内存)。随后,它用自己的nextPair()方法将字串解析成原始的“名称/值”对,各个对之间用一个“=”和“&”符号分隔。这些对由nextPair()传递给Pair构建器,所以nextPair()返回的是一个Pair对象。随后用push_back()将该对象加入vector。nextPair()遍历完整个QUERY_STRING后,会返回一个零值。
现在基本工具已定义好,它们可以简单地在一个CGI程序中使用,就象下面这样:
//: Listmgr2.cpp
// CGI version of Listmgr.c in C++, which
// extracts its input via the GET submission
// from the associated applet. Also works as
// an ordinary CGI program with HTML forms.
#include <stdio.h>
#include "CGITools.h"
constchar* dataFile = "list2.txt";
constchar* notify = "Bruce@EckelObjects.com";
#undef DEBUG
 
// Similar code as before, except that it looks
// for the email name inside of '<>':
int inList(FILE* list, constchar* emailName) {
 constint BSIZE = 255;
 char lbuf[BSIZE];
 char emname[BSIZE];
 // Put the email name in '<>' so there's no
 // possibility of a match within another name:
 sprintf(emname, "<%s>", emailName);
 // Go to the beginning of the list:
 fseek(list, 0, SEEK_SET);
 // Read each line in the list:
 while(fgets(lbuf, BSIZE, list)) {
    // Strip off the newline:
    char * newline = strchr(lbuf, '/n');
    if(newline != 0)
      *newline = '/0';
    if(strstr(lbuf, emname) != 0)
      return 1;
 }
 return 0;
}
 
void main() {
 // You MUST print this out, otherwise the
 // server will not send the response:
 printf("Content-type: text/plain/n/n");
 FILE* list = fopen(dataFile, "a+t");
 if(list == 0) {
    printf("error: could not open database. ");
    printf("Notify %s", notify);
    return;
 }
 // For a CGI "GET," the server puts the data
 // in the environment variable QUERY_STRING:
 CGI_vector query(getenv("QUERY_STRING"));
 #if defined(DEBUG)
 // Test: dump all names and values
 for(int i = 0; i < query.size(); i++) {
    printf("query[%d].name() = [%s], ",
      i, query[i].name());
    printf("query[%d].value() = [%s]/n",
      i, query[i].value());
 }
 #endif(DEBUG)
 Pair name = query[0];
 Pair email = query[1];
 if(name.empty() || email.empty()) {
    printf("error: null name or email");
    return;
 }
 if(inList(list, email.value())) {
    printf("Already in list: %s", email.value());
    return;
 }
 // It's not in the list, add it:
 fseek(list, 0, SEEK_END);
 fprintf(list, "%s <%s>;/n",
    name.value(), email.value());
 fflush(list);
 fclose(list);
 printf("%s <%s> added to list/n",
    name.value(), email.value());
} ///:~

alreadyInList()
函数与前一个版本几乎是完全相同的,只是它假定所有电子函件地址都在一个“<>”内。
在使用GET方法时(通过在FORM引导命令的METHOD标记内部设置,但这在这里由数据发送的方式控制),Web服务器会收集位于“?”后面的所有信息,并把它们置入环境变量QUERY_STRING(查询字串)里。所以为了读取那些信息,必须获得QUERY_STRING的值,这是用标准的C库函数getnv()完成的。在main()中,注意对QUERY_STRING的解析有多么容易:只需把它传递给用于CGI_vector对象的构建器(名为query),剩下的所有工作都会自动进行。从这时开始,我们就可以从query中取出名称和值,把它们当作数组看待(这是由于operator[]在vector里已经过载了)。在调试代码中,大家可看到这一切是如何运作的;调试代码封装在预处理器引导命令#if defined(DEBUG)和#endif(DEBUG)之间。
现在,我们迫切需要掌握一些与CGI有关的东西。CGI程序用两个方式之一传递它们的输入:在GET执行期间通过QUERY_STRING传递(目前用的这种方式),或者在POST期间通过标准输入。但CGI程序通过标准输出发送自己的输出,这通常是用C程序的printf()命令实现的。那么这个输出到哪里去了呢?它回到了Web服务器,由服务器决定该如何处理它。服务器作出决定的依据是content-type(内容类型)头数据。这意味着假如content-type头不是它看到的第一件东西,就不知道该如何处理收到的数据。因此,我们无论如何也要使所有CGI程序都从content-type头开始输出。
在目前这种情况下,我们希望服务器将所有信息都直接反馈回客户程序(亦即我们的程序片,它们正在等候给自己的回复)。信息应该原封不动,所以content-type设为text/plain(纯文本)。一旦服务器看到这个头,就会将所有字串都直接发还给客户。所以每个字串(三个用于出错条件,一个用于成功的加入)都会返回程序片。
我们用相同的代码添加电子函件名称(用户的姓名)。但在CGI脚本的情况下,并不存在无限循环——程序只是简单地响应,然后就中断。每次有一个CGI请求抵达时,程序都会启动,对那个请求作出反应,然后自行关闭。所以CPU不可能陷入空等待的尴尬境地,只有启动程序和打开文件时才存在性能上的隐患。Web服务器对CGI请求进行控制时,它的开销会将这种隐患减轻到最低程度。
这种设计的另一个好处是由于Pair和CGI_vector都得到了定义,大多数工作都帮我们自动完成了,所以只需修改main()即可轻松创建自己的CGI程序。尽管小服务程序(Servlet)最终会变得越来越流行,但为了创建快速的CGI程序,C++仍然显得非常方便。

15.6.4 POST的概念
在许多应用程序中使用GET都没有问题。但是,GET要求通过一个环境变量将自己的数据传递给CGI程序。但假如GET字串过长,有些Web服务器可能用光自己的环境空间(若字串长度超过200字符,就应开始关心这方面的问题)。CGI为此提供了一个解决方案:POST。通过POST,数据可以编码,并按与GET相同的方法连结起来。但POST利用标准输入将编码过后的查询字串传递给CGI程序。我们要做的全部事情就是判断查询字串的长度,而这个长度已在环境变量CONTENT_LENGTH中保存好了。一旦知道了长度,就可自由分配存储空间,并从标准输入中读入指定数量的字符。
对一个用来控制POST的CGI程序,由CGITools.h提供的Pair和CGI_vector均可不加丝毫改变地使用。下面这段程序揭示了写这样的一个CGI程序有多么简单。这个例子将采用“纯”C++,所以studio.h库被iostream(IO数据流)代替。对于iostream,我们可以使用两个预先定义好的对象:cin,用于同标准输入连接;以及cout,用于同标准输出连接。有几个办法可从cin中读入数据以及向cout中写入。但下面这个程序准备采用标准方法:用“<<”将信息发给cout,并用一个成员函数(此时是read())从cin中读入数据:
//: POSTtest.cpp
// CGI_vector works as easily with POST as it
// does with GET. Written in "pure" C++.
#include <iostream.h>
#include "CGITools.h"
 
void main() {
 cout << "Content-type: text/plain/n" << endl;
 // For a CGI "POST," the server puts the length
 // of the content string in the environment
 // variable CONTENT_LENGTH:
 char* clen = getenv("CONTENT_LENGTH");
 if(clen == 0) {
    cout << "Zero CONTENT_LENGTH" << endl;
    return;
 }
 int len = atoi(clen);
 char* query_str = newchar[len + 1];
 cin.read(query_str, len);
 query_str[len] = '/0';
 CGI_vector query(query_str);
 // Test: dump all names and values
 for(int i = 0; i < query.size(); i++)
    cout << "query[" << i << "].name() = [" <<
      query[i].name() << "], " <<
      "query[" << i << "].value() = [" <<
      query[i].value() << "]" << endl;
 delete query_str; // Release storage
} ///:~

getenv()
函数返回指向一个字串的指针,那个字串指示着内容的长度。若指针为零,表明CONTENT_LENGTH环境变量尚未设置,所以肯定某个地方出了问题。否则就必须用ANSI C库函数atoi()将字串转换成一个整数。这个长度将与new一起运用,分配足够的存储空间,以便容纳查询字串(另加它的空中止符)。随后为cin()调用read()。read()函数需要取得指向目标缓冲区的一个指针以及要读入的字节数。随后用空字符(null)中止query_str,指出已经抵达字串的末尾,这就叫作“空中止”。
到这个时候,我们得到的查询字串与GET查询字串已经没有什么区别,所以把它传递给用于CGI_vector的构建器。随后便和前例一样,我们可以自由vector内不同的字段。
为测试这个程序,必须把它编译到主机Web服务器的cgi-bin目录下。然后就可以写一个简单的HTML页进行测试,就象下面这样:
<HTML>
<HEAD>
<META CONTENT="text/html">
<TITLE>A test of standard HTML POST</TITLE>
</HEAD>
Test, uses standard html POST
<Form method="POST" ACTION="/cgi-bin/POSTtest">
<P>Field1: <INPUT TYPE = "text" NAME = "Field1"
VALUE = "" size = "40"></p>
<P>Field2: <INPUT TYPE = "text" NAME = "Field2"
VALUE = "" size = "40"></p>
<P>Field3: <INPUT TYPE = "text" NAME = "Field3"
VALUE = "" size = "40"></p>
<P>Field4: <INPUT TYPE = "text" NAME = "Field4"
VALUE = "" size = "40"></p>
<P>Field5: <INPUT TYPE = "text" NAME = "Field5"
VALUE = "" size = "40"></p>
<P>Field6: <INPUT TYPE = "text" NAME = "Field6"
VALUE = "" size = "40"></p>
<p><input type = "submit" name = "submit" > </p>
</Form>
</HTML>

填好这个表单并提交出去以后,会得到一个简单的文本页,其中包含了解析出来的结果。从中可知道CGI程序是否在正常工作。
当然,用一个程序片来提交数据显得更有趣一些。然而,POST数据的提交属于一个不同的过程。在用常规方式调用了CGI程序以后,必须另行建立与服务器的一个连接,以便将查询字串反馈给它。服务器随后会进行一番处理,再通过标准输入将查询字串反馈回CGI程序。
为建立与服务器的一个直接连接,必须取得自己创建的URL,然后调用openConnection()创建一个URLConnection。但是,由于URLConnection一般不允许我们把数据发给它,所以必须很可笑地调用setDoOutput(true)函数,同时调用的还包括setDoInput(true)以及setAllowUserInteraction(false)——注释⑥。最后,可调用getOutputStream()来创建一个OutputStream(输出数据流),并把它封装到一个DataOutputStream里,以便能按传统方式同它通信。下面列出的便是一个用于完成上述工作的程序片,必须在从它的各个字段里收集了数据之后再执行它:
//: POSTtest.java
// An applet that sends its data via a CGI POST
import java.awt.*;
import java.applet.*;
import java.net.*;
import java.io.*;
 
publicclass POSTtest extends Applet {
 finalstaticint SIZE = 10;
 Button submit = new Button("Submit");
 TextField[] t = new TextField[SIZE];
 String query = "";
 Label l = new Label();
 TextArea ta = new TextArea(15, 60);
 publicvoid init() {
    Panel p = new Panel();
    p.setLayout(new GridLayout(t.length + 2, 2));
    for(int i = 0; i < t.length; i++) {
      p.add(new Label(
        "Field " + i + " ", Label.RIGHT));
      p.add(t[i] = new TextField(30));
    }
    p.add(l);
    p.add(submit);
    add("North", p);
    add("South", ta);
 }
 publicboolean action (Event evt, Object arg) {
    if(evt.target.equals(submit)) {
      query = "";
      ta.setText("");
      // Encode the query from the field data:
      for(int i = 0; i < t.length; i++)
         query += "Field" + i + "=" +
           URLEncoder.encode(
             t[i].getText().trim()) +
           "&";
      query += "submit=Submit";
      // Send the name using CGI's POST process:
      try {
        URL u = new URL(
          getDocumentBase(), "cgi-bin/POSTtest");
        URLConnection urlc = u.openConnection();
        urlc.setDoOutput(true);
        urlc.setDoInput(true);
        urlc.setAllowUserInteraction(false);
        DataOutputStream server =
          new DataOutputStream(
            urlc.getOutputStream());
        // Send the data
        server.writeBytes(query);
        server.close();
        // Read and display the response. You
        // cannot use
        // getAppletContext().showDocument(u);
        // to display the results as a Web page!
        DataInputStream in =
          new DataInputStream(
            urlc.getInputStream());
        String s;
        while((s = in.readLine()) != null) {
          ta.appendText(s + "/n");
        }
        in.close();
      }
      catch (Exception e) {
        l.setText(e.toString());
      }
    }
    elsereturnsuper.action(evt, arg);
    returntrue;
 }
} ///:~

:我不得不说自己并没有真正理解这儿都发生了什么事情,这些概念都是从Elliotte Rusty Harold编著的《Java Network Programming》里得来的,该书由O'Reilly于1997年出版。他在书中提到了Java连网函数库中出现的许多令人迷惑的Bug。所以一旦涉足这些领域,事情就不是编写代码,然后让它自己运行那么简单。一定要警惕潜在的陷阱!

信息发送到服务器后,我们调用getInputStream(),并把返回值封装到一个DataInputStream里,以便自己能读取结果。要注意的一件事情是结果以文本行的形式显示在一个TextArea(文本区域)中。为什么不简单地使用getAppletContext().showDocument(u)呢?事实上,这正是那些陷阱中的一个。上述代码可以很好地工作,但假如试图换用showDocument(),几乎一切都会停止运行。也就是说,showDocument()确实可以运行,但从POSTtest得到的返回结果是“Zero CONTENT_LENGTH”(内容长度为零)。所以不知道为什么原因,showDocument()阻止了POST查询向CGI程序的传递。我很难判断这到底是一个在以后版本里会修复的Bug,还是由于我的理解不够(我看过的书对此讲得都很模糊)。但无论在哪种情况下,只要能坚持在文本区域里观看自CGI程序返回的内容,上述程序片运行时就没有问题。

15.7 用JDBC连接数据库
据估算,将近一半的软件开发都要涉及客户(机)/服务器方面的操作。Java为自己保证的一项出色能力就是构建与平台无关的客户机/服务器数据库应用。在Java 1.1中,这一保证通过Java数据库连接(JDBC)实现了。
数据库最主要的一个问题就是各家公司之间的规格大战。确实存在一种“标准”数据库语言,即“结构查询语言”(SQL-92),但通常都必须确切知道自己要和哪家数据库公司打交道,否则极易出问题,尽管存在所谓的“标准”。JDBC是面向“与平台无关”设计的,所以在编程的时候不必关心自己要使用的是什么数据库产品。然而,从JDBC里仍有可能发出对某些数据库公司专用功能的调用,所以仍然不可任性妄为。
和Java中的许多API一样,JDBC也做到了尽量的简化。我们发出的方法调用对应于从数据库收集数据时想当然的做法:同数据库连接,创建一个语句并执行查询,然后处理结果集。
为实现这一“与平台无关”的特点,JDBC为我们提供了一个“驱动程序管理器”,它能动态维护数据库查询所需的所有驱动程序对象。所以假如要连接由三家公司开发的不同种类的数据库,就需要三个单独的驱动程序对象。驱动程序对象会在装载时由“驱动程序管理器”自动注册,并可用Class.forName()强行装载。
为打开一个数据库,必须创建一个“数据库URL”,它要指定下述三方面的内容:
(1) 用“jdbc”指出要使用JDBC。
(2) “子协议”:驱动程序的名字或者一种数据库连接机制的名称。由于JDBC的设计从ODBC吸收了许多灵感,所以可以选用的第一种子协议就是“jdbc-odbc桥”,它用“odbc”关键字即可指定。
(3) 数据库标识符:随使用的数据库驱动程序的不同而变化,但一般都提供了一个比较符合逻辑的名称,由数据库管理软件映射(对应)到保存了数据表的一个物理目录。为使自己的数据库标识符具有任何含义,必须用自己的数据库管理软件为自己喜欢的名字注册(注册的具体过程又随运行平台的不同而变化)。
所有这些信息都统一编译到一个字串里,即“数据库URL”。举个例子来说,若想通过ODBC子协议同一个标识为“people”的数据库连接,相应的数据库URL可设为:
String dbUrl = "jdbc:odbc:people"
如果通过一个网络连接,数据库URL也需要包含对远程机器进行标识的信息。
准备好同数据库连接后,可调用静态方法DriverManager.getConnection(),将数据库的URL以及进入那个数据库所需的用户名密码传递给它。得到的返回结果是一个Connection对象,利用它即可查询和操纵数据库。
下面这个例子将打开一个联络信息数据库,并根据命令行提供的参数查询一个人的姓(Last Name)。它只选择那些有E-mail地址的人的名字,然后列印出符合查询条件的所有人:
//: Lookup.java
// Looks up email addresses in a
// local database using JDBC
import java.sql.*;
 
publicclass Lookup {
 publicstaticvoid main(String[] args) {
    String dbUrl = "jdbc:odbc:people";
    String user = "";
    String password = "";
    try {
      // Load the driver (registers itself)
      Class.forName(
        "sun.jdbc.odbc.JdbcOdbcDriver");
      Connection c = DriverManager.getConnection(
        dbUrl, user, password);
      Statement s = c.createStatement();
      // SQL code:
      ResultSet r =
        s.executeQuery(
          "SELECT FIRST, LAST, EMAIL " +
          "FROM people.csv people " +
          "WHERE " +
          "(LAST='" + args[0] + "') " +
         " AND (EMAIL Is Not Null) " +
          "ORDER BY FIRST");
      while(r.next()) {
        // Capitalization doesn't matter:
        System.out.println(
          r.getString("Last") + ", "
          + r.getString("fIRST")
          + ": " + r.getString("EMAIL") );
      }
      s.close(); // Also closes ResultSet
    } catch(Exception e) {
      e.printStackTrace();
    }
 }
} ///:~

可以看到,数据库URL的创建过程与我们前面讲述的完全一样。在该例中,数据库未设密码保护,所以用户名和密码都是空串。
用DriverManager.getConnection()建好连接后,接下来可根据结果Connection对象创建一个Statement(语句)对象,这是用createStatement()方法实现的。根据结果Statement,我们可调用executeQuery(),向其传递包含了SQL-92标准SQL语句的一个字串(不久就会看到如何自动创建这类语句,所以没必要在这里知道关于SQL更多的东西)。
executeQuery()方法会返回一个ResultSet(结果集)对象,它与继承器非常相似:next()方法将继承器移至语句中的下一条记录;如果已抵达结果集的末尾,则返回null。我们肯定能从executeQuery()返回一个ResultSet对象,即使查询结果是个空集(也就是说,不会产生一个违例)。注意在试图读取任何记录数据之前,都必须调用一次next()。若结果集为空,那么对next()的这个首次调用就会返回false。对于结果集中的每条记录,都可将字段名作为字串使用(当然还有其他方法),从而选择不同的字段。另外要注意的是字段名的大小写是无关紧要的——SQL数据库不在乎这个问题。为决定返回的类型,可调用getString(),getFloat()等等。到这个时候,我们已经用Java的原始格式得到了自己的数据库数据,接下去可用Java代码做自己想做的任何事情了。

15.7.1 让示例运行起来
就JDBC来说,代码本身是很容易理解的。最令人迷惑的部分是如何使它在自己特定的系统上运行起来。之所以会感到迷惑,是由于它要求我们掌握如何才能使JDBC驱动程序正确装载,以及如何用我们的数据库管理软件来设置一个数据库。
当然,具体的操作过程在不同的机器上也会有所区别。但这儿提供的在32位Windows环境下操作过程可有效帮助大家理解在其他平台上的操作。

1. 步骤1:寻找JDBC驱动程序
上述程序包含了下面这条语句:
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
这似乎暗示着一个目录结构,但大家不要被它蒙骗了。在我手上这个JDK 1.1安装版本中,根本不存在叫作JdbcOdbcDriver.class的一个文件。所以假如在看了这个例子后去寻找它,那么必然会徒劳而返。另一些人提供的例子使用的是一个假名字,如“myDriver.ClassName”,但人们从字面上得不到任何帮助。事实上,上述用于装载jdbc-odbc驱动程序(实际是与JDK 1.1配套提供的唯一驱动)的语句在联机文档的多处地方均有出现(特别是在一个标记为“JDBC-ODBC Bridge Driver”的页内)。若上面的装载语句不能工作,那么它的名字可能已随着Java新版本的发布而改变了;此时应到联机文档里寻找新的表述方式。
若装载语句出错,会在这个时候得到一个违例。为了检验驱动程序装载语句是不是能正常工作,请将该语句后面直到catch从句之间的代码暂时设为注释。如果程序运行时未出现违例,表明驱动程序的装载是正确的。

2. 步骤2:配置数据库
同样地,我们只限于在32位Windows环境中工作;您可能需要研究一下自己的操作系统,找出适合自己平台的配置方法。
首先打开控制面板。其中可能有两个图标都含有“ODBC”字样,必须选择那个“32位ODBC”,因为另一个是为了保持与16位软件的向后兼容而设置的,和JDBC混用没有任何结果。双击“32位ODBC”图标后,看到的应该是一个卡片式对话框,上面一排有多个卡片标签,其中包括“用户DSN”、“系统DSN”、“文件DSN”等等。其中,“DSN”代表“数据源名称”(Data Source Name)。它们都与JDBC-ODBC桥有关,但设置数据库时唯一重要的地方“系统DSN”。尽管如此,由于需要测试自己的配置以及创建查询,所以也需要在“文件DSN”中设置自己的数据库。这样便可让Microsoft Query工具(与Microsoft Office配套提供)正确地找到数据库。注意一些软件公司也设计了自己的查询工具。
最有趣的数据库是我们已经使用过的一个。标准ODBC支持多种文件格式,其中包括由不同公司专用的一些格式,如dBASE。然而,它也包括了简单的“逗号分隔ASCII”格式,它几乎是每种数据工具都能够生成的。就目前的例子来说,我只选择自己的“people”数据库。这是我多年来一直在维护的一个数据库,中间使用了各种联络管理工具。我把它导出成为一个逗号分隔的ASCII文件(一般有个.csv扩展名,用Outlook Express导出通信簿时亦可选用同样的文件格式)。在“文件DSN”区域,我按下“添加”按钮,选择用于控制逗号分隔ASCII文件的文本驱动程序(Microsoft Text Driver),然后撤消对“使用当前目录”的选择,以便导出数据文件时可以自行指定目录。
大家会注意到在进行这些工作的时候,并没有实际指定一个文件,只是一个目录。那是因为数据库通常是由某个目录下的一系列文件构成的(尽管也可能采用其他形式)。每个文件一般都包含了单个“数据表”,而且SQL语句可以产生从数据库中多个表摘取出来的结果(这叫作“联合”,或者join)只包含了单张表的数据库(就象目前这个)通常叫作“平面文件数据库”。对于大多数问题,如果已经超过了简单的数据存储与获取力所能及的范围,那么必须使用多个数据表。通过“联合”,从而获得希望的结果。我们把这些叫作“关系型”数据库。

3. 步骤3:测试配置
为了对配置进行测试,需用一种方式核实数据库是否可由查询它的一个程序“见到”。当然,可以简单地运行上述的JDBC示范程序,并加入下述语句:
Connection c = DriverManager.getConnection(
dbUrl, user, password);
若掷出一个违例,表明你的配置有误。
然而,此时很有必要使用一个自动化的查询生成工具。我使用的是与Microsoft Office配套提供的Microsoft Query,但你完全可以自行选择一个。查询工具必须知道数据库在什么地方,而Microsoft Query要求我进入ODBC Administrator的“文件DSN”卡片,并在那里新添一个条目。同样指定文本驱动程序以及保存数据库的目录。虽然可将这个条目命名为自己喜欢的任何东西,但最好还是使用与“系统DSN”中相同的名字。
做完这些工作后,再用查询工具创建一个新查询时,便会发现自己的数据库可以使用了。

4. 步骤4:建立自己的SQL查询
我用Microsoft Query创建的查询不仅指出目标数据库存在且次序良好,也会自动生成SQL代码,以便将其插入我自己的Java程序。我希望这个查询能够检查记录中是否存在与启动Java程序时在命令行键入的相同的“姓”(Last Name)。所以作为一个起点,我搜索自己的姓“Eckel”。另外,我希望只显示出有对应E-mail地址的那些名字。创建这个查询的步骤如下:
(1) 启动一个新查询,并使用查询向导(Query Wizard)。选择“people”数据库(等价于用适应的数据库URL打开数据库连接)。
(2) 选择数据库中的“people”表。从这张数据表中,选择FIRST,LAST和EMAIL列。
(3) 在“Filter Data”(过滤器数据库)下,选择LAST,并选择“equals”(等于),加上参数Eckel。点选“And”单选钮。
(4) 选择EMAIL,并选中“Is not Null”(不为空)。
(5) 在“Sort By”下,选择FIRST。
查询结果会向我们展示出是否能得到自己希望的东西。
现在可以按下SQL按钮。不需要我们任何方面的介入,正确的SQL代码会立即弹现出来,以便我们粘贴和复制。对于这个查询,相应的SQL代码如下:
SELECT people.FIRST, people.LAST, people.EMAIL
FROM people.csv people
WHERE (people.LAST='Eckel') AND
(people.EMAIL Is Not Null)
ORDER BY people.FIRST

若查询比较复杂,手工编码极易出错。但利用一个查询工具,就可以交互式地测试自己的查询,并自动获得正确的代码。事实上,亲手为这些事情编码是难以让人接受的。

5. 步骤5:在自己的查询中修改和粘贴
我们注意到上述代码与程序中使用的代码是有所区别的。那是由于查询工具对所有名字都进行了限定,即便涉及的仅有一个数据表(若真的涉及多个数据表,这种限定可避免来自不同表的同名数据列发生冲突)。由于这个查询只需要用到一个数据表,所以可考虑从大多数名字中删除“people”限定符,就象下面这样:
SELECT FIRST, LAST, EMAIL
FROM people.csv people
WHERE (LAST='Eckel') AND
(EMAIL Is Not Null)
ORDER BY FIRST

此外,我们不希望“硬编码”这个程序,从而只能查找一个特定的名字。相反,它应该能查找我们在命令行动态提供的一个名字。所以还要进行必要的修改,并将SQL语句转换成一个动态生成的字串。如下所示:
"SELECT FIRST, LAST, EMAIL " +
"FROM people.csv people " +
"WHERE " +
"(LAST='" + args[0] + "') " +
" AND (EMAIL Is Not Null) " +
"ORDER BY FIRST");

SQL
还有一种方式可将名字插入一个查询,名为“程序”(Procedures),它的速度非常快。但对于我们的大多数实验性数据库操作,以及一些初级应用,用Java构建查询字串已经很不错了。
从这个例子可以看出,利用目前找得到的工具——特别是查询构建工具——涉及SQL及JDBC的数据库编程是非常简单和直观的。

15.7.2 查找程序的GUI版本
最好的方法是让查找程序一直保持运行,要查找什么东西时只需简单地切换到它,并键入要查找的名字即可。下面这个程序将查找程序作为一个“application/applet”创建,且添加了名字自动填写功能,所以不必键入完整的姓,即可看到数据:
//: VLookup.java
// GUI version of Lookup.java
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
import java.sql.*;
 
publicclass VLookup extends Applet {
 String dbUrl = "jdbc:odbc:people";
 String user = "";
 String password = "";
 Statement s;
 TextField searchFor = new TextField(20);
 Label completion =
    new Label("                       ");
 TextArea results = new TextArea(40, 20);
 publicvoid init() {
    searchFor.addTextListener(new SearchForL());
    Panel p = new Panel();
    p.add(new Label("Last name to search for:"));
    p.add(searchFor);
    p.add(completion);
    setLayout(new BorderLayout());
    add(p, BorderLayout.NORTH);
    add(results, BorderLayout.CENTER);
    try {
      // Load the driver (registers itself)
      Class.forName(
        "sun.jdbc.odbc.JdbcOdbcDriver");
      Connection c = DriverManager.getConnection(
        dbUrl, user, password);
      s = c.createStatement();
    } catch(Exception e) {
      results.setText(e.getMessage());
    }
 }
 class SearchForL implements TextListener {
    publicvoid textValueChanged(TextEvent te) {
      ResultSet r;
      if(searchFor.getText().length() == 0) {
        completion.setText("");
        results.setText("");
        return;
      }
      try {
        // Name completion:
        r = s.executeQuery(
          "SELECT LAST FROM people.csv people " +
          "WHERE (LAST Like '" +
          searchFor.getText() +
          "%') ORDER BY LAST");
        if(r.next())
          completion.setText(
            r.getString("last"));
        r = s.executeQuery(
          "SELECT FIRST, LAST, EMAIL " +
          "FROM people.csv people " +
          "WHERE (LAST='" +
          completion.getText() +
          "') AND (EMAIL Is Not Null) " +
          "ORDER BY FIRST");
      } catch(Exception e) {
        results.setText(
          searchFor.getText() + "/n");
        results.append(e.getMessage());
        return;
      }
      results.setText("");
      try {
        while(r.next()) {
          results.append(
            r.getString("Last") + ", "
            + r.getString("fIRST") +
            ": " + r.getString("EMAIL") + "/n");
        }
      } catch(Exception e) {
        results.setText(e.getMessage());
      }
    }
 }
 publicstaticvoid main(String[] args) {
    VLookup applet = new VLookup();
    Frame aFrame = new Frame("Email lookup");
    aFrame.addWindowListener(
      new WindowAdapter() {
        publicvoid windowClosing(WindowEvent e) {
          System.exit(0);
        }
      });
    aFrame.add(applet, BorderLayout.CENTER);
    aFrame.setSize(500,200);
    applet.init();
    applet.start();
    aFrame.setVisible(true);
 }
} ///:~

数据库的许多逻辑都是相同的,但大家可看到这里添加了一个TextListener,用于监视在TextField(文本字段)的输入。所以只要键入一个新字符,它首先就会试着查找数据库中的“姓”,并显示出与当前输入相符的第一条记录(将其置入completion Label,并用它作为要查找的文本)。因此,只要我们键入了足够的字符,使程序能找到与之相符的唯一一条记录,就可以停手了。

15.7.3 JDBC API为何如何复杂
阅览JDBC的联机帮助文档时,我们往往会产生畏难情绪。特别是DatabaseMetaData接口——与Java中看到的大多数接口相反,它的体积显得非常庞大——存在着数量众多的方法,比如dataDefinitionCausesTransactionCommit(),getMaxColumnNameLength(),getMaxStatementLength(),storesMixedCaseQuotedIdentifiers(),supportsANSI92IntermediateSQL(),supportsLimitedOuterJoins()等等。它们有这儿有什么意义吗?
正如早先指出的那样,数据库起初一直处于一种混乱状态。这主要是由于各种数据库应用提出的要求造成的,所以数据库工具显得非常“强大”——换言之,“庞大”。只是近几年才涌现出了SQL的通用语言(常用的还有其他许多数据库语言)。但即便象SQL这样的“标准”,也存在无数的变种,所以JDBC必须提供一个巨大的DatabaseMetaData接口,使我们的代码能真正利用当前要连接的一种“标准”SQL数据库的能力。简言之,我们可编写出简单的、能移植的SQL。但如果想优化代码的执行速度,那么为了适应不同数据库类型的特点,我们的编写代码的麻烦就大了。
当然,这并不是Java的缺陷。数据库产品之间的差异是我们和JDBC都要面对的一个现实。但是,如果能编写通用的查询,而不必太关心性能,那么事情就要简单得多。即使必须对性能作一番调整,只要知道最终面向的平台,也不必针对每一种情况都编写不同的优化代码。
在Sun发布的Java 1.1产品中,配套提供了一系列电子文档,其中有对JDBC更全面的介绍。此外,在由Hamilton Cattel和Fisher编著、Addison-Wesley于1997年出版的《JDBC Database Access with Java》中,也提供了有关这一主题的许多有用资料。同时,书店里也经常出现一些有关JDBC的新书。

15.8 远程方法
为通过网络执行其他机器上的代码,传统的方法不仅难以学习和掌握,也极易出错。思考这个问题最佳的方式是:某些对象正好位于另一台机器,我们可向它们发送一条消息,并获得返回结果,就象那些对象位于自己的本地机器一样。Java 1.1的“远程方法调用”(RMI)采用的正是这种抽象。本节将引导大家经历一些必要的步骤,创建自己的RMI对象。

15.8.1 远程接口概念
RMI对接口有着强烈的依赖。在需要创建一个远程对象的时候,我们通过传递一个接口来隐藏基层的实施细节。所以客户得到远程对象的一个句柄时,它们真正得到的是接口句柄。这个句柄正好同一些本地的根代码连接,由后者负责通过网络通信。但我们并不关心这些事情,只需通过自己的接口句柄发送消息即可。
创建一个远程接口时,必须遵守下列规则:
(1) 远程接口必须为public属性(不能有“包访问”;也就是说,它不能是“友好的”)。否则,一旦客户试图装载一个实现了远程接口的远程对象,就会得到一个错误。
(2) 远程接口必须扩展接口java.rmi.Remote。
(3) 除与应用程序本身有关的违例之外,远程接口中的每个方法都必须在自己的throws从句中声明java.rmi.RemoteException。
(4) 作为参数或返回值传递的一个远程对象(不管是直接的,还是在本地对象中嵌入)必须声明为远程接口,不可声明为实施类。

下面是一个简单的远程接口示例,它代表的是一个精确计时服务:
//: PerfectTimeI.java
// The PerfectTime remote interface
package c15.ptime;
import java.rmi.*;
 
interface PerfectTimeI extends Remote {
 long getPerfectTime() throws RemoteException;
} ///:~

它表面上与其他接口是类似的,只是对Remote进行了扩展,而且它的所有方法都会“掷”出RemoteException(远程违例)。记住接口和它所有的方法都是public的。

15.8.2 远程接口的实施
服务器必须包含一个扩展了UnicastRemoteObject的类,并实现远程接口。这个类也可以含有附加的方法,但客户只能使用远程接口中的方法。这是显然的,因为客户得到的只是指向接口的一个句柄,而非实现它的那个类。
必须为远程对象明确定义构建器,即使只准备定义一个默认构建器,用它调用基础类构建器。必须把它明确地编写出来,因为它必须“掷”出RemoteException违例。
下面列出远程接口PerfectTime的实施过程:
//: PerfectTime.java
// The implementation of the PerfectTime
// remote object
package c15.ptime;
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;
import java.net.*;
 
publicclass PerfectTime
    extends UnicastRemoteObject
    implements PerfectTimeI {
 // Implementation of the interface:
 publiclong getPerfectTime()
      throws RemoteException {
    return System.currentTimeMillis();
 }
 // Must implement constructor to throw
 // RemoteException:
 public PerfectTime() throws RemoteException {
    // super(); // Called automatically
 }
 // Registration for RMI serving:
 publicstaticvoid main(String[] args) {
    System.setSecurityManager(
      new RMISecurityManager());
    try {
      PerfectTime pt = new PerfectTime();
      Naming.bind(
        "//colossus:2005/PerfectTime", pt);
      System.out.println("Ready to do time");
    } catch(Exception e) {
      e.printStackTrace();
    }
 }
} ///:~

在这里,main()控制着设置服务器的全部细节。保存RMI对象时,必须在程序的某个地方采取下述操作:
(1) 创建和安装一个安全管理器,令其支持RMI。作为Java发行包的一部分,适用于RMI唯一一个是RMISecurityManager。
(2) 创建远程对象的一个或多个实例。在这里,大家可看到创建的是PerfectTime对象。
(3) 向RMI远程对象注册表注册至少一个远程对象。一个远程对象拥有的方法可生成指向其他远程对象的句柄。这样一来,客户只需到注册表里访问一次,得到第一个远程对象即可。

1. 设置注册表
在这儿,大家可看到对静态方法Naming.bind()的一个调用。然而,这个调用要求注册表作为计算机上的一个独立进程运行。注册表服务器的名字是rmiregistry。在32位Windows环境中,可使用:
start rmiregistry
令其在后台运行。在Unix中,使用:
rmiregistry &
和许多网络程序一样,rmiregistry位于机器启动它所在的某个IP地址处,但它也必须监视一个端口。如果象上面那样调用rmiregistry,不使用参数,注册表的端口就会默认为1099。若希望它位于其他某个端口,只需在命令行添加一个参数,指定那个端口编号即可。对这个例子来说,端口将位于2005,所以rmiregistry应该象下面这样启动(对于32位Windows):
start rmiregistry 2005
对于Unix,则使用下述命令:
rmiregistry 2005 &
与端口有关的信息必须传送给bind()命令,同时传送的还有注册表所在的那台机器的IP地址。但假若我们想在本地测试RMI程序,就象本章的网络程序一直测试的那样,这样做就会带来问题。在JDK 1.1.1版本中,存在着下述两方面的问题(注释⑦):
(1) localhost不能随RMI工作。所以为了在单独一台机器上完成对RMI的测试,必须提供机器的名字。为了在32位Windows环境中调查自己机器的名字,可进入控制面板,选择“网络”,选择“标识”卡片,其中列出了计算机的名字。就我自己的情况来说,我的机器叫作“Colossus”(因为我用几个大容量的硬盘保存各种不同的开发系统——Clossus是“巨人”的意思)。似乎大写形式会被忽略。
(2) 除非计算机有一个活动的TCP/IP连接,否则RMI不能工作,即使所有组件都只需要在本地机器里互相通信。这意味着在试图运行程序之前,必须连接到自己的ISP(因特网服务提供者),否则会得到一些含义模糊的违例消息。

⑦:为找出这些信息,我不知损伤了多少个脑细胞。

考虑到这些因素,bind()命令变成了下面这个样子:
Naming.bind("//colossus:2005/PerfectTime", pt);
若使用默认端口1099,就没有必要指定一个端口,所以可以使用:
Naming.bind("//colossus/PerfectTime", pt);
在JDK未来的版本中(1.1之后),一旦改正了localhost的问题,就能正常地进行本地测试,去掉IP地址,只使用标识符:
Naming.bind("PerfectTime", pt);
服务名是任意的;它在这里正好为PerfectTime,和类名一样,但你可以根据情况任意修改。最重要的是确保它在注册表里是个独一无二的名字,以便客户正常地获取远程对象。若这个名字已在注册表里了,就会得到一个AlreadyBoundException违例。为防止这个问题,可考虑坚持使用rebind(),放弃bind()。这是由于rebind()要么会添加一个新条目,要么将同名的条目替换掉。
尽管main()退出,我们的对象已经创建并注册,所以会由注册表一直保持活动状态,等候客户到达并发出对它的请求。只要rmiregistry处于运行状态,而且我们没有为名字调用Naming.unbind()方法,对象就肯定位于那个地方。考虑到这个原因,在我们设计自己的代码时,需要先关闭rmiregistry,并在编译远程对象的一个新版本时重新启动它。
并不一定要将rmiregistry作为一个外部进程启动。若事前知道自己的是要求用以注册表的唯一一个应用,就可在程序内部启动它,使用下述代码:
LocateRegistry.createRegistry(2005);
和前面一样,2005代表我们在这个例子里选用的端口号。这等价于在命令行执行rmiregistry 2005。但在设计RMI代码时,这种做法往往显得更加方便,因为它取消了启动和中止注册表所需的额外步骤。一旦执行完这个代码,就可象以前一样使用Naming进行“绑定”——bind()。

15.8.3 创建根与干
若编译和运行PerfectTime.java,即使rmiregistry正确运行,它也无法工作。这是由于RMI的框架尚未就位。首先必须创建根和干,以便提供网络连接操作,并使我们将远程对象伪装成自己机器内的某个本地对象。
所有这些幕后的工作都是相当复杂的。我们从远程对象传入、传出的任何对象都必须“implement Serializable”(如果想传递远程引用,而非整个对象,对象的参数就可以“implement Remote”)。因此可以想象,当根和干通过网络“汇集”所有参数并返回结果的时候,会自动进行序列化以及数据的重新装配。幸运的是,我们根本没必要了解这些方面的任何细节,但根和干却是必须创建的。一个简单的过程如下:在编译好的代码中调用rmic,它会创建必需的一些文件。所以唯一要做的事情就是为编译过程新添一个步骤。
然而,rmic工具与特定的包和类路径有很大的关联。PerfectTime.java位于包c15.Ptime中,即使我们调用与PerfectTime.class同一目录内的rmic,rmic都无法找到文件。这是由于它搜索的是类路径。因此,我们必须同时指定类路径,就象下面这样:
rmic c15.PTime.PerfectTime
执行这个命令时,并不一定非要在包含了PerfectTime.class的目录中,但结果会置于当前目录。
若rmic成功运行,目录里就会多出两个新类:
PerfectTime_Stub.class
PerfectTime_Skel.class
它们分别对应根(Stub)和干(Skeleton)。现在,我们已准备好让服务器与客户互相沟通了。

15.8.4 使用远程对象
RMI全部的宗旨就是尽可能简化远程对象的使用。我们在客户程序中要做的唯一一件额外的事情就是查找并从服务器取回远程接口。自此以后,剩下的事情就是普通的Java编程:将消息发给对象。下面是使用PerfectTime的程序:
//: DisplayPerfectTime.java
// Uses remote object PerfectTime
package c15.ptime;
import java.rmi.*;
import java.rmi.registry.*;
 
publicclass DisplayPerfectTime {
 publicstaticvoid main(String[] args) {
    System.setSecurityManager(
      new RMISecurityManager());
    try {
      PerfectTimeI t =
        (PerfectTimeI)Naming.lookup(
          "//colossus:2005/PerfectTime");
      for(int i = 0; i < 10; i++)
        System.out.println("Perfect time = " +
          t.getPerfectTime());
    } catch(Exception e) {
      e.printStackTrace();
    }
 }
} ///:~

ID
字串与那个用Naming注册对象的那个字串是相同的,第一部分指出了URL和端口号。由于我们准备使用一个URL,所以也可以指定因特网上的一台机器。
从Naming.lookup()返回的必须造型到远程接口,而不是到类。若换用类,会得到一个违例提示。
在下述方法调用中:
t.getPerfectTime( )
我们可看到一旦获得远程对象的句柄,用它进行的编程与用本地对象的编程是非常相似(仅有一个区别:远程方法会“掷”出一个RemoteException违例)。

15.8.5 RMI的替选方案
RMI只是一种创建特殊对象的方式,它创建的对象可通过网络发布。它最大的优点就是提供了一种“纯Java”方案,但假如已经有许多用其他语言编写的代码,则RMI可能无法满足我们的要求。目前,两种最具竞争力的替选方案是微软的DCOM(根据微软的计划,它最终会移植到除Windows以外的其他平台)以及CORBA。CORBA自Java 1.1便开始支持,是一种全新设计的概念,面向跨平台应用。在由Orfali和Harkey编著的《Client/Server Programming with Java and CORBA》一书中(John Wiley&Sons 1997年出版),大家可获得对Java中的分布式对象的全面介绍(该书似乎对CORBA似乎有些偏见)。为CORBA赋予一个较公正的对待的一本书是由Andreas Vogel和Keith Duddy编写的《Java Programming with CORBA》,John Wiley&Sons于1997年出版。

15.9 总结
由于篇幅所限,还有其他许多涉及连网的概念没有介绍给大家。Java也为URL提供了相当全面的支持,包括为因特网上不同类型的客户提供协议控制器等等。
除此以外,一种正在逐步流行的技术叫作Servlet Server。它是一种因特网服务器应用,通过Java控制客户请求,而非使用以前那种速度很慢、且相当麻烦的CGI(通用网关接口)协议。这意味着为了在服务器那一端提供服务,我们可以用Java编程,不必使用自己不熟悉的其他语言。由于Java具有优秀的移植能力,所以不必关心具体容纳这个服务器是什么平台。

 

相关文章推荐

黑马程序员——Java学习总结:多线程和网络编程

1、多线程概述什么是多线程??? 一个应用程序有多条执行路径,线程是依赖于进程而存在的。 二、多线程的实现方式一 1、创建多线程的方式一? A创建一个类这个类继承Thread类 B重写ru...

Java - 网络编程PPT

  • 2017年10月30日 15:15
  • 1.77MB
  • 下载

Java基础——网络编程

一.网路编程知识 意义:过去我们IO流是把本地的文件传递而已,网络编程是把自己电脑的数据传递给另一台电脑,并且回馈信息。这是数据通讯 1.通讯三要素 1.1 IP地址 (1)获取对方主机IP 1.2 ...

Java网络编程精解_孙卫琴PDF

  • 2017年04月03日 22:20
  • 46.5MB
  • 下载

java网络编程实验

  • 2015年09月15日 21:51
  • 117KB
  • 下载

Java网络编程以及简单的聊天程序

网络编程技术是互联网技术中的主流编程技术之一,懂的一些基本的操作是非常必要的。这章主要讲解网络编程,UDP和Socket编程,以及使用Socket做一个简单的聊天软件。...

JAVA_网络编程_Socket

  • 2016年05月30日 11:41
  • 6KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:java网络编程
举报原因:
原因补充:

(最多只允许输入30个字)