-------------------------------------------------
本教程由yyc,spirit整理
-------------------------------------------------
網(wǎng)絡(luò)編程
歷史上的網(wǎng)絡(luò)編程都傾向于困難、復(fù)雜，而且極易出錯(cuò)。
程序員必須掌握與網(wǎng)絡(luò)有關(guān)的大量細(xì)節(jié)，有時(shí)甚至要對(duì)硬件有深刻的認(rèn)識(shí)。一般地，我們需要理解連網(wǎng)協(xié)議中不同的“層”（Layer）。而且對(duì)于每個(gè)連網(wǎng)庫(kù)，一般都包含了數(shù)量眾多的函數(shù)，分別涉及信息塊的連接、打包和拆包；這些塊的來回運(yùn)輸；以及握手等等。這是一項(xiàng)令人痛苦的工作。
但是，連網(wǎng)本身的概念并不是很難。我們想獲得位于其他地方某臺(tái)機(jī)器上的信息，并把它們移到這兒；或者相反。這與讀寫文件非常相似，只是文件存在于遠(yuǎn)程機(jī)器上，而且遠(yuǎn)程機(jī)器有權(quán)決定如何處理我們請(qǐng)求或者發(fā)送的數(shù)據(jù)。
Java最出色的一個(gè)地方就是它的“無(wú)痛苦連網(wǎng)”概念。有關(guān)連網(wǎng)的基層細(xì)節(jié)已被盡可能地提取出去，并隱藏在JVM以及Java的本機(jī)安裝系統(tǒng)里進(jìn)行控制。我們使用的編程模型是一個(gè)文件的模型；事實(shí)上，網(wǎng)絡(luò)連接（一個(gè)“套接字”）已被封裝到系統(tǒng)對(duì)象里，所以可象對(duì)其他數(shù)據(jù)流那樣采用同樣的方法調(diào)用。除此以外，在我們處理另一個(gè)連網(wǎng)問題——同時(shí)控制多個(gè)網(wǎng)絡(luò)連接——的時(shí)候，Java內(nèi)建的多線程機(jī)制也是十分方便的。
本章將用一系列易懂的例子解釋Java的連網(wǎng)支持。
15.1 機(jī)器的標(biāo)識(shí)
當(dāng)然，為了分辨來自別處的一臺(tái)機(jī)器，以及為了保證自己連接的是希望的那臺(tái)機(jī)器，必須有一種機(jī)制能獨(dú)一無(wú)二地標(biāo)識(shí)出網(wǎng)絡(luò)內(nèi)的每臺(tái)機(jī)器。早期網(wǎng)絡(luò)只解決了如何在本地網(wǎng)絡(luò)環(huán)境中為機(jī)器提供唯一的名字。但Java面向的是整個(gè)因特網(wǎng)，這要求用一種機(jī)制對(duì)來自世界各地的機(jī)器進(jìn)行標(biāo)識(shí)。為達(dá)到這個(gè)目的，我們采用了IP（互聯(lián)網(wǎng)地址）的概念。IP以兩種形式存在著：
(1) 大家最熟悉的DNS（域名服務(wù)）形式。我自己的域名是bruceeckel.com。所以假定我在自己的域內(nèi)有一臺(tái)名為Opus的計(jì)算機(jī)，它的域名就可以是Opus.bruceeckel.com。這正是大家向其他人發(fā)送電子函件時(shí)采用的名字，而且通常集成到一個(gè)萬(wàn)維網(wǎng)（WWW）地址里。
(2) 此外，亦可采用“四點(diǎn)”格式，亦即由點(diǎn)號(hào)（.）分隔的四組數(shù)字，比如202.98.32.111。
不管哪種情況，IP地址在內(nèi)部都表達(dá)成一個(gè)由32個(gè)二進(jìn)制位（bit）構(gòu)成的數(shù)字（注釋①），所以IP地址的每一組數(shù)字都不能超過255。利用由java.net提供的static InetAddress.getByName()，我們可以讓一個(gè)特定的Java對(duì)象表達(dá)上述任何一種形式的數(shù)字。結(jié)果是類型為InetAddress的一個(gè)對(duì)象，可用它構(gòu)成一個(gè)“套接字”（Socket），大家在后面會(huì)見到這一點(diǎn)。
①：這意味著最多只能得到40億左右的數(shù)字組合，全世界的人很快就會(huì)把它用光。但根據(jù)目前正在研究的新IP編址方案，它將采用128 bit的數(shù)字，這樣得到的唯一性IP地址也許在幾百年的時(shí)間里都不會(huì)用完。
作為運(yùn)用InetAddress.getByName()一個(gè)簡(jiǎn)單的例子，請(qǐng)考慮假設(shè)自己有一家撥號(hào)連接因特網(wǎng)服務(wù)提供者（ISP），那么會(huì)發(fā)生什么情況。每次撥號(hào)連接的時(shí)候，都會(huì)分配得到一個(gè)臨時(shí)IP地址。但在連接期間，那個(gè)IP地址擁有與因特網(wǎng)上其他IP地址一樣的有效性。如果有人按照你的IP地址連接你的機(jī)器，他們就有可能使用在你機(jī)器上運(yùn)行的Web或者FTP服務(wù)器程序。當(dāng)然這有個(gè)前提，對(duì)方必須準(zhǔn)確地知道你目前分配到的IP。由于每次撥號(hào)連接獲得的IP都是隨機(jī)的，怎樣才能準(zhǔn)確地掌握你的IP呢？
下面這個(gè)程序利用InetAddress.getByName()來產(chǎn)生你的IP地址。為了讓它運(yùn)行起來，事先必須知道計(jì)算機(jī)的名字。該程序只在Windows 95中進(jìn)行了測(cè)試，但大家可以依次進(jìn)入自己的“開始”、“設(shè)置”、“控制面板”、“網(wǎng)絡(luò)”，然后進(jìn)入“標(biāo)識(shí)”卡片。其中，“計(jì)算機(jī)名稱”就是應(yīng)在命令行輸入的內(nèi)容。
//: WhoAmI.java
// Finds out your network address when you're
// connected to the Internet.
package c15;
import java.net.*;
public class WhoAmI {
public static void 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);
}
} ///:~
就我自己的情況來說，機(jī)器的名字叫作“Colossus”（來自同名電影，“巨人”的意思。我在這臺(tái)機(jī)器上有一個(gè)很大的硬盤）。所以一旦連通我的ISP，就象下面這樣執(zhí)行程序：
java whoAmI Colossus
得到的結(jié)果象下面這個(gè)樣子（當(dāng)然，這個(gè)地址可能每次都是不同的）：
Colossus/202.98.41.151
假如我把這個(gè)地址告訴一位朋友，他就可以立即登錄到我的個(gè)人Web服務(wù)器，只需指定目標(biāo)地址http://202.98.41.151即可（當(dāng)然，我此時(shí)不能斷線）。有些時(shí)候，這是向其他人發(fā)送信息或者在自己的Web站點(diǎn)正式出臺(tái)以前進(jìn)行測(cè)試的一種方便手段。
15.1.1 服務(wù)器和客戶機(jī)
網(wǎng)絡(luò)最基本的精神就是讓兩臺(tái)機(jī)器連接到一起，并相互“交談”或者“溝通”。一旦兩臺(tái)機(jī)器都發(fā)現(xiàn)了對(duì)方，就可以展開一次令人愉快的雙向?qū)υ挕５鼈冊(cè)鯓硬拍堋鞍l(fā)現(xiàn)”對(duì)方呢？這就象在游樂園里那樣：一臺(tái)機(jī)器不得不停留在一個(gè)地方，偵聽其他機(jī)器說：“嘿，你在哪里呢？”
“停留在一個(gè)地方”的機(jī)器叫作“服務(wù)器”（Server）；到處“找人”的機(jī)器則叫作“客戶機(jī)”（Client）或者“客戶”。它們之間的區(qū)別只有在客戶機(jī)試圖同服務(wù)器連接的時(shí)候才顯得非常明顯。一旦連通，就變成了一種雙向通信，誰(shuí)來扮演服務(wù)器或者客戶機(jī)便顯得不那么重要了。
所以服務(wù)器的主要任務(wù)是偵聽建立連接的請(qǐng)求，這是由我們創(chuàng)建的特定服務(wù)器對(duì)象完成的。而客戶機(jī)的任務(wù)是試著與一臺(tái)服務(wù)器建立連接，這是由我們創(chuàng)建的特定客戶機(jī)對(duì)象完成的。一旦連接建好，那么無(wú)論在服務(wù)器端還是客戶機(jī)端，連接只是魔術(shù)般地變成了一個(gè)IO數(shù)據(jù)流對(duì)象。從這時(shí)開始，我們可以象讀寫一個(gè)普通的文件那樣對(duì)待連接。所以一旦建好連接，我們只需象第10章那樣使用自己熟悉的IO命令即可。這正是Java連網(wǎng)最方便的一個(gè)地方。
1. 在沒有網(wǎng)絡(luò)的前提下測(cè)試程序
由于多種潛在的原因，我們可能沒有一臺(tái)客戶機(jī)、服務(wù)器以及一個(gè)網(wǎng)絡(luò)來測(cè)試自己做好的程序。我們也許是在一個(gè)課堂環(huán)境中進(jìn)行練習(xí)，或者寫出的是一個(gè)不十分可靠的網(wǎng)絡(luò)應(yīng)用，還能拿到網(wǎng)絡(luò)上去。IP的設(shè)計(jì)者注意到了這個(gè)問題，并建立了一個(gè)特殊的地址——localhost——來滿足非網(wǎng)絡(luò)環(huán)境中的測(cè)試要求。在Java中產(chǎn)生這個(gè)地址最一般的做法是：
InetAddress addr = InetAddress.getByName(null);
如果向getByName()傳遞一個(gè)null（空）值，就默認(rèn)為使用localhost。我們用InetAddress對(duì)特定的機(jī)器進(jìn)行索引，而且必須在進(jìn)行進(jìn)一步的操作之前得到這個(gè)InetAddress（互聯(lián)網(wǎng)地址）。我們不可以操縱一個(gè)InetAddress的內(nèi)容（但可把它打印出來，就象下一個(gè)例子要演示的那樣）。創(chuàng)建InetAddress的唯一途徑就是那個(gè)類的static（靜態(tài)）成員方法getByName()（這是最常用的）、getAllByName()或者getLocalHost()。
為得到本地主機(jī)地址，亦可向其直接傳遞字串"localhost"：
InetAddress.getByName("localhost");
或者使用它的保留IP地址（四點(diǎn)形式），就象下面這樣：
InetAddress.getByName("127.0.0.1");
這三種方法得到的結(jié)果是一樣的。
15.1.2 端口：機(jī)器內(nèi)獨(dú)一無(wú)二的場(chǎng)所
有些時(shí)候，一個(gè)IP地址并不足以完整標(biāo)識(shí)一個(gè)服務(wù)器。這是由于在一臺(tái)物理性的機(jī)器中，往往運(yùn)行著多個(gè)服務(wù)器（程序）。由IP表達(dá)的每臺(tái)機(jī)器也包含了“端口”（Port）。我們?cè)O(shè)置一個(gè)客戶機(jī)或者服務(wù)器的時(shí)候，必須選擇一個(gè)無(wú)論客戶機(jī)還是服務(wù)器都認(rèn)可連接的端口。就象我們?nèi)グ輹?huì)某人時(shí)，IP地址是他居住的房子，而端口是他在的那個(gè)房間。
注意端口并不是機(jī)器上一個(gè)物理上存在的場(chǎng)所，而是一種軟件抽象（主要是為了表述的方便）。客戶程序知道如何通過機(jī)器的IP地址同它連接，但怎樣才能同自己真正需要的那種服務(wù)連接呢（一般每個(gè)端口都運(yùn)行著一種服務(wù)，一臺(tái)機(jī)器可能提供了多種服務(wù)，比如HTTP和FTP等等）？端口編號(hào)在這里扮演了重要的角色，它是必需的一種二級(jí)定址措施。也就是說，我們請(qǐng)求一個(gè)特定的端口，便相當(dāng)于請(qǐng)求與那個(gè)端口編號(hào)關(guān)聯(lián)的服務(wù)。“報(bào)時(shí)”便是服務(wù)的一個(gè)典型例子。通常，每個(gè)服務(wù)都同一臺(tái)特定服務(wù)器機(jī)器上的一個(gè)獨(dú)一無(wú)二的端口編號(hào)關(guān)聯(lián)在一起。客戶程序必須事先知道自己要求的那項(xiàng)服務(wù)的運(yùn)行端口號(hào)。
系統(tǒng)服務(wù)保留了使用端口1到端口1024的權(quán)力，所以不應(yīng)讓自己設(shè)計(jì)的服務(wù)占用這些以及其他任何已知正在使用的端口。本書的第一個(gè)例子將使用端口8080（為追憶我的第一臺(tái)機(jī)器使用的老式8位Intel 8080芯片，那是一部使用CP/M操作系統(tǒng)的機(jī)子）。
15.2 套接字
“套接字”或者“插座”（Socket）也是一種軟件形式的抽象，用于表達(dá)兩臺(tái)機(jī)器間一個(gè)連接的“終端”。針對(duì)一個(gè)特定的連接，每臺(tái)機(jī)器上都有一個(gè)“套接字”，可以想象它們之間有一條虛擬的“線纜”。線纜的每一端都插入一個(gè)“套接字”或者“插座”里。當(dāng)然，機(jī)器之間的物理性硬件以及電纜連接都是完全未知的。抽象的基本宗旨是讓我們盡可能不必知道那些細(xì)節(jié)。
在Java中，我們創(chuàng)建一個(gè)套接字，用它建立與其他機(jī)器的連接。從套接字得到的結(jié)果是一個(gè)InputStream以及OutputStream（若使用恰當(dāng)?shù)霓D(zhuǎn)換器，則分別是Reader和Writer），以便將連接作為一個(gè)IO流對(duì)象對(duì)待。有兩個(gè)基于數(shù)據(jù)流的套接字類：ServerSocket，服務(wù)器用它“偵聽”進(jìn)入的連接；以及Socket，客戶用它初始一次連接。一旦客戶（程序）申請(qǐng)建立一個(gè)套接字連接，ServerSocket就會(huì)返回（通過accept()方法）一個(gè)對(duì)應(yīng)的服務(wù)器端套接字，以便進(jìn)行直接通信。從此時(shí)起，我們就得到了真正的“套接字－套接字”連接，可以用同樣的方式對(duì)待連接的兩端，因?yàn)樗鼈儽緛砭褪窍嗤模〈藭r(shí)可以利用getInputStream()以及getOutputStream()從每個(gè)套接字產(chǎn)生對(duì)應(yīng)的InputStream和OutputStream對(duì)象。這些數(shù)據(jù)流必須封裝到緩沖區(qū)內(nèi)。可按第10章介紹的方法對(duì)類進(jìn)行格式化，就象對(duì)待其他任何流對(duì)象那樣。
對(duì)于Java庫(kù)的命名機(jī)制，ServerSocket（服務(wù)器套接字）的使用無(wú)疑是容易產(chǎn)生混淆的又一個(gè)例證。大家可能認(rèn)為ServerSocket最好叫作“ServerConnector”（服務(wù)器連接器），或者其他什么名字，只是不要在其中安插一個(gè)“Socket”。也可能以為ServerSocket和Socket都應(yīng)從一些通用的基礎(chǔ)類繼承。事實(shí)上，這兩種類確實(shí)包含了幾個(gè)通用的方法，但還不夠資格把它們賦給一個(gè)通用的基礎(chǔ)類。相反，ServerSocket的主要任務(wù)是在那里耐心地等候其他機(jī)器同它連接，再返回一個(gè)實(shí)際的Socket。這正是“ServerSocket”這個(gè)命名不恰當(dāng)?shù)牡胤剑驗(yàn)樗哪繕?biāo)不是真的成為一個(gè)Socket，而是在其他人同它連接的時(shí)候產(chǎn)生一個(gè)Socket對(duì)象。
然而，ServerSocket確實(shí)會(huì)在主機(jī)上創(chuàng)建一個(gè)物理性的“服務(wù)器”或者偵聽用的套接字。這個(gè)套接字會(huì)偵聽進(jìn)入的連接，然后利用accept()方法返回一個(gè)“已建立”套接字（本地和遠(yuǎn)程端點(diǎn)均已定義）。容易混淆的地方是這兩個(gè)套接字（偵聽和已建立）都與相同的服務(wù)器套接字關(guān)聯(lián)在一起。偵聽套接字只能接收新的連接請(qǐng)求，不能接收實(shí)際的數(shù)據(jù)包。所以盡管ServerSocket對(duì)于編程并無(wú)太大的意義，但它確實(shí)是“物理性”的。
創(chuàng)建一個(gè)ServerSocket時(shí)，只需為其賦予一個(gè)端口編號(hào)。不必把一個(gè)IP地址分配它，因?yàn)樗呀?jīng)在自己代表的那臺(tái)機(jī)器上了。但在創(chuàng)建一個(gè)Socket時(shí)，卻必須同時(shí)賦予IP地址以及要連接的端口編號(hào)（另一方面，從ServerSocket.accept()返回的Socket已經(jīng)包含了所有這些信息）。
15.2.1 一個(gè)簡(jiǎn)單的服務(wù)器和客戶機(jī)程序
這個(gè)例子將以最簡(jiǎn)單的方式運(yùn)用套接字對(duì)服務(wù)器和客戶機(jī)進(jìn)行操作。服務(wù)器的全部工作就是等候建立一個(gè)連接，然后用那個(gè)連接產(chǎn)生的Socket創(chuàng)建一個(gè)InputStream以及一個(gè)OutputStream。在這之后，它從InputStream讀入的所有東西都會(huì)反饋給OutputStream，直到接收到行中止（END）為止，最后關(guān)閉連接。
客戶機(jī)連接與服務(wù)器的連接，然后創(chuàng)建一個(gè)OutputStream。文本行通過OutputStream發(fā)送。客戶機(jī)也會(huì)創(chuàng)建一個(gè)InputStream，用它收聽服務(wù)器說些什么（本例只不過是反饋回來的同樣的字句）。
服務(wù)器與客戶機(jī)（程序）都使用同樣的端口號(hào)，而且客戶機(jī)利用本地主機(jī)地址連接位于同一臺(tái)機(jī)器中的服務(wù)器（程序），所以不必在一個(gè)物理性的網(wǎng)絡(luò)里完成測(cè)試（在某些配置環(huán)境中，可能需要同真正的網(wǎng)絡(luò)建立連接，否則程序不能工作——盡管實(shí)際并不通過那個(gè)網(wǎng)絡(luò)通信）。
下面是服務(wù)器程序：
//: JabberServer.java
// Very simple server that just
// echoes whatever the client sends.
import java.io.*;
import java.net.*;
public class JabberServer {
// Choose a port outside of the range 1-1024:
public static final int PORT = 8080;
public static void 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需要的只是一個(gè)端口編號(hào)，不需要IP地址（因?yàn)樗驮谶@臺(tái)機(jī)器上運(yùn)行）。調(diào)用accept()時(shí)，方法會(huì)暫時(shí)陷入停頓狀態(tài)（堵塞），直到某個(gè)客戶嘗試同它建立連接。換言之，盡管它在那里等候連接，但其他進(jìn)程仍能正常運(yùn)行（參考第14章）。建好一個(gè)連接以后，accept()就會(huì)返回一個(gè)Socket對(duì)象，它是那個(gè)連接的代表。
清除套接字的責(zé)任在這里得到了很藝術(shù)的處理。假如ServerSocket構(gòu)建器失敗，則程序簡(jiǎn)單地退出（注意必須保證ServerSocket的構(gòu)建器在失敗之后不會(huì)留下任何打開的網(wǎng)絡(luò)套接字）。針對(duì)這種情況，main()會(huì)“擲”出一個(gè)IOException違例，所以不必使用一個(gè)try塊。若ServerSocket構(gòu)建器成功執(zhí)行，則其他所有方法調(diào)用都必須到一個(gè)try-finally代碼塊里尋求保護(hù)，以確保無(wú)論塊以什么方式留下，ServerSocket都能正確地關(guān)閉。
同樣的道理也適用于由accept()返回的Socket。若accept()失敗，那么我們必須保證Socket不再存在或者含有任何資源，以便不必清除它們。但假若執(zhí)行成功，則后續(xù)的語(yǔ)句必須進(jìn)入一個(gè)try-finally塊內(nèi)，以保障在它們失敗的情況下，Socket仍能得到正確的清除。由于套接字使用了重要的非內(nèi)存資源，所以在這里必須特別謹(jǐn)慎，必須自己動(dòng)手將它們清除（Java中沒有提供“破壞器”來幫助我們做這件事情）。
無(wú)論ServerSocket還是由accept()產(chǎn)生的Socket都打印到System.out里。這意味著它們的toString方法會(huì)得到自動(dòng)調(diào)用。這樣便產(chǎn)生了：
ServerSocket[addr=0.0.0.0,PORT=0,localport=8080]
Socket[addr=127.0.0.1,PORT=1077,localport=8080]
大家不久就會(huì)看到它們?nèi)绾闻c客戶程序做的事情配合。
程序的下一部分看來似乎僅僅是打開文件，以便讀取和寫入，只是InputStream和OutputStream是從Socket對(duì)象創(chuàng)建的。利用兩個(gè)“轉(zhuǎn)換器”類InputStreamReader和OutputStreamWriter，InputStream和OutputStream對(duì)象已經(jīng)分別轉(zhuǎn)換成為Java 1.1的Reader和Writer對(duì)象。也可以直接使用Java1.0的InputStream和OutputStream類，但對(duì)輸出來說，使用Writer方式具有明顯的優(yōu)勢(shì)。這一優(yōu)勢(shì)是通過PrintWriter表現(xiàn)出來的，它有一個(gè)過載的構(gòu)建器，能獲取第二個(gè)參數(shù)——一個(gè)布爾值標(biāo)志，指向是否在每一次println()結(jié)束的時(shí)候自動(dòng)刷新輸出（但不適用于print()語(yǔ)句）。每次寫入了輸出內(nèi)容后（寫進(jìn)out），它的緩沖區(qū)必須刷新，使信息能正式通過網(wǎng)絡(luò)傳遞出去。對(duì)目前這個(gè)例子來說，刷新顯得尤為重要，因?yàn)榭蛻艉头?wù)器在采取下一步操作之前都要等待一行文本內(nèi)容的到達(dá)。若刷新沒有發(fā)生，那么信息不會(huì)進(jìn)入網(wǎng)絡(luò)，除非緩沖區(qū)滿（溢出），這會(huì)為本例帶來許多問題。
編寫網(wǎng)絡(luò)應(yīng)用程序時(shí)，需要特別注意自動(dòng)刷新機(jī)制的使用。每次刷新緩沖區(qū)時(shí)，必須創(chuàng)建和發(fā)出一個(gè)數(shù)據(jù)包（數(shù)據(jù)封）。就目前的情況來說，這正是我們所希望的，因?yàn)榧偃绨鼉?nèi)包含了還沒有發(fā)出的文本行，服務(wù)器和客戶機(jī)之間的相互“握手”就會(huì)停止。換句話說，一行的末尾就是一條消息的末尾。但在其他許多情況下，消息并不是用行分隔的，所以不如不用自動(dòng)刷新機(jī)制，而用內(nèi)建的緩沖區(qū)判決機(jī)制來決定何時(shí)發(fā)送一個(gè)數(shù)據(jù)包。這樣一來，我們可以發(fā)出較大的數(shù)據(jù)包，而且處理進(jìn)程也能加快。
注意和我們打開的幾乎所有數(shù)據(jù)流一樣，它們都要進(jìn)行緩沖處理。本章末尾有一個(gè)練習(xí)，清楚展現(xiàn)了假如我們不對(duì)數(shù)據(jù)流進(jìn)行緩沖，那么會(huì)得到什么樣的后果（速度會(huì)變慢）。
無(wú)限while循環(huán)從BufferedReader in內(nèi)讀取文本行，并將信息寫入System.out，然后寫入PrintWriter.out。注意這可以是任何數(shù)據(jù)流，它們只是在表面上同網(wǎng)絡(luò)連接。
客戶程序發(fā)出包含了"END"的行后，程序會(huì)中止循環(huán)，并關(guān)閉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.*;
public class JabberClient {
public static void 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()中，大家可看到獲得本地主機(jī)IP地址的InetAddress的三種途徑：使用null，使用localhost，或者直接使用保留地址127.0.0.1。當(dāng)然，如果想通過網(wǎng)絡(luò)同一臺(tái)遠(yuǎn)程主機(jī)連接，也可以換用那臺(tái)機(jī)器的IP地址。打印出InetAddress addr后（通過對(duì)toString()方法的自動(dòng)調(diào)用），結(jié)果如下：
localhost/127.0.0.1
通過向getByName()傳遞一個(gè)null，它會(huì)默認(rèn)尋找localhost，并生成特殊的保留地址127.0.0.1。注意在名為socket的套接字創(chuàng)建時(shí)，同時(shí)使用了InetAddress以及端口號(hào)。打印這樣的某個(gè)Socket對(duì)象時(shí)，為了真正理解它的含義，請(qǐng)記住一次獨(dú)一無(wú)二的因特網(wǎng)連接是用下述四種數(shù)據(jù)標(biāo)識(shí)的：clientHost（客戶主機(jī)）、clientPortNumber（客戶端口號(hào)）、serverHost（服務(wù)主機(jī)）以及serverPortNumber（服務(wù)端口號(hào)）。服務(wù)程序啟動(dòng)后，會(huì)在本地主機(jī)（127.0.0.1）上建立為它分配的端口（8080）。一旦客戶程序發(fā)出請(qǐng)求，機(jī)器上下一個(gè)可用的端口就會(huì)分配給它（這種情況下是1077），這一行動(dòng)也在與服務(wù)程序相同的機(jī)器（127.0.0.1）上進(jìn)行。現(xiàn)在，為了使數(shù)據(jù)能在客戶及服務(wù)程序之間來回傳送，每一端都需要知道把數(shù)據(jù)發(fā)到哪里。所以在同一個(gè)“已知”服務(wù)程序連接的時(shí)候，客戶會(huì)發(fā)出一個(gè)“返回地址”，使服務(wù)器程序知道將自己的數(shù)據(jù)發(fā)到哪兒。我們?cè)诜?wù)器端的示范輸出中可以體會(huì)到這一情況：
Socket[addr=127.0.0.1,port=1077,localport=8080]
這意味著服務(wù)器剛才已接受了來自127.0.0.1這臺(tái)機(jī)器的端口1077的連接，同時(shí)監(jiān)聽自己的本地端口（8080）。而在客戶端：
Socket[addr=localhost/127.0.0.1,PORT=8080,localport=1077]
這意味著客戶已用自己的本地端口1077與127.0.0.1機(jī)器上的端口8080建立了 連接。
大家會(huì)注意到每次重新啟動(dòng)客戶程序的時(shí)候，本地端口的編號(hào)都會(huì)增加。這個(gè)編號(hào)從1025（剛好在系統(tǒng)保留的1-1024之外）開始，并會(huì)一直增加下去，除非我們重啟機(jī)器。若重新啟動(dòng)機(jī)器，端口號(hào)仍然會(huì)從1025開始增值（在Unix機(jī)器中，一旦超過保留的套按字范圍，數(shù)字就會(huì)再次從最小的可用數(shù)字開始）。
創(chuàng)建好Socket對(duì)象后，將其轉(zhuǎn)換成BufferedReader和PrintWriter的過程便與在服務(wù)器中相同（同樣地，兩種情況下都要從一個(gè)Socket開始）。在這里，客戶通過發(fā)出字串"howdy"，并在后面跟隨一個(gè)數(shù)字，從而初始化通信。注意緩沖區(qū)必須再次刷新（這是自動(dòng)發(fā)生的，通過傳遞給PrintWriter構(gòu)建器的第二個(gè)參數(shù)）。若緩沖區(qū)沒有刷新，那么整個(gè)會(huì)話（通信）都會(huì)被掛起，因?yàn)橛糜诔跏蓟摹癶owdy”永遠(yuǎn)不會(huì)發(fā)送出去（緩沖區(qū)不夠滿，不足以造成發(fā)送動(dòng)作的自動(dòng)進(jìn)行）。從服務(wù)器返回的每一行都會(huì)寫入System.out，以驗(yàn)證一切都在正常運(yùn)轉(zhuǎn)。為中止會(huì)話，需要發(fā)出一個(gè)"END"。若客戶程序簡(jiǎn)單地掛起，那么服務(wù)器會(huì)“擲”出一個(gè)違例。
大家在這里可以看到我們采用了同樣的措施來確保由Socket代表的網(wǎng)絡(luò)資源得到正確的清除，這是用一個(gè)try-finally塊實(shí)現(xiàn)的。
套接字建立了一個(gè)“專用”連接，它會(huì)一直持續(xù)到明確斷開連接為止（專用連接也可能間接性地?cái)嚅_，前提是某一端或者中間的某條鏈路出現(xiàn)故障而崩潰）。這意味著參與連接的雙方都被鎖定在通信中，而且無(wú)論是否有數(shù)據(jù)傳遞，連接都會(huì)連續(xù)處于開放狀態(tài)。從表面看，這似乎是一種合理的連網(wǎng)方式。然而，它也為網(wǎng)絡(luò)帶來了額外的開銷。本章后面會(huì)介紹進(jìn)行連網(wǎng)的另一種方式。采用那種方式，連接的建立只是暫時(shí)的。
15.3 服務(wù)多個(gè)客戶
JabberServer可以正常工作，但每次只能為一個(gè)客戶程序提供服務(wù)。在典型的服務(wù)器中，我們希望同時(shí)能處理多個(gè)客戶的請(qǐng)求。解決這個(gè)問題的關(guān)鍵就是多線程處理機(jī)制。而對(duì)于那些本身不支持多線程的語(yǔ)言，達(dá)到這個(gè)要求無(wú)疑是異常困難的。通過第14章的學(xué)習(xí)，大家已經(jīng)知道Java已對(duì)多線程的處理進(jìn)行了盡可能的簡(jiǎn)化。由于Java的線程處理方式非常直接，所以讓服務(wù)器控制多名客戶并不是件難事。
最基本的方法是在服務(wù)器（程序）里創(chuàng)建單個(gè)ServerSocket，并調(diào)用accept()來等候一個(gè)新連接。一旦accept()返回，我們就取得結(jié)果獲得的Socket，并用它新建一個(gè)線程，令其只為那個(gè)特定的客戶服務(wù)。然后再調(diào)用accept()，等候下一次新的連接請(qǐng)求。
對(duì)于下面這段服務(wù)器代碼，大家可發(fā)現(xiàn)它與JabberServer.java例子非常相似，只是為一個(gè)特定的客戶提供服務(wù)的所有操作都已移入一個(gè)獨(dú)立的線程類中：
//: 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()
}
public void 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) {}
}
}
}
public class MultiJabberServer {
static final int PORT = 8080;
public static void 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();
}
}
} ///:~
每次有新客戶請(qǐng)求建立一個(gè)連接時(shí)，ServeOneJabber線程都會(huì)取得由accept()在main()中生成的Socket對(duì)象。然后和往常一樣，它創(chuàng)建一個(gè)BufferedReader，并用Socket自動(dòng)刷新PrintWriter對(duì)象。最后，它調(diào)用Thread的特殊方法start()，令其進(jìn)行線程的初始化，然后調(diào)用run()。這里采取的操作與前例是一樣的：從套掃字讀入某些東西，然后把它原樣反饋回去，直到遇到一個(gè)特殊的"END"結(jié)束標(biāo)志為止。
同樣地，套接字的清除必須進(jìn)行謹(jǐn)慎的設(shè)計(jì)。就目前這種情況來說，套接字是在ServeOneJabber外部創(chuàng)建的，所以清除工作可以“共享”。若ServeOneJabber構(gòu)建器失敗，那么只需向調(diào)用者“擲”出一個(gè)違例即可，然后由調(diào)用者負(fù)責(zé)線程的清除。但假如構(gòu)建器成功，那么必須由ServeOneJabber對(duì)象負(fù)責(zé)線程的清除，這是在它的run()里進(jìn)行的。
請(qǐng)注意MultiJabberServer有多么簡(jiǎn)單。和以前一樣，我們創(chuàng)建一個(gè)ServerSocket，并調(diào)用accept()允許一個(gè)新連接的建立。但這一次，accept()的返回值（一個(gè)套接字）將傳遞給用于ServeOneJabber的構(gòu)建器，由它創(chuàng)建一個(gè)新線程，并對(duì)那個(gè)連接進(jìn)行控制。連接中斷后，線程便可簡(jiǎn)單地消失。
如果ServerSocket創(chuàng)建失敗，則再一次通過main()擲出違例。如果成功，則位于外層的try-finally代碼塊可以擔(dān)保正確的清除。位于內(nèi)層的try-catch塊只負(fù)責(zé)防范ServeOneJabber構(gòu)建器的失敗；若構(gòu)建器成功，則ServeOneJabber線程會(huì)將對(duì)應(yīng)的套接字關(guān)掉。
為了證實(shí)服務(wù)器代碼確實(shí)能為多名客戶提供服務(wù)，下面這個(gè)程序?qū)?chuàng)建許多客戶（使用線程），并同相同的服務(wù)器建立連接。每個(gè)線程的“存在時(shí)間”都是有限的。一旦到期，就留出空間以便創(chuàng)建一個(gè)新線程。允許創(chuàng)建的線程的最大數(shù)量是由final int maxthreads決定的。大家會(huì)注意到這個(gè)值非常關(guān)鍵，因?yàn)榧偃绨阉O(shè)得很大，線程便有可能耗盡資源，并產(chǎn)生不可預(yù)知的程序錯(cuò)誤。
//: 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;
private static int counter = 0;
private int id = counter++;
private static int threadcount = 0;
public static int 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.
}
public void 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
}
}
}
public class MultiJabberClient {
static final int MAX_THREADS = 40;
public static void 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構(gòu)建器獲取一個(gè)InetAddress，并用它打開一個(gè)套接字。大家可能已看出了這樣的一個(gè)套路：Socket肯定用于創(chuàng)建某種Reader以及／或者Writer（或者InputStream和／或OutputStream）對(duì)象，這是運(yùn)用Socket的唯一方式（當(dāng)然，我們可考慮編寫一、兩個(gè)類，令其自動(dòng)完成這些操作，避免大量重復(fù)的代碼編寫工作）。同樣地，start()執(zhí)行線程的初始化，并調(diào)用run()。在這里，消息發(fā)送給服務(wù)器，而來自服務(wù)器的信息則在屏幕上回顯出來。然而，線程的“存在時(shí)間”是有限的，最終都會(huì)結(jié)束。注意在套接字創(chuàng)建好以后，但在構(gòu)建器完成之前，假若構(gòu)建器失敗，套接字會(huì)被清除。否則，為套接字調(diào)用close()的責(zé)任便落到了run()方法的頭上。
threadcount跟蹤計(jì)算目前存在的JabberClientThread對(duì)象的數(shù)量。它將作為構(gòu)建器的一部分增值，并在run()退出時(shí)減值（run()退出意味著線程中止）。在MultiJabberClient.main()中，大家可以看到線程的數(shù)量會(huì)得到檢查。若數(shù)量太多，則多余的暫時(shí)不創(chuàng)建。方法隨后進(jìn)入“休眠”狀態(tài)。這樣一來，一旦部分線程最后被中止，多作的那些線程就可以創(chuàng)建了。大家可試驗(yàn)一下逐漸增大MAX_THREADS，看看對(duì)于你使用的系統(tǒng)來說，建立多少線程（連接）才會(huì)使您的系統(tǒng)資源降低到危險(xiǎn)程度。
15.4 數(shù)據(jù)報(bào)
大家迄今看到的例子使用的都是“傳輸控制協(xié)議”（TCP），亦稱作“基于數(shù)據(jù)流的套接字”。根據(jù)該協(xié)議的設(shè)計(jì)宗旨，它具有高度的可靠性，而且能保證數(shù)據(jù)順利抵達(dá)目的地。換言之，它允許重傳那些由于各種原因半路“走失”的數(shù)據(jù)。而且收到字節(jié)的順序與它們發(fā)出來時(shí)是一樣的。當(dāng)然，這種控制與可靠性需要我們付出一些代價(jià)：TCP具有非常高的開銷。
還有另一種協(xié)議，名為“用戶數(shù)據(jù)報(bào)協(xié)議”（UDP），它并不刻意追求數(shù)據(jù)包會(huì)完全發(fā)送出去，也不能擔(dān)保它們抵達(dá)的順序與它們發(fā)出時(shí)一樣。我們認(rèn)為這是一種“不可靠協(xié)議”（TCP當(dāng)然是“可靠協(xié)議”）。聽起來似乎很糟，但由于它的速度快得多，所以經(jīng)常還是有用武之地的。對(duì)某些應(yīng)用來說，比如聲音信號(hào)的傳輸，如果少量數(shù)據(jù)包在半路上丟失了，那么用不著太在意，因?yàn)閭鬏數(shù)乃俣蕊@得更重要一些。大多數(shù)互聯(lián)網(wǎng)游戲，如Diablo，采用的也是UDP協(xié)議通信，因?yàn)榫W(wǎng)絡(luò)通信的快慢是游戲是否流暢的決定性因素。也可以想想一臺(tái)報(bào)時(shí)服務(wù)器，如果某條消息丟失了，那么也真的不必過份緊張。另外，有些應(yīng)用也許能向服務(wù)器傳回一條UDP消息，以便以后能夠恢復(fù)。如果在適當(dāng)?shù)臅r(shí)間里沒有響應(yīng)，消息就會(huì)丟失。
Java對(duì)數(shù)據(jù)報(bào)的支持與它對(duì)TCP套接字的支持大致相同，但也存在一個(gè)明顯的區(qū)別。對(duì)數(shù)據(jù)報(bào)來說，我們?cè)诳蛻艉头?wù)器程序都可以放置一個(gè)DatagramSocket（數(shù)據(jù)報(bào)套接字），但與ServerSocket不同，前者不會(huì)干巴巴地等待建立一個(gè)連接的請(qǐng)求。這是由于不再存在“連接”，取而代之的是一個(gè)數(shù)據(jù)報(bào)陳列出來。另一項(xiàng)本質(zhì)的區(qū)別的是對(duì)TCP套接字來說，一旦我們建好了連接，便不再需要關(guān)心誰(shuí)向誰(shuí)“說話”——只需通過會(huì)話流來回傳送數(shù)據(jù)即可。但對(duì)數(shù)據(jù)報(bào)來說，它的數(shù)據(jù)包必須知道自己來自何處，以及打算去哪里。這意味著我們必須知道每個(gè)數(shù)據(jù)報(bào)包的這些信息，否則信息就不能正常地傳遞。
DatagramSocket用于收發(fā)數(shù)據(jù)包，而DatagramPacket包含了具體的信息。準(zhǔn)備接收一個(gè)數(shù)據(jù)報(bào)時(shí)，只需提供一個(gè)緩沖區(qū)，以便安置接收到的數(shù)據(jù)。數(shù)據(jù)包抵達(dá)時(shí)，通過DatagramSocket，作為信息起源地的因特網(wǎng)地址以及端口編號(hào)會(huì)自動(dòng)得到初化。所以一個(gè)用于接收數(shù)據(jù)報(bào)的DatagramPacket構(gòu)建器是：
DatagramPacket(buf, buf.length)
其中，buf是一個(gè)字節(jié)數(shù)組。既然buf是個(gè)數(shù)組，大家可能會(huì)奇怪為什么構(gòu)建器自己不能調(diào)查出數(shù)組的長(zhǎng)度呢？實(shí)際上我也有同感，唯一能猜到的原因就是C風(fēng)格的編程使然，那里的數(shù)組不能自己告訴我們它有多大。
可以重復(fù)使用數(shù)據(jù)報(bào)的接收代碼，不必每次都建一個(gè)新的。每次用它的時(shí)候（再生），緩沖區(qū)內(nèi)的數(shù)據(jù)都會(huì)被覆蓋。
緩沖區(qū)的最大容量?jī)H受限于允許的數(shù)據(jù)報(bào)包大小，這個(gè)限制位于比64KB稍小的地方。但在許多應(yīng)用程序中，我們都寧愿它變得還要小一些，特別是在發(fā)送數(shù)據(jù)的時(shí)候。具體選擇的數(shù)據(jù)包大小取決于應(yīng)用程序的特定要求。
發(fā)出一個(gè)數(shù)據(jù)報(bào)時(shí)，DatagramPacket不僅需要包含正式的數(shù)據(jù)，也要包含因特網(wǎng)地址以及端口號(hào)，以決定它的目的地。所以用于輸出DatagramPacket的構(gòu)建器是：
DatagramPacket(buf, length, inetAddress, port)
這一次，buf（一個(gè)字節(jié)數(shù)組）已經(jīng)包含了我們想發(fā)出的數(shù)據(jù)。length可以是buf的長(zhǎng)度，但也可以更短一些，意味著我們只想發(fā)出那么多的字節(jié)。另兩個(gè)參數(shù)分別代表數(shù)據(jù)包要到達(dá)的因特網(wǎng)地址以及目標(biāo)機(jī)器的一個(gè)目標(biāo)端口（注釋②）。
②：我們認(rèn)為TCP和UDP端口是相互獨(dú)立的。也就是說，可以在端口8080同時(shí)運(yùn)行一個(gè)TCP和UDP服務(wù)程序，兩者之間不會(huì)產(chǎn)生沖突。
大家也許認(rèn)為兩個(gè)構(gòu)建器創(chuàng)建了兩個(gè)不同的對(duì)象：一個(gè)用于接收數(shù)據(jù)報(bào)，另一個(gè)用于發(fā)送它們。如果是好的面向?qū)ο蟮脑O(shè)計(jì)方案，會(huì)建議把它們創(chuàng)建成兩個(gè)不同的類，而不是具有不同的行為的一個(gè)類（具體行為取決于我們?nèi)绾螛?gòu)建對(duì)象）。這也許會(huì)成為一個(gè)嚴(yán)重的問題，但幸運(yùn)的是，DatagramPacket的使用相當(dāng)簡(jiǎn)單，我們不需要在這個(gè)問題上糾纏不清。這一點(diǎn)在下例里將有很明確的說明。該例類似于前面針對(duì)TCP套接字的MultiJabberServer和MultiJabberClient例子。多個(gè)客戶都會(huì)將數(shù)據(jù)報(bào)發(fā)給服務(wù)器，后者會(huì)將其反饋回最初發(fā)出消息的同樣的客戶。
為簡(jiǎn)化從一個(gè)String里創(chuàng)建DatagramPacket的工作（或者從DatagramPacket里創(chuàng)建String），這個(gè)例子首先用到了一個(gè)工具類，名為Dgram：
//: Dgram.java
// A utility class to convert back and forth
// Between Strings and DataGramPackets.
import java.net.*;
public class Dgram {
public static DatagramPacket toDatagram(
String s, InetAddress destIA, int destPort) {
// Deprecated in Java 1.1, but it works:
byte[] buf = new byte[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();
return new DatagramPacket(buf, buf.length,
destIA, destPort);
}
public static 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的第一個(gè)方法采用一個(gè)String、一個(gè)InetAddress以及一個(gè)端口號(hào)作為自己的參數(shù)，將String的內(nèi)容復(fù)制到一個(gè)字節(jié)緩沖區(qū)，再將緩沖區(qū)傳遞進(jìn)入DatagramPacket構(gòu)建器，從而構(gòu)建一個(gè)DatagramPacket。注意緩沖區(qū)分配時(shí)的"+1"——這對(duì)防止截尾現(xiàn)象是非常重要的。String的getByte()方法屬于一種特殊操作，能將一個(gè)字串包含的char復(fù)制進(jìn)入一個(gè)字節(jié)緩沖。該方法現(xiàn)在已被“反對(duì)”使用；Java 1.1有一個(gè)“更好”的辦法來做這個(gè)工作，但在這里卻被當(dāng)作注釋屏蔽掉了，因?yàn)樗鼤?huì)截掉String的部分內(nèi)容。所以盡管我們?cè)贘ava 1.1下編譯該程序時(shí)會(huì)得到一條“反對(duì)”消息，但它的行為仍然是正確無(wú)誤的（這個(gè)錯(cuò)誤應(yīng)該在你讀到這里的時(shí)候修正了）。
Dgram.toString()方法同時(shí)展示了Java 1.0的方法和Java 1.1的方法（兩者是不同的，因?yàn)橛幸环N新類型的String構(gòu)建器）。
下面是用于數(shù)據(jù)報(bào)演示的服務(wù)器代碼：
//: ChatterServer.java
// A server that echoes datagrams
import java.net.*;
import java.io.*;
import java.util.*;
public class ChatterServer {
static final int INPORT = 1711;
private byte[] buf = new byte[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();
}
}
public static void main(String[] args) {
new ChatterServer();
}
} ///:~
ChatterServer創(chuàng)建了一個(gè)用來接收消息的DatagramSocket（數(shù)據(jù)報(bào)套接字），而不是在我們每次準(zhǔn)備接收一條新消息時(shí)都新建一個(gè)。這個(gè)單一的DatagramSocket可以重復(fù)使用。它有一個(gè)端口號(hào)，因?yàn)檫@屬于服務(wù)器，客戶必須確切知道自己把數(shù)據(jù)報(bào)發(fā)到哪個(gè)地址。盡管有一個(gè)端口號(hào)，但沒有為它分配因特網(wǎng)地址，因?yàn)樗婉v留在“這”臺(tái)機(jī)器內(nèi)，所以知道自己的因特網(wǎng)地址是什么（目前是默認(rèn)的localhost）。在無(wú)限while循環(huán)中，套接字被告知接收數(shù)據(jù)（receive()）。然后暫時(shí)掛起，直到一個(gè)數(shù)據(jù)報(bào)出現(xiàn)，再把它反饋回我們希望的接收人——DatagramPacket dp——里面。數(shù)據(jù)包（Packet）會(huì)被轉(zhuǎn)換成一個(gè)字串，同時(shí)插入的還有數(shù)據(jù)包的起源因特網(wǎng)地址及套接字。這些信息會(huì)顯示出來，然后添加一個(gè)額外的字串，指出自己已從服務(wù)器反饋回來了。
大家可能會(huì)覺得有點(diǎn)兒迷惑。正如大家會(huì)看到的那樣，許多不同的因特網(wǎng)地址和端口號(hào)都可能是消息的起源地——換言之，客戶程序可能駐留在任何一臺(tái)機(jī)器里（就這一次演示來說，它們都駐留在localhost里，但每個(gè)客戶使用的端口編號(hào)是不同的）。為了將一條消息送回它真正的始發(fā)客戶，需要知道那個(gè)客戶的因特網(wǎng)地址以及端口號(hào)。幸運(yùn)的是，所有這些資料均已非常周到地封裝到發(fā)出消息的DatagramPacket內(nèi)部，所以我們要做的全部事情就是用getAddress()和getPort()把它們?nèi)〕鰜怼＠眠@些資料，可以構(gòu)建DatagramPacket echo——它通過與接收用的相同的套接字發(fā)送回來。除此以外，一旦套接字發(fā)出數(shù)據(jù)報(bào)，就會(huì)添加“這”臺(tái)機(jī)器的因特網(wǎng)地址及端口信息，所以當(dāng)客戶接收消息時(shí)，它可以利用getAddress()和getPort()了解數(shù)據(jù)報(bào)來自何處。事實(shí)上，getAddress()和getPort()唯一不能告訴我們數(shù)據(jù)報(bào)來自何處的前提是：我們創(chuàng)建一個(gè)待發(fā)送的數(shù)據(jù)報(bào)，并在正式發(fā)出之前調(diào)用了getAddress()和getPort()。到數(shù)據(jù)報(bào)正式發(fā)送的時(shí)候，這臺(tái)機(jī)器的地址以及端口才會(huì)寫入數(shù)據(jù)報(bào)。所以我們得到了運(yùn)用數(shù)據(jù)報(bào)時(shí)一項(xiàng)重要的原則：不必跟蹤一條消息的來源地！因?yàn)樗隙ū４嬖跀?shù)據(jù)報(bào)里。事實(shí)上，對(duì)程序來說，最可靠的做法是我們不要試圖跟蹤，而是無(wú)論如何都從目標(biāo)數(shù)據(jù)報(bào)里提取出地址以及端口信息（就象這里做的那樣）。
為測(cè)試服務(wù)器的運(yùn)轉(zhuǎn)是否正常，下面這程序?qū)?chuàng)建大量客戶（線程），它們都會(huì)將數(shù)據(jù)報(bào)包發(fā)給服務(wù)器，并等候服務(wù)器把它們?cè)瓨臃答伝貋怼?
//: ChatterServer.java
// A server that echoes datagrams
import java.net.*;
import java.io.*;
import java.util.*;
public class ChatterServer {
static final int INPORT = 1711;
private byte[] buf = new byte[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();
}
}
public static void main(String[] args) {
new ChatterServer();
}
} ///:~
ChatterClient被創(chuàng)建成一個(gè)線程（Thread），所以可以用多個(gè)客戶來“騷擾”服務(wù)器。從中可以看到，用于接收的DatagramPacket和用于ChatterServer的那個(gè)是相似的。在構(gòu)建器中，創(chuàng)建DatagramPacket時(shí)沒有附帶任何參數(shù)（自變量），因?yàn)樗恍枰鞔_指出自己位于哪個(gè)特定編號(hào)的端口里。用于這個(gè)套接字的因特網(wǎng)地址將成為“這臺(tái)機(jī)器”（比如localhost），而且會(huì)自動(dòng)分配端口編號(hào)，這從輸出結(jié)果即可看出。同用于服務(wù)器的那個(gè)一樣，這個(gè)DatagramPacket將同時(shí)用于發(fā)送和接收。
hostAddress是我們想與之通信的那臺(tái)機(jī)器的因特網(wǎng)地址。在程序中，如果需要?jiǎng)?chuàng)建一個(gè)準(zhǔn)備傳出去的DatagramPacket，那么必須知道一個(gè)準(zhǔn)確的因特網(wǎng)地址和端口號(hào)。可以肯定的是，主機(jī)必須位于一個(gè)已知的地址和端口號(hào)上，使客戶能啟動(dòng)與主機(jī)的“會(huì)話”。
每個(gè)線程都有自己獨(dú)一無(wú)二的標(biāo)識(shí)號(hào)（盡管自動(dòng)分配給線程的端口號(hào)是也會(huì)提供一個(gè)唯一的標(biāo)識(shí)符）。在run()中，我們創(chuàng)建了一個(gè)String消息，其中包含了線程的標(biāo)識(shí)編號(hào)以及該線程準(zhǔn)備發(fā)送的消息編號(hào)。我們用這個(gè)字串創(chuàng)建一個(gè)數(shù)據(jù)報(bào)，發(fā)到主機(jī)上的指定地址；端口編號(hào)則直接從ChatterServer內(nèi)的一個(gè)常數(shù)取得。一旦消息發(fā)出，receive()就會(huì)暫時(shí)被“堵塞”起來，直到服務(wù)器回復(fù)了這條消息。與消息附在一起的所有信息使我們知道回到這個(gè)特定線程的東西正是從始發(fā)消息中投遞出去的。在這個(gè)例子中，盡管是一種“不可靠”協(xié)議，但仍然能夠檢查數(shù)據(jù)報(bào)是否到去過了它們?cè)撊サ牡胤剑ㄟ@在localhost和LAN環(huán)境中是成立的，但在非本地連接中卻可能出現(xiàn)一些錯(cuò)誤）。
運(yùn)行該程序時(shí)，大家會(huì)發(fā)現(xiàn)每個(gè)線程都會(huì)結(jié)束。這意味著發(fā)送到服務(wù)器的每個(gè)數(shù)據(jù)報(bào)包都會(huì)回轉(zhuǎn)，并反饋回正確的接收者。如果不是這樣，一個(gè)或更多的線程就會(huì)掛起并進(jìn)入“堵塞”狀態(tài)，直到它們的輸入被顯露出來。
大家或許認(rèn)為將文件從一臺(tái)機(jī)器傳到另一臺(tái)的唯一正確方式是通過TCP套接字，因?yàn)樗鼈兪恰翱煽俊钡摹Ｈ欢捎跀?shù)據(jù)報(bào)的速度非常快，所以它才是一種更好的選擇。我們只需將文件分割成多個(gè)數(shù)據(jù)報(bào)，并為每個(gè)包編號(hào)。接收機(jī)器會(huì)取得這些數(shù)據(jù)包，并重新“組裝”它們；一個(gè)“標(biāo)題包”會(huì)告訴機(jī)器應(yīng)該接收多少個(gè)包，以及組裝所需的另一些重要信息。如果一個(gè)包在半路“走丟”了，接收機(jī)器會(huì)返回一個(gè)數(shù)據(jù)報(bào)，告訴發(fā)送者重傳。
15.5 一個(gè)Web應(yīng)用
現(xiàn)在讓我們想想如何創(chuàng)建一個(gè)應(yīng)用，令其在真實(shí)的Web環(huán)境中運(yùn)行，它將把Java的優(yōu)勢(shì)表現(xiàn)得淋漓盡致。這個(gè)應(yīng)用的一部分是在Web服務(wù)器上運(yùn)行的一個(gè)Java程序，另一部分則是一個(gè)“程序片”或“小應(yīng)用程序”（Applet），從服務(wù)器下載至瀏覽器（即“客戶”）。這個(gè)程序片從用戶那里收集信息，并將其傳回Web服務(wù)器上運(yùn)行的應(yīng)用程序。程序的任務(wù)非常簡(jiǎn)單：程序片會(huì)詢問用戶的E-mail地址，并在驗(yàn)證這個(gè)地址合格后（沒有包含空格，而且有一個(gè)@符號(hào)），將該E-mail發(fā)送給Web服務(wù)器。服務(wù)器上運(yùn)行的程序則會(huì)捕獲傳回的數(shù)據(jù)，檢查一個(gè)包含了所有E-mail地址的數(shù)據(jù)文件。如果那個(gè)地址已包含在文件里，則向?yàn)g覽器反饋一條消息，說明這一情況。該消息由程序片負(fù)責(zé)顯示。若是一個(gè)新地址，則將其置入列表，并通知程序片已成功添加了電子函件地址。
若采用傳統(tǒng)方式來解決這個(gè)問題，我們要?jiǎng)?chuàng)建一個(gè)包含了文本字段及一個(gè)“提交”（Submit）按鈕的HTML頁(yè)。用戶可在文本字段里鍵入自己喜歡的任何內(nèi)容，并毫無(wú)阻礙地提交給服務(wù)器（在客戶端不進(jìn)行任何檢查）。提交數(shù)據(jù)的同時(shí)，Web頁(yè)也會(huì)告訴服務(wù)器應(yīng)對(duì)數(shù)據(jù)采取什么樣的操作——知會(huì)“通用網(wǎng)關(guān)接口”（CGI）程序，收到這些數(shù)據(jù)后立即運(yùn)行服務(wù)器。這種CGI程序通常是用Perl或C寫的（有時(shí)也用C++，但要求服務(wù)器支持），而且必須能控制一切可能出現(xiàn)的情況。它首先會(huì)檢查數(shù)據(jù)，判斷是否采用了正確的格式。若答案是否定的，則CGI程序必須創(chuàng)建一個(gè)HTML頁(yè)，對(duì)遇到的問題進(jìn)行描述。這個(gè)頁(yè)會(huì)轉(zhuǎn)交給服務(wù)器，再由服務(wù)器反饋回用戶。用戶看到出錯(cuò)提示后，必須再試一遍提交，直到通過為止。若數(shù)據(jù)正確，CGI程序會(huì)打開數(shù)據(jù)文件，要么把電子函件地址加入文件，要么指出該地址已在數(shù)據(jù)文件里了。無(wú)論哪種情況，都必須格式化一個(gè)恰當(dāng)?shù)腍TML頁(yè)，以便服務(wù)器返回給用戶。
作為Java程序員，上述解決問題的方法顯得非常笨拙。而且很自然地，我們希望一切工作都用Java完成。首先，我們會(huì)用一個(gè)Java程序片負(fù)責(zé)客戶端的數(shù)據(jù)有效性校驗(yàn)，避免數(shù)據(jù)在服務(wù)器和客戶之間傳來傳去，浪費(fèi)時(shí)間和帶寬，同時(shí)減輕服務(wù)器額外構(gòu)建HTML頁(yè)的負(fù)擔(dān)。然后跳過Perl CGI腳本，換成在服務(wù)器上運(yùn)行一個(gè)Java應(yīng)用。事實(shí)上，我們?cè)谶@兒已完全跳過了Web服務(wù)器，僅僅需要從程序片到服務(wù)器上運(yùn)行的Java應(yīng)用之間建立一個(gè)連接即可。
正如大家不久就會(huì)體驗(yàn)到的那樣，盡管看起來非常簡(jiǎn)單，但實(shí)際上有一些意想不到的問題使局面顯得稍微有些復(fù)雜。用Java 1.1寫程序片是最理想的，但實(shí)際上卻經(jīng)常行不通。到本書寫作的時(shí)候，擁有Java 1.1能力的瀏覽器仍為數(shù)不多，而且即使這類瀏覽器現(xiàn)在非常流行，仍需考慮照顧一下那些升級(jí)緩慢的人。所以從安全的角度看，程序片代碼最好只用Java 1.0編寫。基于這一前提，我們不能用JAR文件來合并（壓縮）程序片中的.class文件。所以，我們應(yīng)盡可能減少.class文件的使用數(shù)量，以縮短下載時(shí)間。
好了，再來說說我用的Web服務(wù)器（寫這個(gè)示范程序時(shí)用的就是它）。它確實(shí)支持Java，但僅限于Java 1.0！所以服務(wù)器應(yīng)用也必須用Java 1.0編寫。
15.5.1 服務(wù)器應(yīng)用
現(xiàn)在討論一下服務(wù)器應(yīng)用（程序）的問題，我把它叫作NameCollecor（名字收集器）。假如多名用戶同時(shí)嘗試提交他們的E-mail地址，那么會(huì)發(fā)生什么情況呢？若NameCollector使用TCP/IP套接字，那么必須運(yùn)用早先介紹的多線程機(jī)制來實(shí)現(xiàn)對(duì)多個(gè)客戶的并發(fā)控制。但所有這些線程都試圖把數(shù)據(jù)寫到同一個(gè)文件里，其中保存了所有E-mail地址。這便要求我們?cè)O(shè)立一種鎖定機(jī)制，保證多個(gè)線程不會(huì)同時(shí)訪問那個(gè)文件。一個(gè)“信號(hào)機(jī)”可在這里幫助我們達(dá)到目的，但或許還有一種更簡(jiǎn)單的方式。
如果我們換用數(shù)據(jù)報(bào)，就不必使用多線程了。用單個(gè)數(shù)據(jù)報(bào)即可“偵聽”進(jìn)入的所有數(shù)據(jù)報(bào)。一旦監(jiān)視到有進(jìn)入的消息，程序就會(huì)進(jìn)行適當(dāng)?shù)奶幚恚⒋饛?fù)數(shù)據(jù)作為一個(gè)數(shù)據(jù)報(bào)傳回原先發(fā)出請(qǐng)求的那名接收者。若數(shù)據(jù)報(bào)半路上丟失了，則用戶會(huì)注意到?jīng)]有答復(fù)數(shù)據(jù)傳回，所以可以重新提交請(qǐng)求。
服務(wù)器應(yīng)用收到一個(gè)數(shù)據(jù)報(bào)，并對(duì)它進(jìn)行解讀的時(shí)候，必須提取出其中的電子函件地址，并檢查本機(jī)保存的數(shù)據(jù)文件，看看里面是否已經(jīng)包含了那個(gè)地址（如果沒有，則添加之）。所以我們現(xiàn)在遇到了一個(gè)新的問題。Java 1.0似乎沒有足夠的能力來方便地處理包含了電子函件地址的文件（Java 1.1則不然）。但是，用C輕易就可以解決這個(gè)問題。因此，我們?cè)谶@兒有機(jī)會(huì)學(xué)習(xí)將一個(gè)非Java程序同Java程序連接的最簡(jiǎn)便方式。程序使用的Runtime對(duì)象包含了一個(gè)名為exec()的方法，它會(huì)獨(dú)立機(jī)器上一個(gè)獨(dú)立的程序，并返回一個(gè)Process（進(jìn)程）對(duì)象。我們可以取得一個(gè)OutputStream，它同這個(gè)單獨(dú)程序的標(biāo)準(zhǔn)輸入連接在一起；并取得一個(gè)InputStream，它則同標(biāo)準(zhǔn)輸出連接到一起。要做的全部事情就是用任何語(yǔ)言寫一個(gè)程序，只要它能從標(biāo)準(zhǔn)輸入中取得自己的輸入數(shù)據(jù)，并將輸出結(jié)果寫入標(biāo)準(zhǔn)輸出即可。如果有些問題不能用Java簡(jiǎn)便與快速地解決（或者想利用原有代碼，不想改寫），就可以考慮采用這種方法。亦可使用Java的“固有方法”（Native Method），但那要求更多的技巧，大家可以參考一下附錄A。
1. C程序
這個(gè)非Java應(yīng)用是用C寫成，因?yàn)镴ava不適合作CGI編程；起碼啟動(dòng)的時(shí)間不能讓人滿意。它的任務(wù)是管理電子函件（E-mail）地址的一個(gè)列表。標(biāo)準(zhǔn)輸入會(huì)接受一個(gè)E-mail地址，程序會(huì)檢查列表中的名字，判斷是否存在那個(gè)地址。若不存在，就將其加入，并報(bào)告操作成功。但假如名字已在列表里了，就需要指出這一點(diǎn)，避免重復(fù)加入。大家不必?fù)?dān)心自己不能完全理解下列代碼的含義。它僅僅是一個(gè)演示程序，告訴你如何用其他語(yǔ)言寫一個(gè)程序，并從Java中調(diào)用它。在這里具體采用何種語(yǔ)言并不重要，只要能夠從標(biāo)準(zhǔn)輸入中讀取數(shù)據(jù)，并能寫入標(biāo)準(zhǔn)輸出即可。
//: Listmgr.c
// Used by NameCollector.java to manage
// the email list file on the server
#include
#include
#include
#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);
}
}
} ///:~
該程序假設(shè)C編譯器能接受'//'樣式注釋（許多編譯器都能，亦可換用一個(gè)C++編譯器來編譯這個(gè)程序）。如果你的編譯器不能接受，則簡(jiǎn)單地將那些注釋刪掉即可。
文件中的第一個(gè)函數(shù)檢查我們作為第二個(gè)參數(shù)（指向一個(gè)char的指針）傳遞給它的名字是否已在文件中。在這兒，我們將文件作為一個(gè)FILE指針傳遞，它指向一個(gè)已打開的文件（文件是在main()中打開的）。函數(shù)fseek()在文件中遍歷；我們?cè)谶@兒用它移至文件開頭。fgets()從文件list中讀入一行內(nèi)容，并將其置入緩沖區(qū)lbuf——不會(huì)超過規(guī)定的緩沖區(qū)長(zhǎng)度BSIZE。所有這些工作都在一個(gè)while循環(huán)中進(jìn)行，所以文件中的每一行都會(huì)讀入。接下來，用strchr()找到新行字符，以便將其刪掉。最后，用strcmp()比較我們傳遞給函數(shù)的名字與文件中的當(dāng)前行。若找到一致的內(nèi)容，strcmp()會(huì)返回0。函數(shù)隨后會(huì)退出，并返回一個(gè)1，指出該名字已經(jīng)在文件里了（注意這個(gè)函數(shù)找到相符內(nèi)容后會(huì)立即返回，不會(huì)把時(shí)間浪費(fèi)在檢查列表剩余內(nèi)容的上面）。如果找遍列表都沒有發(fā)現(xiàn)相符的內(nèi)容，則函數(shù)返回0。
在main()中，我們用fopen()打開文件。第一個(gè)參數(shù)是文件名，第二個(gè)是打開文件的方式；a+表示“追加”，以及“打開”（或“創(chuàng)建”，假若文件尚不存在），以便到文件的末尾進(jìn)行更新。fopen()函數(shù)返回的是一個(gè)FILE指針；若為0，表示打開操作失敗。此時(shí)需要用perror()打印一條出錯(cuò)提示消息，并用exit()中止程序運(yùn)行。
如果文件成功打開，程序就會(huì)進(jìn)入一個(gè)無(wú)限循環(huán)。調(diào)用gets(buf)的函數(shù)會(huì)從標(biāo)準(zhǔn)輸入中取出一行（記住標(biāo)準(zhǔn)輸入會(huì)與Java程序連接到一起），并將其置入緩沖區(qū)buf中。緩沖區(qū)的內(nèi)容隨后會(huì)簡(jiǎn)單地傳遞給alreadyInList()函數(shù)，如內(nèi)容已在列表中，printf()就會(huì)將那條消息發(fā)給標(biāo)準(zhǔn)輸出（Java程序正在監(jiān)視它）。fflush()用于對(duì)輸出緩沖區(qū)進(jìn)行刷新。
如果名字不在列表中，就用fseek()移到列表末尾，并用fprintf()將名字“打印”到列表末尾。隨后，用printf()指出名字已成功加入列表（同樣需要刷新標(biāo)準(zhǔn)輸出），無(wú)限循環(huán)返回，繼續(xù)等候一個(gè)新名字的進(jìn)入。
記住一般不能先在自己的計(jì)算機(jī)上編譯此程序，再把編譯好的內(nèi)容上載到Web服務(wù)器，因?yàn)槟桥_(tái)機(jī)器使用的可能是不同類的處理器和操作系統(tǒng)。例如，我的Web服務(wù)器安裝的是Intel的CPU，但操作系統(tǒng)是Linux，所以必須先下載源碼，再用遠(yuǎn)程命令（通過telnet）指揮Linux自帶的C編譯器，令其在服務(wù)器端編譯好程序。
2. Java程序
這個(gè)程序先啟動(dòng)上述的C程序，再建立必要的連接，以便同它“交談”。隨后，它創(chuàng)建一個(gè)數(shù)據(jù)報(bào)套接字，用它“監(jiān)視”或者“偵聽”來自程序片的數(shù)據(jù)報(bào)包。
//: 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.*;
public class NameCollector {
final static int COLLECTOR_PORT = 8080;
final static int BUFFER_SIZE = 1000;
byte[] buf = new byte[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 = new byte[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 = new byte[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();
}
}
public static void main(String[] args) {
new NameCollector();
}
} ///:~
NameCollector中的第一個(gè)定義應(yīng)該是大家所熟悉的：選定端口，創(chuàng)建一個(gè)數(shù)據(jù)報(bào)包，然后創(chuàng)建指向一個(gè)DatagramSocket的句柄。接下來的三個(gè)定義負(fù)責(zé)與C程序的連接：一個(gè)Process對(duì)象是C程序由Java程序啟動(dòng)之后返回的，而且那個(gè)Process對(duì)象產(chǎn)生了InputStream和OutputStream，分別代表C程序的標(biāo)準(zhǔn)輸出和標(biāo)準(zhǔn)輸入。和Java IO一樣，它們理所當(dāng)然地需要“封裝”起來，所以我們最后得到的是一個(gè)PrintStream和DataInputStream。
這個(gè)程序的所有工作都是在構(gòu)建器內(nèi)進(jìn)行的。為啟動(dòng)C程序，需要取得當(dāng)前的Runtime對(duì)象。我們用它調(diào)用exec()，再由后者返回Process對(duì)象。在Process對(duì)象中，大家可看到通過一簡(jiǎn)單的調(diào)用即可生成數(shù)據(jù)流：getOutputStream()和getInputStream()。從這個(gè)時(shí)候開始，我們需要考慮的全部事情就是將數(shù)據(jù)傳給數(shù)據(jù)流nameList，并從addResult中取得結(jié)果。
和往常一樣，我們將DatagramSocket同一個(gè)端口連接到一起。在無(wú)限while循環(huán)中，程序會(huì)調(diào)用receive()——除非一個(gè)數(shù)據(jù)報(bào)到來，否則receive()會(huì)一起處于“堵塞”狀態(tài)。數(shù)據(jù)報(bào)出現(xiàn)以后，它的內(nèi)容會(huì)提取到String rcvd里。我們首先將該字串兩頭的空格剔除（trim），再將其發(fā)給C程序。如下所示：
nameList.println(rcvd.trim());
之所以能這樣編碼，是因?yàn)镴ava的exec()允許我們?cè)L問任何可執(zhí)行模塊，只要它能從標(biāo)準(zhǔn)輸入中讀，并能向標(biāo)準(zhǔn)輸出中寫。還有另一些方式可與非Java代碼“交談”，這將在附錄A中討論。
從C程序中捕獲結(jié)果就顯得稍微麻煩一些。我們必須調(diào)用read()，并提供一個(gè)緩沖區(qū)，以便保存結(jié)果。read()的返回值是來自C程序的字節(jié)數(shù)。若這個(gè)值為-1，意味著某個(gè)地方出現(xiàn)了問題。否則，我們就將resultBuf（結(jié)果緩沖區(qū)）轉(zhuǎn)換成一個(gè)字串，然后同樣清除多余的空格。隨后，這個(gè)字串會(huì)象往常一樣進(jìn)入一個(gè)DatagramPacket，并傳回當(dāng)初發(fā)出請(qǐng)求的那個(gè)同樣的地址。注意發(fā)送方的地址也是我們接收到的DatagramPacket的一部分。
記住盡管C程序必須在Web服務(wù)器上編譯，但Java程序的編譯場(chǎng)所可以是任意的。這是由于不管使用的是什么硬件平臺(tái)和操作系統(tǒng)，編譯得到的字節(jié)碼都是一樣的。就就是Java的“跨平臺(tái)”兼容能力。
15.5.2 NameSender程序片
正如早先指出的那樣，程序片必須用Java 1.0編寫，使其能與絕大多數(shù)的瀏覽器適應(yīng)。也正是由于這個(gè)原因，我們產(chǎn)生的類數(shù)量應(yīng)盡可能地少。所以我們?cè)谶@兒不考慮使用前面設(shè)計(jì)好的Dgram類，而將數(shù)據(jù)報(bào)的所有維護(hù)工作都轉(zhuǎn)到代碼行中進(jìn)行。此外，程序片要用一個(gè)線程監(jiān)視由服務(wù)器傳回的響應(yīng)信息，而非實(shí)現(xiàn)Runnable接口，用集成到程序片的一個(gè)獨(dú)立線程來做這件事情。當(dāng)然，這樣做對(duì)代碼的可讀性不利，但卻能產(chǎn)生一個(gè)單類（以及單個(gè)服務(wù)器請(qǐng)求）程序片：
//: 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.*;
public class 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;
private byte[] buf =
new byte[NameCollector.BUFFER_SIZE];
private DatagramPacket dp =
new DatagramPacket(buf, buf.length);
private int vcount = 0;
public void 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");
}
public boolean 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");
return true;
}
if(str.indexOf(',') != -1) {
l.setText("Commas not allowed in name");
return true;
}
if(str.indexOf('@') == -1) {
l.setText("Name must include '@'");
l2.setText("");
return true;
}
if(str.indexOf('@') == 0) {
l.setText("Name must preceed '@'");
l2.setText("");
return true;
}
String end =
str.substring(str.indexOf('@'));
if(end.indexOf('.') == -1) {
l.setText("Portion after '@' must " +
"have an extension, such as '.com'");
l2.setText("");
return true;
}
// 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 =
new byte[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");
return true;
}
l.setText("Sent: " + str);
send.setLabel("Re-send");
pl = new Thread(this);
pl.start();
l2.setText(
"Waiting for verification " + ++vcount);
}
else return super.action(evt, arg);
return true;
}
// The thread portion of the applet watches for
// the reply to come back from the server:
public void 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（用戶界面）非常簡(jiǎn)單。它包含了一個(gè)TestField（文本字段），以便我們鍵入一個(gè)電子函件地址；以及一個(gè)Button（按鈕），用于將地址發(fā)給服務(wù)器。兩個(gè)Label（標(biāo)簽）用于向用戶報(bào)告狀態(tài)信息。
到現(xiàn)在為止，大家已能判斷出DatagramSocket、InetAddress、緩沖區(qū)以及DatagramPacket都屬于網(wǎng)絡(luò)連接中比較麻煩的部分。最后，大家可看到run()方法實(shí)現(xiàn)了線程部分，使程序片能夠“偵聽”由服務(wù)器傳回的響應(yīng)信息。
init()方法用大家熟悉的布局工具設(shè)置GUI，然后創(chuàng)建DatagramSocket，它將同時(shí)用于數(shù)據(jù)報(bào)的收發(fā)。
action()方法只負(fù)責(zé)監(jiān)視我們是否按下了“發(fā)送”（send）按鈕。記住，我們已被限制在Java 1.0上面，所以不能再用較靈活的內(nèi)部類了。按鈕按下以后，采取的第一項(xiàng)行動(dòng)便是檢查線程pl，看看它是否為null（空）。如果不為null，表明有一個(gè)活動(dòng)線程正在運(yùn)行。消息首次發(fā)出時(shí)，會(huì)啟動(dòng)一個(gè)新線程，用它監(jiān)視來自服務(wù)器的回應(yīng)。所以假若有個(gè)線程正在運(yùn)行，就意味著這并非用戶第一次發(fā)送消息。pl句柄被設(shè)為null，同時(shí)中止原來的監(jiān)視者（這是最合理的一種做法，因?yàn)閟top()已被Java 1.2“反對(duì)”，這在前一章已解釋過了）。
無(wú)論這是否按鈕被第一次按下，I2中的文字都會(huì)清除。
下一組語(yǔ)句將檢查E-mail名字是否合格。String.indexOf()方法的作用是搜索其中的非法字符。如果找到一個(gè)，就把情況報(bào)告給用戶。注意進(jìn)行所有這些工作時(shí)，都不必涉及網(wǎng)絡(luò)通信，所以速度非常快，而且不會(huì)影響帶寬和服務(wù)器的性能。
名字校驗(yàn)通過以后，它會(huì)打包到一個(gè)數(shù)據(jù)報(bào)里，然后采用與前面那個(gè)數(shù)據(jù)報(bào)示例一樣的方式發(fā)到主機(jī)地址和端口編號(hào)。第一個(gè)標(biāo)簽會(huì)發(fā)生變化，指出已成功發(fā)送出去。而且按鈕上的文字也會(huì)改變，變成“重發(fā)”（resend）。這時(shí)會(huì)啟動(dòng)線程，第二個(gè)標(biāo)簽則會(huì)告訴我們程序片正在等候來自服務(wù)器的回應(yīng)。
線程的run()方法會(huì)利用NameSender中包含的DatagramSocket來接收數(shù)據(jù)（receive()），除非出現(xiàn)來自服務(wù)器的數(shù)據(jù)報(bào)包，否則receive()會(huì)暫時(shí)處于“堵塞”或者“暫停”狀態(tài)。結(jié)果得到的數(shù)據(jù)包會(huì)放進(jìn)NameSender的DatagramPacketdp中。數(shù)據(jù)會(huì)從包中提取出來，并置入NameSender的第二個(gè)標(biāo)簽。隨后，線程的執(zhí)行將中斷，成為一個(gè)“死”線程。若某段時(shí)間里沒有收到來自服務(wù)器的回應(yīng)，用戶可能變得不耐煩，再次按下按鈕。這樣做會(huì)中斷當(dāng)前線程（數(shù)據(jù)發(fā)出以后，會(huì)再建一個(gè)新的）。由于用一個(gè)線程來監(jiān)視回應(yīng)數(shù)據(jù)，所以用戶在監(jiān)視期間仍然可以自由使用UI。
1. Web頁(yè)
當(dāng)然，程序片必須放到一個(gè)Web頁(yè)里。下面列出完整的Web頁(yè)源碼；稍微研究一下就可看出，我用它從自己開辦的郵寄列表（Mailling List）里自動(dòng)收集名字。
Add Yourself to Bruce Eckel's Java Mailing List
Add Yourself to Bruce Eckel's Java Mailing List
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.
If after several tries, you do not get verification it means that the Java application on the server is having problems. In this case, you can add yourself to the list by sending email to
Bruce@EckelObjects.com
程序片標(biāo)記（