【帶你入門】java網路程式設計
網路程式設計
網路程式設計對於很多的初學者來說，都是很嚮往的一種程式設計技能，但是很多的初學者卻因為很長一段時間無法進入網路程式設計的大門而放棄了對於該部分技術的學習。
在 學習網路程式設計以前，很多初學者可能覺得網路程式設計是比較複雜的系統工程，需要了解很多和網路相關的基礎知識，其實這些都不是很必需的。首先來問一個問題：你 會打手機嗎？很多人可能說肯定會啊，不就是按按電話號碼，撥打電話嘛，很簡單的事情啊！其實初學者如果入門網路程式設計的話也可以做到這麼簡單！
網路程式設計就是在兩個或兩個以上的裝置(例如計算機)之間傳輸資料。程式設計師所作的事情就是把資料傳送到指定的位置，或者接收到指定的資料，這個就是狹義的網路程式設計範疇。在傳送和接收資料時，大部分的程式設計語言都設計了專門的API實現這些功能，程式設計師只需要呼叫即可。所以，基礎的網路程式設計可以和打電話一樣簡單。
下面就開始Java語言的網路程式設計技術學習吧。
1.1 網路概述
網路程式設計技術是當前一種主流的程式設計技術，隨著聯網趨勢的逐步增強以及網路應用程式的大量出現，所以在實際的開發中網路程式設計技術獲得了大量的使用。本章中以淺 顯的基礎知識說明和實際的案例使廣大初學者能夠進入網路程式設計技術的大門，至於以後的實際修行就要閱讀進階的書籍以及進行大量的實際練習。
1.1.1 計算機網路概述
網路程式設計的實質就是兩個(或多個)裝置(例如計算機)之間的資料傳輸。
按照計算機網路的定義，通過一定的物理裝置將處於不同位置的計算機連線起來組成的網路，這個網路中包含的裝置有：計算機、路由器、交換機等等。
其實從軟體程式設計的角度來說，對於物理裝置的理解不需要很深刻，就像你打電話時不需要很熟悉通訊網路的底層實現是一樣的，但是當深入到網路程式設計的底層時，這些基礎知識是必須要補的。
路由器和交換機組成了核心的計算機網路，計算機只是這個網路上的節點以及控制等，通過光纖、網線等連線將裝置連線起來，從而形成了一張巨大的計算機網路。
網路最主要的優勢在於共享：共享裝置和資料，現在共享裝置最常見的是印表機，一個公司一般一個印表機即可，共享資料就是將大量的資料儲存在一組機器中，其它的計算機通過網路訪問這些資料，例如網站、銀行伺服器等等。
如果需要了解更多的網路硬體基礎知識，可以閱讀《計算機網路》教材，對於基礎進行強化，這個在基礎學習階段不是必須的，但是如果想在網路程式設計領域有所造詣，則是一個必須的基本功。
對於網路程式設計來說，最主要的是計算機和計算機之間的通訊，這樣首要的問題就是如何找到網路上的計算機呢？這就需要了解IP地址的概念。
為了能夠方便的識別網路上的每個裝置，網路中的每個裝置都會有一個唯一的數字標識，這個就是IP地址。在計算機網路中,現在命名IP地址的規定是IPv4協議，該協議規定每個IP地址由4個0-255之間的數字組成，例如10.0.120.34。每個接入網路的計算機都擁有唯一的IP地址，這個IP地址可能是固定的，例如網路上各種各樣的伺服器，也可以是動態的，例如使用ADSL撥號上網的寬頻使用者，無論以何種方式獲得或是否是固定的，每個計算機在聯網以後都擁有一個唯一的合法IP地址，就像每個手機號碼一樣。
但是由於IP地址不容易記憶，所以為了方便記憶，有創造了另外一個概念——域名(Domain Name)，例如sohu.com等。一個IP地址可以對應多個域名，一個域名只能對應一個IP地址。域名的概念可以類比手機中的通訊簿，由於手機號碼不方便記憶，所以新增一個姓名標識號碼，在實際撥打電話時可以選擇該姓名，然後撥打即可。
在網路中傳輸的資料，全部是以IP地址作為地址標識，所以在實際傳輸資料以前需要將域名轉換為IP地址，實現這種功能的伺服器稱之為DNS伺服器，也就是通俗的說法叫做域名解析。例如當用戶在瀏覽器輸入域名時，瀏覽器首先請求DNS伺服器，將域名轉換為IP地址，然後將轉換後的IP地址反饋給瀏覽器，然後再進行實際的資料傳輸。
當DNS伺服器正常工作時，使用IP地址或域名都可以很方便的找到計算機網路中的某個裝置，例如伺服器計算機。當DNS不正常工作時，只能通過IP地址訪問該裝置。所以IP地址的使用要比域名通用一些。
IP地址和域名很好的解決了在網路中找到一個計算機的問題，但是為了讓一個計算機可以同時執行多個網路程式，就引入了另外一個概念——埠(port)。
在介紹埠的概念以前，首先來看一個例子，一般一個公司前臺會有一個電話，每個員工會有一個分機，這樣如果需要找到這個員工的話，需要首先撥打前臺總機，然後轉該分機號即可。這樣減少了公司的開銷，也方便了每個員工。在該示例中前臺總機的電話號碼就相當於IP地址，而每個員工的分機號就相當於埠。
有了埠的概念以後，在同一個計算機中每個程式對應唯一的埠，這樣一個計算機上就可以通過埠區分發送給每個埠的資料了，換句話說，也就是一個計算機上可以併發執行多個網路程式，而不會在互相之間產生干擾。
在硬體上規定，埠的號碼必須位於0-65535之間，每個埠唯一的對應一個網路程式，一個網路程式可以使用多個埠。這樣一個網路程式執行在一臺計算上時，不管是客戶端還是伺服器，都是至少佔用一個埠進行網路通訊。在接收資料時，首先發送給對應的計算機，然後計算機根據埠把資料轉發給對應的程式。
有了IP地址和埠的概念以後，在進行網路通訊交換時，就可以通過IP地址查詢到該臺計算機，然後通過埠標識這臺計算機上的一個唯一的程式。這樣就可以進行網路資料的交換了。
但是，進行網路程式設計時，只有IP地址和埠的概念還是不夠的，下面就介紹一下基礎的網路程式設計相關的軟體基礎知識。
1.1. 2 網路程式設計概述
按照前面的介紹，網路程式設計就是兩個或多個裝置之間的資料交換，其實更具體的說，網路程式設計就是兩個或多個程式之間的資料交換，和普通的單機程式相比，網路程式最大的不同就是需要交換資料的程式執行在不同的計算機上，這樣就造成了資料交換的複雜。雖然通過IP地址和埠可以找到網路上執行的一個程式，但是如果需要進行網路程式設計，則還需要了解網路通訊的過程。
網路通訊基於“請求-響應”模型。為了理解這個模型，先來看一個例子，經常看電視的人肯定見過審訊的場面吧，一般是這樣的：
警察：姓名
嫌疑犯：XXX
警察：性別
嫌疑犯：男
警察：年齡
嫌疑犯：29
……
在這個例子中，警察問一句，嫌疑犯回答一句，如果警察不問，則嫌疑犯保持沉默。這種一問一答的形式就是網路中的“請求-響應”模型。也就是通訊的一端傳送資料，另外一端反饋資料，網路通訊都基於該模型。
在網路通訊中，第一次主動發起通訊的程式被稱作客戶端(Client)程式，簡稱客戶端，而在第一次通訊中等待連線的程式被稱作伺服器端(Server)程式，簡稱伺服器。一旦通訊建立，則客戶端和伺服器端完全一樣，沒有本質的區別。
由此，網路程式設計中的兩種程式就分別是客戶端和伺服器端，例如QQ程式，每個QQ使用者安裝的都是QQ客戶端程式，而QQ伺服器端程式則執行在騰訊公司的機房中，為大量的QQ使用者提供服務。這種網路程式設計的結構被稱作客戶端/伺服器結構，也叫做Client/Server結構，簡稱C/S結構。
使用C/S結 構的程式，在開發時需要分別開發客戶端和伺服器端，這種結構的優勢在於由於客戶端是專門開發的，所以根據需要實現各種效果，專業點說就是表現力豐富，而服 務器端也需要專門進行開發。但是這種結構也存在著很多不足，例如通用性差，幾乎不能通用等，也就是說一種程式的客戶端只能和對應的伺服器端通訊，而不能和 其它伺服器端通訊，在實際維護時，也需要維護專門的客戶端和伺服器端，維護的壓力比較大。
其實在執行很多程式時，沒有必要使用專用的客戶端，而需要使用通用的客戶端，例如瀏覽器，使用瀏覽器作為客戶端的結構被稱作瀏覽器/伺服器結構，也叫做Browser/Server結構，簡稱為B/S結構。
使用B/S結構的程式，在開發時只需要開發伺服器端即可，這種結構的優勢在於開發的壓力比較小，不需要維護客戶端。但是這種結構也存在著很多不足，例如瀏覽器的限制比較大，表現力不強，無法進行系統級操作等。
總之C/S結構和B/S結構是現在網路程式設計中常見的兩種結構，B/S結構其實也就是一種特殊的C/S結構。
另外簡單的介紹一下P2P(Point to Point)程式，常見的如BT、電驢等。P2P程式是一種特殊的程式，應該一個P2P程式中既包含客戶端程式，也包含伺服器端程式，例如BT，使用客戶端程式部分連線其它的種子(伺服器端)，而使用伺服器端向其它的BT客戶端傳輸資料。如果這個還不是很清楚，其實P2P程式和手機是一樣的，當手機撥打電話時就是使用客戶端的作用，而手機處於待機狀態時，可以接收到其它使用者撥打的電話則起的就是伺服器端的功能，只是一般的手機不能同時使用撥打電話和接聽電話的功能，而P2P程式實現了該功能。
最後再介紹一個網路程式設計中最重要，也是最複雜的概念——協議(Protocol)。按照前面的介紹，網路程式設計就是執行在不同計算機中兩個程式之間的資料交換。在實際進行資料交換時，為了讓接收端理解該資料，計算機比較笨，什麼都不懂的，那麼就需要規定該資料的格式，這個資料的格式就是協議。
如 果沒有理解協議的概念，那麼再舉一個例子，記得有個電影叫《永不消逝的電波》，講述的是地下黨通過電臺傳送情報的故事，這裡我們不探討電影的劇情，而只關 心電臺傳送的資料。在實際發報時，需要首先將需要傳送的內容轉換為電報編碼，然後將電報編碼傳送出去，而接收端接收的是電報編碼，如果需要理解電報的內容 則需要根據密碼本翻譯出該電報的內容。這裡的密碼本就規定了一種資料格式，這種對於網路中傳輸的資料格式在網路程式設計中就被稱作協議。
那麼如何來編寫協議格式呢？答案是隨意。只要按照這種協議格式能夠生成唯一的編碼，按照該編碼可以唯一的解析出傳送資料的內容即可。也正因為各個網路程式之間協議格式的不同，所以才導致了客戶端程式都是專用的結構。
在實際的網路程式程式設計中，最麻煩的內容不是資料的傳送和接收，因為這個功能在幾乎所有的程式語言中都提供了封裝好的API進行呼叫，最麻煩的內容就是協議的設計以及協議的生產和解析，這個才是網路程式設計中最核心的內容。
關於網路程式設計的基礎知識，就介紹這裡，深刻理解IP地址、埠和協議等概念，將會極大的有助於後續知識的學習。
13.1.3 網路通訊方式
在現有的網路中，網路通訊的方式主要有兩種：
TCP(傳輸控制協議)方式
UDP(使用者資料報協議)方式
為 了方便理解這兩種方式，還是先來看一個例子。大家使用手機時，向別人傳遞資訊時有兩種方式：撥打電話和傳送簡訊。使用撥打電話的方式可以保證將資訊傳遞給 別人，因為別人接聽電話時本身就確認接收到了該資訊。而傳送簡訊的方式價格低廉，使用方便，但是接收人有可能接收不到。
在網路通訊中，TCP方式就類似於撥打電話，使用該種方式進行網路通訊時，需要建立專門的虛擬連線，然後進行可靠的資料傳輸，如果資料傳送失敗，則客戶端會自動重發該資料。而UDP方式就類似於傳送簡訊，使用這種方式進行網路通訊時，不需要建立專門的虛擬連線，傳輸也不是很可靠，如果傳送失敗則客戶端無法獲得。
這兩種傳輸方式都是實際的網路程式設計中進行使用，重要的資料一般使用TCP方式進行資料傳輸，而大量的非核心資料則都通過UDP方式進行傳遞，在一些程式中甚至結合使用這兩種方式進行資料的傳遞。
由於TCP需要建立專用的虛擬連線以及確認傳輸是否正確，所以使用TCP方式的速度稍微慢一些，而且傳輸時產生的資料量要比UDP稍微大一些。
關於網路程式設計的基礎知識就介紹這麼多，如果需要深入瞭解相關知識請閱讀專門的計算機網路書籍，下面開始介紹Java語言中網路程式設計的相關技術。
1.2 網路程式設計技術
前面介紹了網路程式設計的相關基礎知識，初步建立了網路程式設計的概念，但是實際學習網路程式設計還必須使用某種程式設計語言進行程式碼實現，下面就介紹一下網路程式設計的程式碼實現。
1.2.1 網路程式設計步驟
按照前面的基礎知識介紹，無論使用TCP方式還是UDP方式進行網路通訊，網路程式設計都是由客戶端和伺服器端組成。當然，B/S結構的程式設計中只需要實現伺服器端即可。所以，下面介紹網路程式設計的步驟時，均以C/S結構為基礎進行介紹。
說明：這裡的步驟實現和語言無關，也就是說，這個步驟適用於各種語言實現，不侷限於Java語言。
1.2.1.1 客戶端網路程式設計步驟
客戶端(Client)是指網路程式設計中首先發起連線的程式，客戶端一般實現程式介面和基本邏輯實現，在進行實際的客戶端程式設計時，無論客戶端複雜還是簡單，以及客戶端實現的方式，客戶端的程式設計主要由三個步驟實現：
1、 建立網路連線
客戶端網路程式設計的第一步都是建立網路連線。在建立網路連線時需要指定連線到的伺服器的IP地址和埠號，建立完成以後，會形成一條虛擬的連線，後續的操作就可以通過該連線實現資料交換了。
2、 交換資料
連線建立以後，就可以通過這個連線交換資料了。交換資料嚴格按照請求響應模型進行，由客戶端傳送一個請求資料到伺服器，伺服器反饋一個響應資料給客戶端，如果客戶端不傳送請求則伺服器端就不響應。
根據邏輯需要，可以多次交換資料，但是還是必須遵循請求響應模型。
3、 關閉網路連線
在資料交換完成以後，關閉網路連線，釋放程式佔用的埠、記憶體等系統資源，結束網路程式設計。
最基本的步驟一般都是這三個步驟，在實際實現時，步驟2會出現重複，在進行程式碼組織時，由於網路程式設計是比較耗時的操作，所以一般開啟專門的現場進行網路通訊。
1.2.1.2 伺服器端網路程式設計步驟
伺服器端(Server)是指在網路程式設計中被動等待連線的程式，伺服器端一般實現程式的核心邏輯以及資料儲存等核心功能。伺服器端的程式設計步驟和客戶端不同，是由四個步驟實現，依次是：
1、 監聽埠
伺服器端屬於被動等待連線，所以伺服器端啟動以後，不需要發起連線，而只需要監聽本地計算機的某個固定埠即可。
這個埠就是伺服器端開放給客戶端的埠，伺服器端程式執行的本地計算機的IP地址就是伺服器端程式的IP地址。
2、 獲得連線
當客戶端連線到伺服器端時，伺服器端就可以獲得一個連線，這個連線包含客戶端的資訊，例如客戶端IP地址等等，伺服器端和客戶端也通過該連線進行資料交換。
一般在伺服器端程式設計中，當獲得連線時，需要開啟專門的執行緒處理該連線，每個連線都由獨立的執行緒實現。
3、 交換資料
伺服器端通過獲得的連線進行資料交換。伺服器端的資料交換步驟是首先接收客戶端傳送過來的資料，然後進行邏輯處理，再把處理以後的結果資料傳送給客戶端。簡單來說，就是先接收再發送，這個和客戶端的資料交換數序不同。
其實，伺服器端獲得的連線和客戶端連線是一樣的，只是資料交換的步驟不同。
當然，伺服器端的資料交換也是可以多次進行的。
在資料交換完成以後，關閉和客戶端的連線。
4、 關閉連線
當伺服器程式關閉時，需要關閉伺服器端，通過關閉伺服器端使得伺服器監聽的埠以及佔用的記憶體可以釋放出來，實現了連線的關閉。
其實伺服器端程式設計的模型和呼叫中心的實現是類似的，例如移動的客服電話10086就是典型的呼叫中心，當一個使用者撥打10086時，轉接給一個專門的客服人員，由該客服實現和該使用者的問題解決，當另外一個使用者撥打10086時，則轉接給另一個客服，實現問題解決，依次類推。
在伺服器端程式設計時，10086這個電話號碼就類似於伺服器端的埠號碼，每個使用者就相當於一個客戶端程式，每個客服人員就相當於伺服器端啟動的專門和客戶端連線的執行緒，每個執行緒都是獨立進行互動的。
這就是伺服器端程式設計的模型，只是TCP方式是需要建立連線的，對於伺服器端的壓力比較大，而UDP是不需要建立連線的，對於伺服器端的壓力比較小罷了。
1.2.1.3 小結
總之，無論使用任何語言，任何方式進行基礎的網路程式設計，都必須遵循固定的步驟進行操作，在熟悉了這些步驟以後，可以根據需要進行邏輯上的處理，但是還是必須遵循固定的步驟進行。
其實，基礎的網路程式設計本身不難，也不需要很多的基礎網路知識，只是由於程式設計的基礎功能都已經由API實現，而且需要按照固定的步驟進行，所以在入門時有一定的門檻，希望下面的內容能夠將你快速的帶入網路程式設計技術的大門。
1.2.2 Java網路程式設計技術
Java語言是在網路環境下誕生的，所以Java語言雖然不能說是對於網路程式設計的支援最好的語言，但是必須說是一種對於網路程式設計提供良好支援的語言，使用Java語言進行網路程式設計將是一件比較輕鬆的工作。
和網路程式設計有關的基本API位於java.net包中，該包中包含了基本的網路程式設計實現，該包是網路程式設計的基礎。該包中既包含基礎的網路程式設計類，也包含封裝後的專門處理WEB相關的處理類。在本章中，將只介紹基礎的網路程式設計類。
首先來介紹一個基礎的網路類——InetAddress類。該類的功能是代表一個IP地址，並且將IP地址和域名相關的操作方法包含在該類的內部。
關於該類的使用，下面通過一個基礎的程式碼示例演示該類的使用，程式碼如下：
package inetaddressdemo;
import java.net.*;
/**
* 演示InetAddress類的基本使用
*/
public class InetAddressDemo {
public static void main(String[] args) {
try{
//使用域名建立物件
InetAddress inet1 = InetAddress.getByName("www.163.com");
System.out.println(inet1);
//使用IP建立物件
InetAddress inet2 = InetAddress.getByName("127.0.0.1");
System.out.println(inet2);
//獲得本機地址物件
InetAddress inet3 = InetAddress.getLocalHost();
System.out.println(inet3);
//獲得物件中儲存的域名
String host = inet3.getHostName();
System.out.println("域名：" + host);
//獲得物件中儲存的IP
String ip = inet3.getHostAddress();
System.out.println("IP:" + ip);
}catch(Exception e){}
}
}在該示例程式碼中，演示了InetAddress類的基本使用，並使用了該類中的幾個常用方法，該程式碼的執行結果是：
www.163.com/220.181.28.50
/127.0.0.1
chen/192.168.1.100
域名：chen
IP:192.168.1.100說明：由於該程式碼中包含一個網際網路的網址，所以執行該程式時需要聯網，否則將產生異常。
在後續的使用中，經常包含需要使用InetAddress物件代表IP地址的構造方法，當然，該類的使用不是必須的，也可以使用字串來代表IP地址進行實現。
1.2.3 TCP程式設計
按照前面的介紹，網路通訊的方式有TCP和UDP兩種，其中TCP方式的網路通訊是指在通訊的過程中保持連線，有點類似於打電話，只需要撥打一次號碼(建立一次網路連線)，就可以多次通話(多次傳輸資料)。這樣方式在實際的網路程式設計中，由於傳輸可靠，類似於打電話，如果甲給乙打電話，乙說沒有聽清楚讓甲重複一遍，直到乙聽清楚為止，實際的網路傳輸也是這樣，如果傳送的一方傳送的資料接收方覺得有問題，則網路底層會自動要求傳送方重發，直到接收方收到為止。
在Java語言中，對於TCP方式的網路程式設計提供了良好的支援，在實際實現時，以java.net.Socket類代表客戶端連線，以java.net.ServerSocket類代表伺服器端連線。在進行網路程式設計時，底層網路通訊的細節已經實現了比較高的封裝，所以在程式設計師實際程式設計時，只需要指定IP地址和埠號碼就可以建立連線了。正是由於這種高度的封裝，一方面簡化了Java語言網路程式設計的難度，另外也使得使用Java語言進行網路程式設計時無法深入到網路的底層，所以使用Java語言進行網路底層系統程式設計很困難，具體點說，Java語言無法實現底層的網路嗅探以及獲得IP包結構等資訊。但是由於Java語言的網路程式設計比較簡單，所以還是獲得了廣泛的使用。
在使用TCP方式進行網路程式設計時，需要按照前面介紹的網路程式設計的步驟進行，下面分別介紹一下在Java語言中客戶端和伺服器端的實現步驟。
在客戶端網路程式設計中，首先需要建立連線，在Java API中以java.net.Socket類的物件代表網路連線，所以建立客戶端網路連線，也就是建立Socket型別的物件，該物件代表網路連線，示例如下：
Socket socket1 = new Socket(“192.168.1.103”,10000);
Socket socket2 = new Socket(“www.sohu.com”,80);上面的程式碼中，socket1實現的是連線到IP地址是192.168.1.103的計算機的10000號埠，而socket2實現的是連線到域名是www.sohu.com的計算機的80號埠，至於底層網路如何實現建立連線，對於程式設計師來說是完全透明的。如果建立連線時，本機網路不通，或伺服器端程式未開啟，則會丟擲異常。
連線一旦建立，則完成了客戶端程式設計的第一步，緊接著的步驟就是按照“請求-響應”模型進行網路資料交換，在Java語言中，資料傳輸功能由Java IO實現，也就是說只需要從連線中獲得輸入流和輸出流即可，然後將需要傳送的資料寫入連線物件的輸出流中，在傳送完成以後從輸入流中讀取資料即可。示例程式碼如下：
OutputStream os = socket1.getOutputStream(); //獲得輸出流
InputStream is = socket1.getInputStream(); //獲得輸入流上面的程式碼中，分別從socket1這個連線物件獲得了輸出流和輸入流物件，在整個網路程式設計中，後續的資料交換就變成了IO操作，也就是遵循“請求-響應”模型的規定，先向輸出流中寫入資料，這些資料會被系統傳送出去，然後在從輸入流中讀取伺服器端的反饋資訊，這樣就完成了一次資料交換過程，當然這個資料交換過程可以多次進行。
這裡獲得的只是最基本的輸出流和輸入流物件，還可以根據前面學習到的IO知識，使用流的巢狀將這些獲得到的基本流物件轉換成需要的裝飾流物件，從而方便資料的操作。
最後當資料交換完成以後，關閉網路連線，釋放網路連線佔用的系統埠和記憶體等資源，完成網路操作，示例程式碼如下：
socket1.close();這就是最基本的網路程式設計功能介紹。下面是一個簡單的網路客戶端程式示例，該程式的作用是向伺服器端傳送一個字串“Hello”，並將伺服器端的反饋顯示到控制檯，資料交換隻進行一次，當資料交換進行完成以後關閉網路連線，程式結束。實現的程式碼如下：
package tcp;
import java.io.*;
import java.net.*;
/**
* 簡單的Socket客戶端
* 功能為：傳送字串“Hello”到伺服器端，並打印出伺服器端的反饋
*/
public class SimpleSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
//伺服器端IP地址
String serverIP = "127.0.0.1";
//伺服器端埠號
int port = 10000;
//傳送內容
String data = "Hello";
try {
//建立連線
socket = new Socket(serverIP,port);
//傳送資料
os = socket.getOutputStream();
os.write(data.getBytes());
//接收資料
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
//輸出反饋資料
System.out.println("伺服器反饋：" + new String(b,0,n));
} catch (Exception e) {
e.printStackTrace(); //列印異常資訊
}finally{
try {
//關閉流和連線
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}在該示例程式碼中建立了一個連線到IP地址為127.0.0.1，埠號碼為10000的TCP型別的網路連線，然後獲得連線的輸出流物件，將需要傳送的字串“Hello”轉換為byte陣列寫入到輸出流中，由系統自動完成將輸出流中的資料傳送出去，如果需要強制傳送，可以呼叫輸出流物件中的flush方法實現。在資料傳送出去以後，從連線物件的輸入流中讀取伺服器端的反饋資訊，讀取時可以使用IO中的各種讀取方法進行讀取，這裡使用最簡單的方法進行讀取，從輸入流中讀取到的內容就是伺服器端的反饋，並將讀取到的內容在客戶端的控制檯進行輸出，最後依次關閉開啟的流物件和網路連線物件。
這是一個簡單的功能示例，在該示例中演示了TCP型別的網路客戶端基本方法的使用，該程式碼只起演示目的，還無法達到實用的級別。
如果需要在控制檯下面編譯和執行該程式碼，需要首先在控制檯下切換到原始碼所在的目錄，然後依次輸入編譯和執行命令：
javac –d . SimpleSocketClient.java
java tcp.SimpleSocketClient和下面將要介紹的SimpleSocketServer伺服器端組合執行時，程式的輸出結果為：
伺服器反饋：Hello介紹完一個簡單的客戶端程式設計的示例，下面接著介紹一下TCP型別的伺服器端的編寫。首先需要說明的是，客戶端的步驟和伺服器端的編寫步驟不同，所以在學習伺服器端程式設計時注意不要和客戶端混淆起來。
在伺服器端程式程式設計中，由於伺服器端實現的是被動等待連線，所以伺服器端程式設計的第一個步驟是監聽埠，也就是監聽是否有客戶端連線到達。實現伺服器端監聽的程式碼為：
ServerSocket ss = new ServerSocket(10000);該程式碼實現的功能是監聽當前計算機的10000號埠，如果在執行該程式碼時，10000號埠已經被別的程式佔用，那麼將丟擲異常。否則將實現監聽。
伺服器端程式設計的第二個步驟是獲得連線。該步驟的作用是當有客戶端連線到達時，建立一個和客戶端連線對應的Socket連 接物件，從而釋放客戶端連線對於伺服器端埠的佔用。實現功能就像公司的前臺一樣，當一個客戶到達公司時，會告訴前臺我找某某某，然後前臺就通知某某某， 然後就可以繼續接待其它客戶了。通過獲得連線，使得客戶端的連線在伺服器端獲得了保持，另外使得伺服器端的埠釋放出來，可以繼續等待其它的客戶端連線。 實現獲得連線的程式碼是：
Socket socket = ss.accept();該程式碼實現的功能是獲得當前連線到伺服器端的客戶端連線。需要說明的是accept和前面IO部分介紹的read方法一樣，都是一個阻塞方法，也就是當無連線時，該方法將阻塞程式的執行，直到連線到達時才執行該行程式碼。另外獲得的連線會在伺服器端的該埠註冊，這樣以後就可以通過在伺服器端的註冊資訊直接通訊，而註冊以後伺服器端的埠就被釋放出來，又可以繼續接受其它的連線了。
連接獲得以後，後續的程式設計就和客戶端的網路程式設計類似了，這裡獲得的Socket型別的連線就和客戶端的網路連線一樣了，只是伺服器端需要首先讀取傳送過來的資料，然後進行邏輯處理以後再發送給客戶端，也就是交換資料的順序和客戶端交換資料的步驟剛好相反。這部分的內容和客戶端很類似，所以就不重複了，如果還不熟悉，可以參看下面的示例程式碼。
最後，在伺服器端通訊完成以後，關閉伺服器端連線。實現的程式碼為：
ss.close();這就是基本的TCP型別的伺服器端程式設計步驟。下面以一個簡單的echo服務實現為例子，介紹綜合使用示例。echo的意思就是“回聲”，echo伺服器端實現的功能就是將客戶端傳送的內容再原封不動的反饋給客戶端。實現的程式碼如下：
package tcp;
import java.io.*;
import java.net.*;
/**
* echo伺服器
* 功能：將客戶端傳送的內容反饋給客戶端
*/
public class SimpleSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//監聽埠號
int port = 10000;
try {
//建立連線
serverSocket = new ServerSocket(port);
//獲得連線
socket = serverSocket.accept();
//接收客戶端傳送內容
is = socket.getInputStream();
byte[] b = new byte[1024];
int n = is.read(b);
//輸出
System.out.println("客戶端傳送內容為：" + new String(b,0,n));
//向客戶端傳送反饋內容
os = socket.getOutputStream();
os.write(b, 0, n);
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//關閉流和連線
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}在該示例程式碼中建立了一個監聽當前計算機10000號埠的伺服器端Socket連線，然後獲得客戶端傳送過來的連線，如果有連線到達時，讀取連線中傳送過來的內容，並將傳送的內容在控制檯進行輸出，輸出完成以後將客戶端傳送的內容再反饋給客戶端。最後關閉流和連線物件，結束程式。
在控制檯下面編譯和執行該程式的命令和客戶端部分的類似。
這樣，就以一個很簡單的示例演示了TCP型別的網路程式設計在Java語言中的基本實現，這個示例只是演示了網路程式設計的基本步驟以及各個功能方法的基本使用，只是為網路程式設計打下了一個基礎，下面將就幾個問題來深入介紹網路程式設計深層次的一些知識。
為了一步一步的掌握網路程式設計，下面再研究網路程式設計中的兩個基本問題，通過解決這兩個問題將對網路程式設計的認識深入一層。
1、如何複用Socket連線？
在前面的示例中，客戶端中建立了一次連線，只發送一次資料就關閉了，這就相當於撥打電話時，電話打通了只對話一次就關閉了，其實更加常用的應該是撥通一次電話以後多次對話，這就是複用客戶端連線。
那 麼如何實現建立一次連線，進行多次資料交換呢？其實很簡單，建立連線以後，將資料交換的邏輯寫到一個迴圈中就可以了。這樣只要迴圈不結束則連線就不會被關 閉。按照這種思路，可以改造一下上面的程式碼，讓該程式可以在建立連線一次以後，傳送三次資料，當然這裡的次數也可以是多次，示例程式碼如下：
package tcp;
import java.io.*;
import java.net.*;
/**
* 複用連線的Socket客戶端
* 功能為：傳送字串“Hello”到伺服器端，並打印出伺服器端的反饋
*/
public class MulSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
//伺服器端IP地址
String serverIP = "127.0.0.1";
//伺服器端埠號
int port = 10000;
//傳送內容
String data[] ={"First","Second","Third"};
try {
//建立連線
socket = new Socket(serverIP,port);
//初始化流
os = socket.getOutputStream();
is = socket.getInputStream();
byte[] b = new byte[1024];
for(int i = 0;i < data.length;i++){
//傳送資料
os.write(data[i].getBytes());
//接收資料
int n = is.read(b);
//輸出反饋資料
System.out.println("伺服器反饋：" + new String(b,0,n));
}
} catch (Exception e) {
e.printStackTrace(); //列印異常資訊
}finally{
try {
//關閉流和連線
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}該示例程式和前面的程式碼相比，將資料交換部分的邏輯寫在一個for迴圈的內容，這樣就可以建立一次連線，依次將data陣列中的資料按照順序傳送給伺服器端了。
如果還是使用前面示例程式碼中的伺服器端程式執行該程式，則該程式的結果是：
java.net.SocketException: Software caused connection abort: recv failed
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.net.SocketInputStream.read(SocketInputStream.java:90)
at tcp.MulSocketClient.main(MulSocketClient.java:30)
伺服器反饋：First顯然，客戶端在實際執行時出現了異常，出現異常的原因是什麼呢？如果仔細閱讀前面的程式碼，應該還記得前面示例程式碼中的伺服器端是對話一次資料以後就關閉了連線，如果伺服器端程式關閉了，客戶端繼續傳送資料肯定會出現異常，這就是出現該問題的原因。
按照客戶端實現的邏輯，也可以複用伺服器端的連線，實現的原理也是將伺服器端的資料交換邏輯寫在迴圈中即可，按照該種思路改造以後的伺服器端程式碼為：
package tcp;
import java.io.*;
import java.net.*;
/**
* 複用連線的echo伺服器
* 功能：將客戶端傳送的內容反饋給客戶端
*/
public class MulSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//監聽埠號
int port = 10000;
try {
//建立連線
serverSocket = new ServerSocket(port);
System.out.println("伺服器已啟動：");
//獲得連線
socket = serverSocket.accept();
//初始化流
is = socket.getInputStream();
os = socket.getOutputStream();
byte[] b = new byte[1024];
for(int i = 0;i < 3;i++){
int n = is.read(b);
//輸出
System.out.println("客戶端傳送內容為：" + new String(b,0,n));
//向客戶端傳送反饋內容
os.write(b, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//關閉流和連線
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}在該示例程式碼中，也將資料傳送和接收的邏輯寫在了一個for迴圈內部，只是在實現時硬性的將迴圈次數規定成了3次，這樣程式碼雖然比較簡單，但是通用性比較差。
以該伺服器端程式碼實現為基礎執行前面的客戶端程式時，客戶端的輸出為：
伺服器反饋：First
伺服器反饋：Second
伺服器反饋：Third伺服器端程式的輸出結果為：
伺服器已啟動：
客戶端傳送內容為：First
客戶端傳送內容為：Second
客戶端傳送內容為：Third在該程式中，比較明顯的體現出了“請求-響應”模型，也就是在客戶端發起連線以後，首先發送字串“First”給伺服器端，伺服器端輸出客戶端傳送的內容“First”，然後將客戶端傳送的內容再反饋給客戶端，這樣客戶端也輸出伺服器反饋“First”，這樣就完成了客戶端和伺服器端的一次對話，緊接著客戶端傳送“Second”給伺服器端，服務端輸出“Second”，然後將“Second”再反饋給客戶端，客戶端再輸出“Second”，從而完成第二次會話，第三次會話的過程和這個一樣。在這個過程中，每次都是客戶端程式首先發送資料給伺服器端，伺服器接收資料以後，將結果反饋給客戶端，客戶端接收到伺服器端的反饋，從而完成一次通訊過程。
在該示例中，雖然解決了多次傳送的問題，但是客戶端和伺服器端的次數控制還不夠靈活，如果客戶端的次數不固定怎麼辦呢？是否可以使用某個特殊的字串，例如quit，表示客戶端退出呢,這就涉及到網路協議的內容了，會在後續的網路應用示例部分詳細介紹。下面開始介紹另外一個網路程式設計的突出問題。
2、如何使伺服器端支援多個客戶端同時工作？
前面介紹的伺服器端程式，只是實現了概念上的伺服器端，離實際的伺服器端程式結構距離還很遙遠，如果需要讓伺服器端能夠實際使用，那麼最需要解決的問題就是——如何支援多個客戶端同時工作。
一個伺服器端一般都需要同時為多個客戶端提供通訊，如果需要同時支援多個客戶端，則必須使用前面介紹的執行緒的概念。簡單來說，也就是當伺服器端接收到一個連線時，啟動一個專門的執行緒處理和該客戶端的通訊。
按照這個思路改寫的服務端示例程式將由兩個部分組成，MulThreadSocketServer類實現伺服器端控制，實現接收客戶端連線，然後開啟專門的邏輯執行緒處理該連線，LogicThread類實現對於一個客戶端連線的邏輯處理，將處理的邏輯放置在該類的run方法中。該示例的程式碼實現為：
package tcp;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 支援多客戶端的伺服器端實現
*/
public class MulThreadSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
//監聽埠號
int port = 10000;
try {
//建立連線
serverSocket = new ServerSocket(port);
System.out.println("伺服器已啟動：");
while(true){
//獲得連線
socket = serverSocket.accept();
//啟動執行緒
new LogicThread(socket);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//關閉連線
serverSocket.close();
}catch(Exception e){}
}
}
}在該示例程式碼中，實現了一個while形式的死迴圈，由於accept方法是阻塞方法，所以當客戶端連線未到達時，將阻塞該程式的執行，當客戶端到達時接收該連線，並啟動一個新的LogicThread執行緒處理該連線，然後按照迴圈的執行流程，繼續等待下一個客戶端連線。這樣當任何一個客戶端連線到達時，都開啟一個專門的執行緒處理，通過多個執行緒支援多個客戶端同時處理。
下面再看一下LogicThread執行緒類的原始碼實現：
package tcp;
import java.io.*;
import java.net.*;
/**
* 伺服器端邏輯執行緒
*/
public class LogicThread extends Thread {
Socket socket;
InputStream is;
OutputStream os;
public LogicThread(Socket socket){
this.socket = socket;
start(); //啟動執行緒
}
public void run(){
byte[] b = new byte[1024];
try{
//初始化流
os = socket.getOutputStream();
is = socket.getInputStream();
for(int i = 0;i < 3;i++){
//讀取資料
int n = is.read(b);
//邏輯處理
byte[] response = logic(b,0,n);
//反饋資料
os.write(response);
}
}catch(Exception e){
e.printStackTrace();
}finally{
close();
}
}
/**
* 關閉流和連線
*/
private void close(){
try{
//關閉流和連線
os.close();
is.close();
socket.close();
}catch(Exception e){}
}
/**
* 邏輯處理方法,實現echo邏輯
* @param b 客戶端傳送資料緩衝區
* @param off 起始下標
* @param len 有效資料長度
* @return
*/
private byte[] logic(byte[] b,int off,int len){
byte[] response = new byte[len];
//將有效資料拷貝到陣列response中
System.arraycopy(b, 0, response, 0, len);
return response;
}
}在該示例程式碼中，每次使用一個連線物件構造該執行緒，該連線物件就是該執行緒需要處理的連線，線上程構造完成以後，該執行緒就被啟動起來了，然後在run方法內部對客戶端連線進行處理，資料交換的邏輯和前面的示例程式碼一致，只是這裡將接收到客戶端傳送過來的資料並進行處理的邏輯封裝成了logic方法，按照前面介紹的IO程式設計的內容，客戶端傳送過來的內容儲存在陣列b的起始下標為0，長度為n箇中，這些資料是客戶端傳送過來的有效資料，將有效的資料傳遞給logic方法，logic方法實現的是echo服務的邏輯，也就是將客戶端傳送的有效資料形成以後新的response陣列，並作為返回值反饋。
線上程中將logic方法的返回值反饋給客戶端，這樣就完成了伺服器端的邏輯處理模擬，其他的實現和前面的介紹類似，這裡就不在重複了。
這裡的示例還只是基礎的伺服器端實現，在實際的伺服器端實現中，由於硬體和埠數的限制，所以不能無限制的建立執行緒物件，而且頻繁的建立執行緒物件效率也比較低，所以程式中都實現了執行緒池來提高程式的執行效率。
這裡簡單介紹一下執行緒池的概念，執行緒池(Thread pool)是池技術的一種，就是在程式啟動時首先把需要個數的執行緒物件建立好，例如建立5000個執行緒物件，然後當客戶端連線到達時從池中取出一個已經建立完成的執行緒物件使用即可。當客戶端連線關閉以後，將該執行緒物件重新放入到執行緒池中供其它的客戶端重複使用，這樣可以提高程式的執行速度，優化程式對於記憶體的佔用等。
關於基礎的TCP方式的網路程式設計就介紹這麼多，下面介紹UDP方式的網路程式設計在Java語言中的實現。
網路通訊的方式除了TCP方式以外，還有一種實現的方式就是UDP方式。UDP(User Datagram Protocol)，中文意思是使用者資料報協議，方式類似於發簡訊息，是一種物美價廉的通訊方式，使用該種方式無需建立專用的虛擬連線，由於無需建立專用的連線，所以對於伺服器的壓力要比TCP小很多，所以也是一種常見的網路程式設計方式。但是使用該種方式最大的不足是傳輸不可靠，當然也不是說經常丟失，就像大家發簡訊息一樣，理論上存在收不到的可能，這種可能性可能是1%，反正比較小，但是由於這種可能的存在，所以平時我們都覺得重要的事情還是打個電話吧(類似TCP方式)，一般的事情才發簡訊息(類似UDP方式)。網路程式設計中也是這樣，必須要求可靠傳輸的資訊一般使用TCP方式實現，一般的資