詳細介紹Scoket編程包含最簡單實現但客戶端、多客戶端多會話、上傳

看到一篇挺不錯的文章分享給大家：

前面是一些理論的東西，第五點之後是簡單的socket 代碼

重點六、七是多用戶同對話代碼。

其中有編碼問題漢字顯示亂碼還沒有修改，希望可以會改的留言。

一、TCP/IP協議

　　既然是網絡編程，涉及幾個系統之間的交互，那麼首先要考慮的是如何準確的定位到網絡上的一臺或幾臺主機，另一個是如何進行可靠高效的數據傳輸。這裏就要使用到TCP/IP協議。

　　TCP/IP協議（傳輸控制協議）由網絡層的IP協議和傳輸層的TCP協議組成。IP層負責網絡主機的定位，數據傳輸的路由，由IP地址可以唯一的確定Internet上的一臺主機。TCP層負責面向應用的可靠的或非可靠的數據傳輸機制，這是網絡編程的主要對象。

二、TCP與UDP

　　TCP是一種面向連接的保證可靠傳輸的協議。通過TCP協議傳輸，得到的是一個順序的無差錯的數據流。發送方和接收方的成對的兩個socket之間必須建立連接，以便在TCP協議的基礎上進行通信，當一個socket（通常都是server socket）等待建立連接時，另一個socket可以要求進行連接，一旦這兩個socket連接起來，它們就可以進行雙向數據傳輸，雙方都可以進行發送或接收操作。

　　UDP是一種面向無連接的協議，每個數據報都是一個獨立的信息，包括完整的源地址或目的地址，它在網絡上以任何可能的路徑傳往目的地，因此能否到達目的地，到達目的地的時間以及內容的正確性都是不能被保證的。

TCP與UDP區別：

TCP特點：

　　1、TCP是面向連接的協議，通過三次握手建立連接，通訊完成時要拆除連接，由於TCP是面向連接協議，所以只能用於點對點的通訊。而且建立連接也需要消耗時間和開銷。

　　2、TCP傳輸數據無大小限制，進行大數據傳輸。

　　3、TCP是一個可靠的協議，它能保證接收方能夠完整正確地接收到發送方發送的全部數據。

UDP特點：

　　1、UDP是面向無連接的通訊協議，UDP數據包括目的端口號和源端口號信息，由於通訊不需要連接，所以可以實現廣播發送。

　　2、UDP傳輸數據時有大小限制，每個被傳輸的數據報必須限定在64KB之內。

　　3、UDP是一個不可靠的協議，發送方所發送的數據報並不一定以相同的次序到達接收方。

TCP與UDP應用：

　　1、TCP在網絡通信上有極強的生命力，例如遠程連接（Telnet）和文件傳輸（FTP）都需要不定長度的數據被可靠地傳輸。但是可靠的傳輸是要付出代價的，對數據內容正確性的檢驗必然佔用計算機的處理時間和網絡的帶寬，因此TCP傳輸的效率不如UDP高。

　　2，UDP操作簡單，而且僅需要較少的監護，因此通常用於局域網高可靠性的分散系統中client/server應用程序。例如視頻會議系統，並不要求音頻視頻數據絕對的正確，只要保證連貫性就可以了，這種情況下顯然使用UDP會更合理一些。

三、Socket是什麼

　　Socket通常也稱作"套接字"，用於描述IP地址和端口，是一個通信鏈的句柄。網絡上的兩個程序通過一個雙向的通訊連接實現數據的交換，這個雙向鏈路的一端稱爲一個Socket，一個Socket由一個IP地址和一個端口號唯一確定。應用程序通常通過"套接字"向網絡發出請求或者應答網絡請求。 Socket是TCP/IP協議的一個十分流行的編程界面，但是，Socket所支持的協議種類也不光TCP/IP一種，因此兩者之間是沒有必然聯繫的。在Java環境下，Socket編程主要是指基於TCP/IP協議的網絡編程。

　　Socket通訊過程：服務端監聽某個端口是否有連接請求，客戶端向服務端發送連接請求，服務端收到連接請求向客戶端發出接收消息，這樣一個連接就建立起來了。客戶端和服務端都可以相互發送消息與對方進行通訊。

　　Socket的基本工作過程包含以下四個步驟：

　　1、創建Socket；

　　2、打開連接到Socket的輸入輸出流；

　　3、按照一定的協議對Socket進行讀寫操作；

　　4、關閉Socket。

四、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，它必須被捕獲，因爲它們返回的流對象，通常都會被另一個流對象使用。

五、基本的Client/Server程序

以下是一個基本的客戶端/服務器端程序代碼。主要實現了服務器端一直監聽某個端口，等待客戶端連接請求。客戶端根據IP地址和端口號連接服務器端，從鍵盤上輸入一行信息，發送到服務器端，然後接收服務器端返回的信息，最後結束會話。這個程序一次只能接受一個客戶連接。

ps：這個小例子寫好後，服務端一直接收不到消息，調試了好長時間，才發現誤使用了PrintWriter的print()方法，而BufferedReader的readLine()方法一直沒有遇到換行，所以一直等待讀取。我暈死~~@_@

客戶端程序：

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();
        }
    }
}

六、多客戶端連接服務器

上面的服務器端程序一次只能連接一個客戶端，這在實際應用中顯然是不可能的。通常的網絡環境是多個客戶端連接到某個主機進行通訊，所以我們要對上面的程序進行改造。

設計思路：服務器端主程序監聽某一個端口，客戶端發起連接請求，服務器端主程序接收請求，同時構造一個線程類，用於接管會話。當一個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();
    }
}

七、信息共享

以上雖然實現了多個客戶端和服務器連接，但是仍然是消息在一個客戶端和服務器之間相互傳播。現在我們要實現信息共享，即服務器可以向多個客戶端發送廣播消息，客戶端也可以向其他客戶端發送消息。類似於聊天室的那種功能，實現信息能在多個客戶端之間共享。

設計思路：客戶端循環可以不停輸入向服務器發送消息，並且啓一個線程，專門用來監聽服務器端發來的消息並打印輸出。服務器端啓動時，啓動一個監聽何時需要向客戶端發送消息的線程。每次接受客戶端連接請求，都啓一個線程進行處理，並且將客戶端信息存放到公共集合中。當客戶端發送消息時，服務器端將消息順序存入隊列中，當需要輸出時，從隊列中取出廣播到各客戶端處。客戶端輸入showuser命令可以查看在線用戶列表，輸入bye向服務器端申請退出連接。

PS：以下代碼在測試時發現了一箇中文亂碼小問題，當文件設置UTF-8編碼時，無論怎樣在代碼中設置輸入流編碼都不起作用，輸入中文仍然會亂碼。把文件設置爲GBK編碼後，不用在代碼中設置輸入流編碼都能正常顯示傳輸中文。

客戶端代碼：

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();//啓動服務端
    }
}

八、文件傳輸

客戶端向服務器端傳送文件，服務端可獲取文件名用於保存，獲取文件大小計算傳輸進度，比較簡單，直接貼代碼。

客戶端代碼：

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();
    }
}

先關連接：

http://my.oschina.net/leejun2005/blog/104955#OSC_h3_1

http://blog.csdn.net/yuebinghaoyuan/article/details/8479626

http://www.blogjava.net/yongboy/archive/2013/05/13/399203.html

q5545q

發佈了23 篇原創文章 · 獲贊 3 · 訪問量 2萬+

私信關注

詳細介紹Scoket編程包含最簡單實現但客戶端、多客戶端多會話、上傳

二、TCP與UDP

三、Socket是什麼

四、Java中的Socket

五、基本的Client/Server程序

六、多客戶端連接服務器

七、信息共享

八、文件傳輸

【簡寫Mybatis-02】註冊機的實現以及SqlSession處理

手繪二維碼

.NET藉助虛擬網卡實現一個簡單異地組網工具

AJAX編寫格式

struts2的基本配置實現

集成Spring JDBC及最佳實踐

struts標籤庫

Socket 簡單實現服務器和客戶端

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

詳細介紹Scoket編程 包含最簡單實現但客戶端、多客戶端多會話 、上傳

二、TCP與UDP

三、Socket是什麼

四、Java中的Socket

五、基本的Client/Server程序

六、多客戶端連接服務器

七、信息共享

八、文件傳輸

詳細介紹Scoket編程包含最簡單實現但客戶端、多客戶端多會話、上傳