聊聊Socket、TCP/IP、HTTP、FTP及網絡編程
1 這些都是什么
既然是網絡傳輸，涉及幾個系統之間的交互，那么首先要考慮的是如何準確的定位到網絡上的一臺或幾臺主機，另一個是如何進行可靠高效的數據傳輸。這里就要使用到TCP/IP協議。
1.1 TCP/IP協議組
TCP/IP協議（傳輸控制協議）由網絡層的IP協議和傳輸層的TCP協議組成。
IP層負責網絡主機的定位，數據傳輸的路由，由IP地址可以唯一的確定Internet上的一臺主機。
TCP層負責面向應用的可靠的或非可靠的數據傳輸機制，這是網絡編程的主要對象。
TCP/IP是個協議組，可分為三個層次：網絡層、傳輸層和應用層：
網絡層：IP協議、ICMP協議、ARP協議、RARP協議和BOOTP協議；
傳輸層：TCP協議與UDP協議；
應用層：FTP、HTTP、TELNET、SMTP、DNS等協議；
HTTP是應用層協議，其傳輸都是被包裝成TCP協議傳輸。可以用SOCKET實現HTTP。SOCKET是實現傳輸層協議的一種編程API，可以是TCP，也可以是UDP。
1.2 TCP
TCP — 傳輸控制協議,提供的是面向連接、可靠的字節流服務。當客戶和服務器彼此交換數據前，必須先在雙方之間建立一個TCP連接，之后才能傳輸數據。TCP提供超時重發，丟棄重復數據，檢驗數據，流量控制等功能，保證數據能從一端傳到另一端。 理想狀態下，TCP連接一旦建立，在通信雙方中的任何一方主動關閉連接前，TCP 連接都將被一直保持下去。斷開連接時服務器和客戶端均可以主動發起斷開TCP連接的請求。
TCP是一種面向連接的保證可靠傳輸的協議。通過TCP協議傳輸，得到的是一個順序的無差錯的數據流。發送方和接收方的成對的兩個socket之間必須建立連接，以便在TCP協議的基礎上進行通信，當一個socket（通常都是server socket）等待建立連接時，另一個socket可以要求進行連接，一旦這兩個socket連接起來，它們就可以進行雙向數據傳輸，雙方都可以進行發送或接收操作。
TCP特點：
- TCP是面向連接的協議，通過三次握手建立連接，通訊完成時要拆除連接，由于TCP是面向連接協議，所以只能用于點對點的通訊。而且建立連接也需要消耗時間和開銷。
- TCP傳輸數據無大小限制，進行大數據傳輸。
- TCP是一個可靠的協議，它能保證接收方能夠完整正確地接收到發送方發送的全部數據。
要了解TCP，一定要知道”三次握手，四次拜拜”所謂的三次握手，就是發送數據前必須建立的連接叫三次握手，握手完了才開始發的，這也就是面向連接的意思。
第一次握手：客戶端發送syn包(syn=j)到服務器，并進入SYN_SEND狀態，等待服務器確認；
第二次握手：服務器收到syn包，必須確認客戶的SYN（ack=j+1），同時自己也發送一個SYN包（syn=k），即SYN+ACK包，此時服務器進入SYN_RECV狀態；
第三次握手：客戶端收到服務器的SYN＋ACK包，向服務器發送確認包ACK(ack=k+1)，此包發送完畢，客戶端和服務器進入ESTABLISHED狀態，完成三次握手；
【適用情況】
TCP發送的包有序號，對方收到包后要給一個反饋，如果超過一定時間還沒收到反饋就自動執行超時重發，因此TCP最大的優點是可靠。一般網頁（http）、郵件（SMTP)、遠程連接(Telnet)、文件(FTP)傳送就用TCP
TCP在網絡通信上有極強的生命力，例如遠程連接（Telnet）和文件傳輸（FTP）都需要不定長度的數據被可靠地傳輸。但是可靠的傳輸是要付出代價的，對數據內容正確性的檢驗必然占用計算機的處理時間和網絡的帶寬，因此TCP傳輸的效率不如UDP高。
1.3 UDP
UDP — 用戶數據報協議，是一個無連接的簡單的面向數據報的運輸層協議。UDP不提供可靠性，它只是把應用程序傳給IP層的數據報發送出去，但是并不能保證它們能到達目的地。由于UDP在傳輸數據報前不用在客戶和服務器之間建立一個連接，且沒有超時重發等機制，故而傳輸速度很快。
UDP是一種面向無連接的協議，每個數據報都是一個獨立的信息，包括完整的源地址或目的地址，它在網絡上以任何可能的路徑傳往目的地，因此能否到達目的地，到達目的地的時間以及內容的正確性都是不能被保證的。
UDP特點：
- UDP是面向無連接的通訊協議，UDP數據包括目的端口號和源端口號信息，由于通訊不需要連接，所以可以實現廣播發送。
- UDP傳輸數據時有大小限制，每個被傳輸的數據報必須限定在64KB之內。
- UDP是一個不可靠的協議，發送方所發送的數據報并不一定以相同的次序到達接收方。
【適用情況】
UDP是面向消息的協議，通信時不需要建立連接，數據的傳輸自然是不可靠的，UDP一般用于多點通信和實時的數據業務，比如語音廣播、視頻、QQ、TFTP(簡單文件傳送）、SNMP（簡單網絡管理協議）、RTP（實時傳送協議）RIP（路由信息協議，如報告股票市場，航空信息）、DNS(域名解釋）。注重速度流暢。
UDP操作簡單，而且僅需要較少的監護，因此通常用于局域網高可靠性的分散系統中client/server應用程序。例如視頻會議系統，并不要求音頻視頻數據絕對的正確，只要保證連貫性就可以了，這種情況下顯然使用UDP會更合理一些。
1.4 Socket
Socket通常也稱作”套接字”，用于描述IP地址和端口，是一個通信鏈的句柄。網絡上的兩個程序通過一個雙向的通訊連接實現數據的交換，這個雙向鏈路的一端稱為一個Socket，一個Socket由一個IP地址和一個端口號唯一確定。應用程序通常通過”套接字”向網絡發出請求或者應答網絡請求。Socket是TCP/IP協議的一個十分流行的編程界面，但是，Socket所支持的協議種類也不光TCP/IP一種，因此兩者之間是沒有必然聯系的。在Java環境下，Socket編程主要是指基于TCP/IP協議的網絡編程。
Socket通訊過程：服務端監聽某個端口是否有連接請求，客戶端向服務端發送連接請求，服務端收到連接請求向客戶端發出接收消息，這樣一個連接就建立起來了。客戶端和服務端都可以相互發送消息與對方進行通訊。
Socket是應用層與TCP/IP協議族通信的中間軟件抽象層，它是一組接口。在設計模式中，Socket其實就是一個門面模式，它把復雜的TCP/IP協議族隱藏在Socket接口后面，對用戶來說，一組簡單的接口就是全部，讓Socket去組織數據，以符合指定的協議。
由于通常情況下Socket連接就是TCP連接，因此Socket連接一旦建立，通信雙方即可開始相互發送數據內容，直到雙方連接斷開。但在實際網絡應用中，客戶端到服務器之間的通信往往需要穿越多個中間節點，例如路由器、網關、防火墻等，大部分防火墻默認會關閉長時間處于非活躍狀態的連接而導致 Socket 連接斷連，因此需要通過輪詢告訴網絡，該連接處于活躍狀態。
- 套接字（socket）概念： 套接字（socket）是通信的基石，是支持TCP/IP協議的網絡通信的基本操作單元。它是網絡通信過程中端點的抽象表示，包含進行網絡通信必須的五種信息：連接使用的協議，本地主機的IP地址，本地進程的協議端口，遠地主機的IP地址，遠地進程的協議端口。應用層通過傳輸層進行數據通信時，TCP會遇到同時為多個應用程序進程提供并發服務的問題。多個TCP連接或多個應用程序進程可能需要通過同一個TCP協議端口傳輸數據。為了區別不同的應用程序進程和連接，許多計算機操作系統為應用程序與TCP／IP協議交互提供了套接字(Socket)接口。應用層可以和傳輸層通過Socket接口，區分來自不同應用程序進程或網絡連接的通信，實現數據傳輸的并發服務。
- 建立socket連接： 建立Socket連接至少需要一對套接字，其中一個運行于客戶端，稱為ClientSocket ，另一個運行于服務器端，稱為ServerSocket。套接字之間的連接過程分為三個步驟：服務器監聽，客戶端請求，連接確認。
服務器監聽：服務器端套接字并不定位具體的客戶端套接字，而是處于等待連接的狀態，實時監控網絡狀態，等待客戶端的連接請求；
客戶端請求：指客戶端的套接字提出連接請求，要連接的目標是服務器端的套接字。為此，客戶端的套接字必須首先描述它要連接的服務器的套接字，指出服務器端套接字的地址和端口號，然后就向服務器端套接字提出連接請求。
連接確認：當服務器端套接字監聽到或者說接收到客戶端套接字的連接請求時，就響應客戶端套接字的請求，建立一個新的線程，把服務器端套接字的描述發給客戶端，一旦客戶端確認了此描述，雙方就正式建立連接。而服務器端套接字繼續處于監聽狀態，繼續接收其他客戶端套接字的連接請求。
- SOCKET連接與TCP連接 創建Socket連接時，可以指定使用的傳輸層協議，Socket可以支持不同的傳輸層協議（TCP或UDP），當使用TCP協議進行連接時，該Socket連接就是一個TCP連接。
【適用情況】
很多情況下，需要服務器端主動向客戶端推送數據，保持客戶端與服務器數據的實時與同步。此時若雙方建立的是Socket連接，服務器就可以直接將數據傳送給客戶端；
1.5 HTTP
HTTP協議是建立在TCP協議之上的一種應用，HTTP連接使用的是“請求—響應”的方式，不僅在請求時需要先建立TCP連接，而且需要客戶端向服務器發出請求后，請求中包含請求方法、URI、協議版本以及相關的MIME樣式的消息，服務器端才能回復數據，包含消息的協議版本、一個成功和失敗碼以及相關的MIME式樣的消息。在請求結束后，會主動釋放連接。從建立連接到關閉連接的過程稱為“一次連接”。由于HTTP在每次請求結束后都會主動釋放連接，因此HTTP連接是一種“短連接”，要保持客戶端程序的在線狀態，需要不斷地向服務器發起連接請求。通常的做法是即時不需要獲得任何數據，客戶端也保持每隔一段固定的時間向服務器發送一次“保持連接”的請求，服務器在收到該請求后對客戶端進行回復，表明知道客戶端“在線”。若服務器長時間無法收到客戶端的請求，則認為客戶端“下線”，若客戶端長時間無法收到服務器的回復，則認為網絡已經斷開。
HTTP/1.0為每一次HTTP的請求/響應建立一條新的TCP鏈接，因此一個包含HTML內容和圖片的頁面將需要建立多次的短期的TCP鏈接。一次TCP鏈接的建立將需要3次握手。
另外，為了獲得適當的傳輸速度，則需要TCP花費額外的回路鏈接時間（RTT）。每一次鏈接的建立需要這種經常性的開銷，而其并不帶有實際有用的數據，只是保證鏈接的可靠性，因此HTTP/1.1提出了可持續鏈接的實現方法。HTTP/1.1將只建立一次TCP的鏈接而重復地使用它傳輸一系列的請求/響應消息，因此減少了鏈接建立的次數和經常性的鏈接開銷。
結論：HTTP是應用層協議，其傳輸都是被包裝成TCP協議傳輸。可以用SOCKET實現HTTP。SOCKET是實現傳輸層協議的一種編程API，可以是TCP，也可以是UDP。
【適用情況】
若雙方建立的是HTTP連接，則服務器需要等到客戶端發送一次請求后才能將數據傳回給客戶端，因此，客戶端定時向服務器端發送連接請求，不僅可以保持在線，同時也是在“詢問”服務器是否有新的數據，如果有就將數據傳給客戶端。
1.6 FTP
文件傳輸協議（File Transfer Protocol, FTP）是TCP/IP網絡上兩臺計算機傳送文件的協議，FTP是在TCP/IP網絡和INTERNET上最早使用的協議之一，它屬于網絡協議組的應用層。FTP客戶機可以給服務器發出命令來下載文件，上載文件，創建或改變服務器上的目錄。
2 N層交換技術
2.1 二層交換
交換原理：根據第二層數據鏈路層的MAC地址來實現端到端的數據交換；
工作流程：
（1）交換機某端口收到數據包，讀取源MAC地址，得到源MAC地址機器所連端口；
（2）讀取目的MAC地址，在地址表中查找對應端口；
（3）如果地址表中有目的MAC地址對應端口，直接復制數據至此端口；
（4）如果地址表中沒有目的MAC地址對應端口，廣播所有端口，當目的機器回應時，更新地址表，下次就不需要廣播了；
不斷的循環上述過程，全網的MAC地址信息都可以學習到，二層交換機就這樣學習和維護它的地址表。第二層交換機根據MAC選擇端口轉發數據，算法又很簡單，其方便采用廉價芯片實現，且速度快。
2.2 三層交換
交換原理：根據第三層網絡層的IP地址來完成端到端的數據交換；
場景：A(ip1) => 三層交換機 =>B(ip2)
工作流程：
（1）A發數據給B，根據B的ip地址+子網掩碼，A能夠判斷出B和自己是否在同一個網段；
（2）B如果和A在同一個網段內，但A不知道B的MAC地址，A會發送一個ARP請求，以獲取B的MAC地址，并根據MAC通過二層交換機將數據發送給B；
（3）B如果和A不在同一個網段內，且不知道B的MAC地址，A會將數據包發送給網關（A的本地一定有網關的MAC地址）。網關收到數據包后，將源MAC地址會修改為網關自己的MAC地址，目的IP對應的MAC地址為目的MAC地址，以完成數據交換。
看似第三層交換機是第二層交換機+路由功能的組合，實際并非這樣：數據通過第三層轉發設備后，會記錄IP與MAC的映射關系，下次需要轉發時，不會再經過第三層設備。
2.3 四層交換
二層和三層交換設備都是基于端到端的交換，這種基于IP和MAC地址的交換技術，有著很高效傳輸率，但是缺乏根據目的主機應用需求動態交換數據的功能。
四層設備不但能夠完成端到端的交換，還能夠根據目的主機的應用特點，分配或限制其流量；
四層設備基于傳輸層數據包交換，是一類建立在TCP/IP應用層至上，實現用戶應用需求的設備；它實現一類應用層的訪問控制與質量保證服務，與其說它是硬件設備，不如說它是軟件網絡管理系統。
四層交換核心技術
- 包過濾 利用四層信息定義過濾規則，能夠控制指定端口的TCP/UDP通信，它可以在高速芯片中實現，極大提高包過濾速率；
- 包優先級 三層以下設備只有MAC，PORT，IP等信息，因為缺乏四層信息，無法確認TCP/IP等四層優先級信息；四層設備允許基于目的地址/端口（即應用服務）的組合來區分優先級。
- 負載均衡
將附加有負載均衡服務的IP地址，通過不同的物理服務做成一個集群，提供相同的服務，并將其定義為一個單獨的虛擬服務器；這個虛擬服務器是一個有獨立IP的邏輯服務器，用戶數據流只需要流向虛擬服務器IP，而不與物理服務器進行通信；
只有通過交換機執行網絡地址轉換（NAT）后，才能得到真實訪問；
虛擬服務器組里轉換通信流量實現均衡，其中具體關系到OSPF、RIP、VRRP等協議；
- 主機備用連接 同（3）所含技術類似，可以實現主備同IP自動切換；
2.4 七層交換
交換原理：比四層更進一步，可以根據應用層的數據報文來完成更多的復雜交換功能（例如根據http報文路由）。由于七層交換還沒有具體的標準，文章也不多展開啦。
3 JDK Socket
在java.net包下有兩個類：Socket和ServerSocket。ServerSocket用于服務器端，Socket是建立網絡連接時使用的。在連接成功時，應用程序兩端都會產生一個Socket實例，操作這個實例，完成所需的會話。對于一個網絡連接來說，套接字是平等的，并沒有差別，不因為在服務器端或在客戶端而產生不同級別。不管是Socket還是ServerSocket它們的工作都是通過SocketImpl類及其子類完成的。
列出幾個常用的構造方法：
Socket(InetAddress address,int port); //創建一個流套接字并將其連接到指定 IP 地址的指定端口號
Socket(String host,int port); //創建一個流套接字并將其連接到指定主機上的指定端口號
Socket(InetAddress address,int port, InetAddress localAddr,int localPort); //創建一個套接字并將其連接到指定遠程地址上的指定遠程端口
Socket(String host,int port, InetAddress localAddr,int localPort); //創建一個套接字并將其連接到指定遠程主機上的指定遠程端口
Socket(SocketImpl impl); //使用用戶指定的 SocketImpl 創建一個未連接 Socket
ServerSocket(int port); //創建綁定到特定端口的服務器套接字
ServerSocket(int port,int backlog); //利用指定的 backlog 創建服務器套接字并將其綁定到指定的本地端口號
ServerSocket(int port,int backlog, InetAddress bindAddr); //使用指定的端口、偵聽 backlog 和要綁定到的本地 IP地址創建服務器</code></pre>
構造方法的參數中，address、host和port分別是雙向連接中另一方的IP地址、主機名和端 口號，stream指明socket是流socket還是數據報socket，localPort表示本地主機的端口號，localAddr和bindAddr是本地機器的地址（ServerSocket的主機地址），impl是socket的父類，既可以用來創建serverSocket又可以用來創建Socket。count則表示服務端所能支持的最大連接數。
注意：必須小心選擇端口號。每一個端口提供一種特定的服務，只有給出正確的端口，才能獲得相應的服務。0~1023的端口號為系統所保留，例如http服務的端口號為80,telnet服務的端口號為21,ftp服務的端口號為23, 所以我們在選擇端口號時，最好選擇一個大于1023的數以防止發生沖突。
幾個重要的Socket方法：
public InputStream getInputStream(); //方法獲得網絡連接輸入，同時返回一個IutputStream對象實例
public OutputStream getOutputStream(); //方法連接的另一端將得到輸入，同時返回一個OutputStream對象實例
public Socket accept(); //用于產生"阻塞"，直到接受到一個連接，并且返回一個客戶端的Socket對象實例。
“阻塞”是一個術語，它使程序運行暫時”停留”在這個地方，直到一個會話產生，然后程序繼續；通常”阻塞”是由循環產生的。
注意：其中getInputStream和getOutputStream方法均會產生一個IOException，它必須被捕獲，因為它們返回的流對象，通常都會被另一個流對象使用。
4 基本的Client/Server程序
以下是一個基本的客戶端/服務器端程序代碼。主要實現了服務器端一直監聽某個端口，等待客戶端連接請求。客戶端根據IP地址和端口號連接服務器端，從鍵盤上輸入一行信息，發送到服務器端，然后接收服務器端返回的信息，最后結束會話。這個程序一次只能接受一個客戶連接。
客戶端程序：
package sock;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class SocketClient {
public static void main(String[] args) {
try {
/* 創建Socket/
// 創建一個流套接字并將其連接到指定 IP 地址的指定端口號(本處是本機)
Socket socket =new Socket("127.0.0.1",2013);
// 60s超時
socket.setSoTimeout(60000);
/** 發送客戶端準備傳輸的信息 */
// 由Socket對象得到輸出流，并構造PrintWriter對象
PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);
// 將輸入讀入的字符串輸出到Server
BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
printWriter.println(sysBuff.readLine());
// 刷新輸出流，使Server馬上收到該字符串
printWriter.flush();
/** 用于獲取服務端傳輸來的信息 */
// 由Socket對象得到輸入流，并構造相應的BufferedReader對象
BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 輸入讀入一字符串
String result = bufferedReader.readLine();
System.out.println("Server say : " + result);
/** 關閉Socket*/
printWriter.close();
bufferedReader.close();
socket.close();
}catch (Exception e) {
System.out.println("Exception:" + e);
}
}
}</code></pre>
服務器端程序：
package sock;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServer {
public static void main(String[] args) {
try {
/* 創建ServerSocket/
// 創建一個ServerSocket在端口2013監聽客戶請求
ServerSocket serverSocket =new ServerSocket(2013);
while (true) {
// 偵聽并接受到此Socket的連接,請求到來則產生一個Socket對象，并繼續執行
Socket socket = serverSocket.accept();
/** 獲取客戶端傳來的信息 */
// 由Socket對象得到輸入流，并構造相應的BufferedReader對象
BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 獲取從客戶端讀入的字符串
String result = bufferedReader.readLine();
System.out.println("Client say : " + result);
/** 發送服務端準備傳輸的 */
// 由Socket對象得到輸出流，并構造PrintWriter對象
PrintWriter printWriter =new PrintWriter(socket.getOutputStream());
printWriter.print("hello Client, I am Server!");
printWriter.flush();
/** 關閉Socket*/
printWriter.close();
bufferedReader.close();
socket.close();
}
}catch (Exception e) {
System.out.println("Exception:" + e);
}finally{
//serverSocket.close();
}
}
}</code></pre>
5 多客戶端連接服務器
上面的服務器端程序一次只能連接一個客戶端，這在實際應用中顯然是不可能的。通常的網絡環境是多個客戶端連接到某個主機進行通訊，所以我們要對上面的程序進行改造。
設計思路：服務器端主程序監聽某一個端口，客戶端發起連接請求，服務器端主程序接收請求，同時構造一個線程類，用于接管會話。當一個Socket會話產生后，這個會話就會交給線程進行處理，主程序繼續進行監聽。
下面的實現程序流程是：客戶端和服務器建立連接，客戶端發送消息，服務端根據消息進行處理并返回消息，若客戶端申請關閉，則服務器關閉此連接，雙方通訊結束。
客戶端程序：
package sock;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class SocketClient {
public static void main(String[] args) {
try {
Socket socket =new Socket("127.0.0.1",2013);
socket.setSoTimeout(60000);
PrintWriter printWriter =new PrintWriter(socket.getOutputStream(),true);
BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(socket.getInputStream()));
String result ="";
while(result.indexOf("bye") == -1){
BufferedReader sysBuff =new BufferedReader(new InputStreamReader(System.in));
printWriter.println(sysBuff.readLine());
printWriter.flush();
result = bufferedReader.readLine();
System.out.println("Server say : " + result);
}
printWriter.close();
bufferedReader.close();
socket.close();
}catch (Exception e) {
System.out.println("Exception:" + e);
}
}
}</code></pre>
服務器端程序：
package sock;
import java.io.;
import java.net.;
public classServerextendsServerSocket {
private static final int SERVER_PORT =2013;
public Server()throws IOException {
super(SERVER_PORT);
try {
while (true) {
Socket socket = accept();
new CreateServerThread(socket);//當有請求時，啟一個線程處理
}
}catch (IOException e) {
}finally {
close();
}
}
//線程類
classCreateServerThreadextendsThread {
private Socket client;
private BufferedReader bufferedReader;
private PrintWriter printWriter;
public CreateServerThread(Socket s)throws IOException {
client = s;
bufferedReader =new BufferedReader(new InputStreamReader(client.getInputStream()));
printWriter =new PrintWriter(client.getOutputStream(),true);
System.out.println("Client(" + getName() +") come in...");
start();
}
public void run() {
try {
String line = bufferedReader.readLine();
while (!line.equals("bye")) {
printWriter.println("continue, Client(" + getName() +")!");
line = bufferedReader.readLine();
System.out.println("Client(" + getName() +") say: " + line);
}
printWriter.println("bye, Client(" + getName() +")!");
System.out.println("Client(" + getName() +") exit!");
printWriter.close();
bufferedReader.close();
client.close();
}catch (IOException e) {
}
}
}
public static void main(String[] args)throws IOException {
new Server();
}
}</code></pre>
6 信息群發共享
以上雖然實現了多個客戶端和服務器連接，但是仍然是消息在一個客戶端和服務器之間相互傳播。現在我們要實現信息共享，即服務器可以向多個客戶端發送廣播消息，客戶端也可以向其他客戶端發送消息。類似于聊天室的那種功能，實現信息能在多個客戶端之間共享。
設計思路：客戶端循環可以不停輸入向服務器發送消息，并且啟一個線程，專門用來監聽服務器端發來的消息并打印輸出。服務器端啟動時，啟動一個監聽何時需要向客戶端發送消息的線程。每次接受客戶端連接請求，都啟一個線程進行處理，并且將客戶端信息存放到公共集合中。當客戶端發送消息時，服務器端將消息順序存入隊列中，當需要輸出時，從隊列中取出廣播到各客戶端處。客戶端輸入showuser命令可以查看在線用戶列表，輸入bye向服務器端申請退出連接。
客戶端代碼：
package sock;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public classSocketClientextendsSocket{
private static final String SERVER_IP ="127.0.0.1";
private static final int SERVER_PORT =2013;
private Socket client;
private PrintWriter out;
private BufferedReader in;
/**
* 與服務器連接，并輸入發送消息
*/
public SocketClient()throws Exception{
super(SERVER_IP, SERVER_PORT);
client =this;
out =new PrintWriter(this.getOutputStream(),true);
in =new BufferedReader(new InputStreamReader(this.getInputStream()));
new readLineThread();
while(true){
in =new BufferedReader(new InputStreamReader(System.in));
String input = in.readLine();
out.println(input);
}
}
/**
* 用于監聽服務器端向客戶端發送消息線程類
*/
classreadLineThreadextendsThread{
private BufferedReader buff;
public readLineThread(){
try {
buff =new BufferedReader(new InputStreamReader(client.getInputStream()));
start();
}catch (Exception e) {
}
}
@Override
public void run() {
try {
while(true){
String result = buff.readLine();
if("byeClient".equals(result)){//客戶端申請退出，服務端返回確認退出
break;
}else{//輸出服務端發送消息
System.out.println(result);
}
}
in.close();
out.close();
client.close();
}catch (Exception e) {
}
}
}
public static void main(String[] args) {
try {
new SocketClient();//啟動客戶端
}catch (Exception e) {
}
}
}</code></pre>
服務器端代碼：
package sock;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class Server extends ServerSocket{
private static final int SERVER_PORT =2013;
private static boolean isPrint =false;//是否輸出消息標志
private static List user_list =new ArrayList();//登錄用戶集合
private static List<ServerThread> thread_list =new ArrayList<ServerThread>();//服務器已啟用線程集合
private static LinkedList<String> message_list =new LinkedList<String>();//存放消息隊列
/**
* 創建服務端Socket,創建向客戶端發送消息線程,監聽客戶端請求并處理
*/
public Server()throws IOException{
super(SERVER_PORT);//創建ServerSocket
new PrintOutThread();//創建向客戶端發送消息線程
try {
while(true){//監聽客戶端請求，啟個線程處理
Socket socket = accept();
new ServerThread(socket);
}
}catch (Exception e) {
}finally{
close();
}
}
/**
* 監聽是否有輸出消息請求線程類,向客戶端發送消息
*/
class PrintOutThread extends Thread{
public PrintOutThread(){
start();
}
@Override
public void run() {
while(true){
if(isPrint){//將緩存在隊列中的消息按順序發送到各客戶端，并從隊列中清除。
String message = message_list.getFirst();
for (ServerThread thread : thread_list) {
thread.sendMessage(message);
}
message_list.removeFirst();
isPrint = message_list.size() >0 ?true :false;
}
}
}
}
/**
* 服務器線程類
*/
class ServerThread extends Thread{
private Socket client;
private PrintWriter out;
private BufferedReader in;
private String name;
public ServerThread(Socket s)throws IOException{
client = s;
out =new PrintWriter(client.getOutputStream(),true);
in =new BufferedReader(new InputStreamReader(client.getInputStream()));
in.readLine();
out.println("成功連上聊天室,請輸入你的名字：");
start();
}
@Override
public void run() {
try {
int flag =0;
String line = in.readLine();
while(!"bye".equals(line)){
//查看在線用戶列表
if ("showuser".equals(line)) {
out.println(this.listOnlineUsers());
line = in.readLine();
}
//第一次進入，保存名字
if(flag++ ==0){
name = line;
user_list.add(name);
thread_list.add(this);
out.println(name +"你好,可以開始聊天了...");
this.pushMessage("Client<" + name +">進入聊天室...");
}else{
this.pushMessage("Client<" + name +"> say : " + line);
}
line = in.readLine();
}
out.println("byeClient");
}catch (Exception e) {
e.printStackTrace();
}finally{//用戶退出聊天室
try {
client.close();
}catch (IOException e) {
e.printStackTrace();
}
thread_list.remove(this);
user_list.remove(name);
pushMessage("Client<" + name +">退出了聊天室");
}
}
//放入消息隊列末尾，準備發送給客戶端
private void pushMessage(String msg){
message_list.addLast(msg);
isPrint =true;
}
//向客戶端發送一條消息
private void sendMessage(String msg){
out.println(msg);
}
//統計在線用戶列表
private String listOnlineUsers() {
String s ="--- 在線用戶列表 ---1512";
for (int i =0; i < user_list.size(); i++) {
s +="[" + user_list.get(i) +"]1512";
}
s +="--------------------";
return s;
}
}
public static void main(String[] args)throws IOException {
new Server();//啟動服務端
}
}</code></pre>
7 文件傳輸
客戶端向服務器端傳送文件，服務端可獲取文件名用于保存，獲取文件大小計算傳輸進度，比較簡單，直接貼代碼。
客戶端代碼：
package sock;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.Socket;
/**
客戶端
*/
public class Client extends Socket{
private static final String SERVER_IP ="127.0.0.1";
private static final int SERVER_PORT =2013;
private Socket client;
private FileInputStream fis;
private DataOutputStream dos;
public Client(){
try {
try {
client =new Socket(SERVER_IP, SERVER_PORT);
//向服務端傳送文件
File file =new File("c:/test.doc");
fis =new FileInputStream(file);
dos =new DataOutputStream(client.getOutputStream());
//文件名和長度
dos.writeUTF(file.getName());
dos.flush();
dos.writeLong(file.length());
dos.flush();
//傳輸文件
byte[] sendBytes =new byte[1024];
int length =0;
while((length = fis.read(sendBytes,0, sendBytes.length)) >0){
dos.write(sendBytes,0, length);
dos.flush();
}
}catch (Exception e) {
e.printStackTrace();
}finally{
if(fis !=null)
fis.close();
if(dos !=null)
dos.close();
client.close();
}
}catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args)throws Exception {
new Client();
}
}</code></pre>
服務器端代碼：
package sock;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
服務器
*/
public classServerextendsServerSocket{
private static final int PORT =2013;
private ServerSocket server;
private Socket client;
private DataInputStream dis;
private FileOutputStream fos;
publicServer()throws Exception{
try {
try {
server =new ServerSocket(PORT);
while(true){
client = server.accept();
dis =new DataInputStream(client.getInputStream());
//文件名和長度
String fileName = dis.readUTF();
long fileLength = dis.readLong();
fos =new FileOutputStream(new File("d:/" + fileName));
byte[] sendBytes =new byte[1024];
int transLen =0;
System.out.println("----開始接收文件<" + fileName +">,文件大小為<" + fileLength +">----");
while(true){
int read =0;
read = dis.read(sendBytes);
if(read == -1)
break;
transLen += read;
System.out.println("接收文件進度" +100 * transLen/fileLength +"%...");
fos.write(sendBytes,0, read);
fos.flush();
}
System.out.println("----接收文件<" + fileName +">成功-------");
client.close();
}
}catch (Exception e) {
e.printStackTrace();
}finally {
if(dis !=null)
dis.close();
if(fos !=null)
fos.close();
server.close();
}
}catch (Exception e) {
e.printStackTrace();
}
}
publicstaticvoidmain(String[] args)throws Exception {
new Server();
}
}</code></pre>