-------------------------------------------------
本教程由yyc,spirit整理
-------------------------------------------------
網絡編程
歷史上的網絡編程都傾向于困難、復雜，而且極易出錯。
程序員必須掌握與網絡有關的大量細節，有時甚至要對硬件有深刻的認識。一般地，我們需要理解連網協議中不同的“層”（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.*;
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);
}
} ///:~
就我自己的情況來說，機器的名字叫作“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.*;
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需要的只是一個端口編號，不需要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.*;
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()中，大家可看到獲得本地主機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()
}
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();
}
}
} ///:~
每次有新客戶請求建立一個連接時，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;
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構建器獲取一個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.*;
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的第一個方法采用一個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.*;
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創建了一個用來接收消息的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.*;
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被創建成一個線程（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
#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);
}
}
} ///:~
該程序假設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.*;
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中的第一個定義應該是大家所熟悉的：選定端口，創建一個數據報包，然后創建指向一個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.*;
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（用戶界面）非常簡單。它包含了一個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）里自動收集名字。
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
程序片標記（