轉載地址:http://my.oschina.net/xianggao/blog/654677
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地址創建服務器
構造方法的參數中,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);
}
}
}
服務器端程序:
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();
}
}
}
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);
}
}
}
服務器端程序:
package sock;
import java.io.*;
import java.net.*;
public class Server extends ServerSocket {
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();
}
}
//線程類
class CreateServerThread extends Thread {
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();
}
}
6 信息羣發共享
以上雖然實現了多個客戶端和服務器連接,但是仍然是消息在一個客戶端和服務器之間相互傳播。現在我們要實現信息共享,即服務器可以向多個客戶端發送廣播消息,客戶端也可以向其他客戶端發送消息
。類似於聊天室的那種功能,實現信息能在多個客戶端之間共享。
設計思路:客戶端循環可以不停輸入向服務器發送消息,並且啓一個線程,專門用來監聽服務器端發來的消息並打印輸出。服務器端啓動時,啓動一個監聽何時需要向客戶端發送消息的線程。每次接受客戶端連接請求,都啓一個線程進行處理,並且將客戶端信息存放到公共集合中。當客戶端發送消息時,服務器端將消息順序存入隊列中,當需要輸出時,從隊列中取出廣播到各客戶端處。客戶端輸入showuser命令可以查看在線用戶列表,輸入bye向服務器端申請退出連接。
客戶端代碼:
package sock;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class SocketClient extends Socket{
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);
}
}
/**
* 用於監聽服務器端向客戶端發送消息線程類
*/
class readLineThread extends Thread{
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) {
}
}
}
服務器端代碼:
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 ="--- 在線用戶列表 ---\015\012";
for (int i =0; i < user_list.size(); i++) {
s +="[" + user_list.get(i) +"]\015\012";
}
s +="--------------------";
return s;
}
}
public static void main(String[] args)throws IOException {
new Server();//啓動服務端
}
}
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();
}
}
服務器端代碼:
package sock;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服務器
*/
public class Server extends ServerSocket{
private static final int PORT =2013;
private ServerSocket server;
private Socket client;
private DataInputStream dis;
private FileOutputStream fos;
public Server()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();
}
}
public static void main(String[] args)throws Exception {
new Server();
}
}