循序漸進Socket網絡編程（多客戶端、信息共享、文件傳輸）
前言：在最近一個即將結束的項目中使用到了Socket編程，用於調用另一系統進行處理並返回數據。故把Socket的基礎知識總結梳理一遍。
1、TCP/IP協議
既然是網絡編程，涉及幾個系統之間的交互，那么首先要考慮的是如何准確的定位到網絡上的一台或幾台主機，另一個是如何進行可靠高效的數據傳輸。這里就要使用到TCP/IP協議。
TCP/IP協議（傳輸控制協議）由網絡層的IP協議和傳輸層的TCP協議組成。IP層負責網絡主機的定位，數據傳輸的路由，由IP地址可以唯一的確定Internet上的一台主機。TCP層負責面向應用的可靠的或非可靠的數據傳輸機制，這是網絡編程的主要對象。
2、TCP與UDP
TCP是一種面向連接的保證可靠傳輸的協議。通過TCP協議傳輸，得到的是一個順序的無差錯的數據流。發送方和接收方的成對的兩個socket之間必須建立連接，以便在TCP協議的基礎上進行通信，當一個socket（通常都是server socket）等待建立連接時，另一個socket可以要求進行連接，一旦這兩個socket連接起來，它們就可以進行雙向數據傳輸，雙方都可以進行發送或接收操作。
UDP是一種面向無連接的協議，每個數據報都是一個獨立的信息，包括完整的源地址或目的地址，它在網絡上以任何可能的路徑傳往目的地，因此能否到達目的地，到達目的地的時間以及內容的正確性都是不能被保證的。
TCP與UDP區別：
TCP特點：
- TCP是面向連接的協議，通過三次握手建立連接，通訊完成時要拆除連接，由於TCP是面向連接協議，所以只能用於點對點的通訊。而且建立連接也需要消耗時間和開銷。
- TCP傳輸數據無大小限制，進行大數據傳輸。
- TCP是一個可靠的協議，它能保證接收方能夠完整正確地接收到發送方發送的全部數據。
UDP特點：
- UDP是面向無連接的通訊協議，UDP數據包括目的端口號和源端口號信息，由於通訊不需要連接，所以可以實現廣播發送。
- UDP傳輸數據時有大小限制，每個被傳輸的數據報必須限定在64KB之內。
- UDP是一個不可靠的協議，發送方所發送的數據報並不一定以相同的次序到達接收方。
TCP與UDP應用：
- TCP在網絡通信上有極強的生命力，例如遠程連接（Telnet）和文件傳輸（FTP）都需要不定長度的數據被可靠地傳輸。但是可靠的傳輸是要付出代價的，對數據內容正確性的檢驗必然占用計算機的處理時間和網絡的帶寬，因此TCP傳輸的效率不如UDP高。
- UDP操作簡單，而且僅需要較少的監護，因此通常用於局域網高可靠性的分散系統中client/server應用程序。例如視頻會議系統，並不要求音頻視頻數據絕對的正確，只要保證連貫性就可以了，這種情況下顯然使用UDP會更合理一些。
3、Socket是什么
Socket通常也稱作"套接字"，用於描述IP地址和端口，是一個通信鏈的句柄。網絡上的兩個程序通過一個雙向的通訊連接實現數據的交換，這個雙向鏈路的一端稱為一個Socket，一個Socket由一個IP地址和一個端口號唯一確定。應用程序通常通過"套接字"向網絡發出請求或者應答網絡請求。 Socket是TCP/IP協議的一個十分流行的編程界面，但是，Socket所支持的協議種類也不光TCP/IP一種，因此兩者之間是沒有必然聯系的。在Java環境下，Socket編程主要是指基於TCP/IP協議的網絡編程。
Socket通訊過程：服務端監聽某個端口是否有連接請求，客戶端向服務端發送連接請求，服務端收到連接請求向客戶端發出接收消息，這樣一個連接就建立起來了。客戶端和服務端都可以相互發送消息與對方進行通訊。
Socket的基本工作過程包含以下四個步驟：
- 創建Socket；
- 打開連接到Socket的輸入輸出流；
- 按照一定的協議對Socket進行讀寫操作；
- 關閉Socket。
4、Java中的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的數以防止發生沖突。
幾個重要的Socke方法：
public InputStream getInputStream();//方法獲得網絡連接輸入，同時返回一個IutputStream對象實例
public OutputStream getOutputStream();//方法連接的另一端將得到輸入，同時返回一個OutputStream對象實例
public Socket accept();//用於產生"阻塞"，直到接受到一個連接，並且返回一個客戶端的Socket對象實例。
"阻塞"是一個術語，它使程序運行暫時"停留"在這個地方，直到一個會話產生，然后程序繼續；通常"阻塞"是由循環產生的。
注意：其中getInputStream和getOutputStream方法均會產生一個IOException，它必須被捕獲，因為它們返回的流對象，通常都會被另一個流對象使用。
4、基本的Client/Server程序
以下是一個基本的客戶端/服務器端程序代碼。主要實現了服務器端一直監聽某個端口，等待客戶端連接請求。客戶端根據IP地址和端口號連接服務器端，從鍵盤上輸入一行信息，發送到服務器端，然后接收服務器端返回的信息，最后結束會話。這個程序一次只能接受一個客戶連接。
ps：這個小例子寫好后，服務端一直接收不到消息，調試了好長時間，才發現誤使用了PrintWriter的print()方法，而BufferedReader的readLine()方法一直沒有遇到換行，所以一直等待讀取。我暈死~~@_@
客戶端程序：
package com.socket; 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 com.socket; 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 com.socket; 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 com.socket; 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向服務器端申請退出連接。
PS：以下代碼在測試時發現了一個中文亂碼小問題，當文件設置UTF-8編碼時，無論怎樣在代碼中設置輸入流編碼都不起作用，輸入中文仍然會亂碼。把文件設置為GBK編碼后，不用在代碼中設置輸入流編碼都能正常顯示傳輸中文。
客戶端代碼：
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) { } } }
服務器端代碼：
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 message_list = new LinkedList();// 存放消息隊列
/** * 創建服務端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 = (String) 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、文件傳輸
客戶端向服務器端傳送文件，服務端可獲取文件名用於保存，獲取文件大小計算傳輸進度，比較簡單，直接貼代碼。
客戶端代碼：
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(); } }
服務器端代碼：
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(); } }