Java Socket編程(理論)

時間 2019-11-09

標籤 java socket 編程理論欄目 Java 简体版

原文原文鏈接

socket chat: http://www.cn-java.com/download/data/book/socket_chat.pdfjava

1、網絡編程中的兩個問題：編程

1.找到指定主機：IP層負責網絡主機的定位；服務器

2.可靠高效的傳輸數據：TCP層提供面向應用的可靠（TCP）和非可靠（UDP）的數據傳輸機制。網絡

2、目前流行的網絡編程模式：客戶端/服務器(C/S)模式。多線程

在C/S模式中，通訊一方做爲服務器，等待客戶端提出請求並予以響應。(服務器端一般做爲守護進程，始終運行，監聽網絡端口，隨時做出響應)；通訊另外一方做爲客戶端，在須要服務時向服務器發出請求。app

3、兩類傳輸協議:TCP和UDPsocket

TCP（Tranfer Control Protocol），是一種面向鏈接的保證可靠傳輸的協議。經過TCP協議傳輸，獲得的是一個順序的無差錯的數據流。發送方和接收方的成對的兩個socket之間必須建立鏈接，以便在TCP協議的基礎上進行通訊，當一個socket（一般都是server socket）等待創建鏈接時，另外一個socket能夠要求進行鏈接，一旦這兩個socket鏈接起來，它們就能夠進行雙向數據傳輸，雙方均可以進行發送或接收操做。ide

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

比較：this

UDP：1，每一個數據報中都給出了完整的地址信息，所以無須要創建發送方和接收方的鏈接。

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

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

TCP：1，面向鏈接的協議，在socket之間進行數據傳輸以前必然要創建鏈接，因此在TCP中須要鏈接時間。

2，TCP傳輸數據大小限制，一旦鏈接創建起來，雙方的socket就能夠按統一的格式傳輸大的數據。

3，TCP是一個可靠的協議，它確保接收方徹底正確地獲取發送方所發送的所有數據。

應用：

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

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

4、基於Socket的java網絡編程

1，什麼是Socket

Socket是應用與TCP/IP協議簇通訊的中間軟件抽象層，是一組接口。Socket把複雜的TCP/IP協議隱藏在Socket接口後面，對用戶來講，一組簡單接口就是所有，讓Socket去組織數據，以符合指定協議。

網絡上的兩個程序經過一個雙向的通信鏈接實現數據的交換，這個雙向鏈路的一端稱爲一個Socket。Socket一般用來實現客戶方和服務方的鏈接。Socket是TCP/IP協議的一個十分流行的編程界面，一個Socket由一個IP地址和一個端口號惟一肯定。

可是，Socket所支持的協議種類也不光TCP/IP一種，所以二者之間是沒有必然聯繫的。在Java環境下，Socket編程主要是指基於TCP/IP協議的網絡編程。

2，Socket通信的過程

Server端Listen(監聽)某個端口是否有鏈接請求，Client端向Server端發出Connect(鏈接)請求，Server端向Client端發回Accept（接受）消息。一個鏈接就創建起來了。Server端和Client端均可以經過Send，Write等方法與對方通訊。

對於一個功能齊全的Socket，都要包含如下基本結構，其工做過程包含如下四個基本的步驟：

　　（1）建立Socket；

　　（2）打開鏈接到Socket的輸入/出流；

　　（3）按照必定的協議對Socket進行讀/寫操做；

　　（4）關閉Socket.（在實際應用中，並未使用到顯示的close，雖然不少文章都推薦如此，不過在個人程序中，可能由於程序自己比較簡單，要求不高，因此並未形成什麼影響。）

3，建立Socket

java在包java.net中提供了兩個類Socket和ServerSocket，分別用來表示雙向鏈接的客戶端和服務端。這是兩個封裝得很是好的類，使用很方便。其構造方法以下：

    Socket(InetAddress address, int port);
　　Socket(InetAddress address, int port, boolean stream);
　　Socket(String host, int prot);
　　Socket(String host, int prot, boolean stream);
　　Socket(SocketImpl impl)
　　Socket(String host, int port, InetAddress localAddr, int localPort)
　　Socket(InetAddress address, int port, InetAddress localAddr, int localPort)
　　
　　ServerSocket(int port);
　　ServerSocket(int port, int backlog);
　　ServerSocket(int port, int backlog, InetAddress bindAddr)
　　
   參數說明：
　 address、host和port分別是雙向鏈接中另外一方的IP地址、主機名和端口號，
   stream指明socket是流socket仍是數據報socket，
   localPort表示本地主機的端口號，localAddr和 bindAddr是本地機器的地址（ServerSocket的主機地址），
   impl是socket的父類，既能夠用來建立serverSocket又可 以用來建立Socket。
   count則表示服務端所能支持的最大鏈接數。

例如：學習視頻網 http://www.xxspw.com

　　Socket client = new Socket("127.0.01.", 80);
　　ServerSocket server = new ServerSocket(80);

　　注意，在選擇端口時，必須當心。每個端口提供一種特定的服務，只有給出正確的端口，才能得到相應的服。0~1023的端口號爲系統所保留，例如http服務的端口號爲80, telnet服務的端口號爲21, ftp服務的端口號爲23, 因此咱們在選擇端口號時，最好選擇一個大於1023的數以防止發生衝突。

在建立socket時若是發生錯誤，將產生IOException，在程序中必須對之做出處理。因此在建立Socket或ServerSocket是必須捕獲或拋出例外。

5、Socket基本C/S程序

　　import java.io.*;
　　import java.net.*;
　　public class TalkClient {
　　　　public static void main(String args[]) 
　　　　{
　　　　　　try{
　　　　　　　　Socket socket=new Socket("127.0.0.1",4700);
　　　　　　　　//向本機的4700端口發出客戶請求
　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
　　　　　　　　//由系統標準輸入設備構造BufferedReader對象
　　　　　　　　PrintWriter os=new PrintWriter(socket.getOutputStream());
　　　　　　　　//由Socket對象獲得輸出流，並構造PrintWriter對象
　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
　　　　　　　　//由Socket對象獲得輸入流，並構造相應的BufferedReader對象
　　　　　　　　String readline;
　　　　　　　　readline=sin.readLine(); //從系統標準輸入讀入一字符串
　　　　　　　　while(!readline.equals("bye"))
　　　　　　　　{
　　　　　　　　   //若從標準輸入讀入的字符串爲 "bye"則中止循環
　　　　　　　　　　os.println(readline);
　　　　　　　　　　//將從系統標準輸入讀入的字符串輸出到Server
　　　　　　　　　　os.flush();
　　　　　　　　　　//刷新輸出流，使Server立刻收到該字符串
　　　　　　　　　　System.out.println("Client:"+readline);
　　　　　　　　　　//在系統標準輸出上打印讀入的字符串
　　　　　　　　　　System.out.println("Server:"+is.readLine());
　　　　　　　　　　//從Server讀入一字符串，並打印到標準輸出上
　　　　　　　　　　readline=sin.readLine(); //從系統標準輸入讀入一字符串
　　　　　　　　} //繼續循環
　　　　　　　　os.close(); //關閉Socket輸出流
　　　　　　　　is.close(); //關閉Socket輸入流
　　　　　　　　socket.close(); //關閉Socket
　　　　　　}catch(Exception e) 
　　　　　　{
　　　　　　　　System.out.println("Error"+e); //出錯，則打印出錯信息
　　　　　　}
　　}
}
　　import java.io.*;
　　import java.net.*;
　　import java.applet.Applet;
　　public class TalkServer{
　　　　public static void main(String args[]) 
　　　　{
　　　　　　try{
　　　　　　　　ServerSocket server=null;
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　server=new ServerSocket(4700);
　　　　　　　　    //建立一個ServerSocket在端口4700監聽客戶請求
　　　　　　　　}catch(Exception e) 
　　　　　　　　{
　　　　　　　　　　System.out.println("can not listen to:"+e);
　　　　　　　　    //出錯，打印出錯信息
　　　　　　　　}
　　　　　　　　Socket socket=null;
　　　　　　　　try{
　　　　　　　　　　socket=server.accept();
　　　　　　　　　　//使用accept()阻塞等待客戶請求，有客戶
　　　　　　　　　　//請求到來則產生一個Socket對象，並繼續執行
　　　　　　　　}catch(Exception e) {
　　　　　　　　　　System.out.println("Error."+e);
　　　　　　　　　　//出錯，打印出錯信息
　　　　　　　　}
　　　　　　　　String line;
　　　　　　　　BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
　　　　　　　　　//由Socket對象獲得輸入流，並構造相應的BufferedReader對象
　　　　　　　　PrintWriter os=newPrintWriter(socket.getOutputStream());
　　　　　　　　　//由Socket對象獲得輸出流，並構造PrintWriter對象
　　　　　　　　BufferedReader sin=new BufferedReader(new InputStreamReader(System.in));
　　　　　　　　　//由系統標準輸入設備構造BufferedReader對象
　　　　　　　　System.out.println("Client:"+is.readLine());
　　　　　　　　//在標準輸出上打印從客戶端讀入的字符串
　　　　　　　　line=sin.readLine();
　　　　　　　　//從標準輸入讀入一字符串
　　　　　　　　while(!line.equals("bye"))
　　　　　　　　{
　　　　　　　　   //若是該字符串爲 "bye"，則中止循環
　　　　　　　　　　os.println(line);
　　　　　　　　　　//向客戶端輸出該字符串
　　　　　　　　　　os.flush();
　　　　　　　　　　//刷新輸出流，使Client立刻收到該字符串
　　　　　　　　　　System.out.println("Server:"+line);
　　　　　　　　　　//在系統標準輸出上打印讀入的字符串
　　　　　　　　　　System.out.println("Client:"+is.readLine());
　　　　　　　　　　//從Client讀入一字符串，並打印到標準輸出上
　　　　　　　　　　line=sin.readLine();
　　　　　　　　　　//從系統標準輸入讀入一字符串
　　　　　　　　} 　//繼續循環
　　　　　　　　os.close(); //關閉Socket輸出流
　　　　　　　　is.close(); //關閉Socket輸入流
　　　　　　　　socket.close(); //關閉Socket
　　　　　　　　server.close(); //關閉ServerSocket
　　　　　　}catch(Exception e){
　　　　　　　　System.out.println("Error:"+e);
　　　　　　　　//出錯，打印出錯信息
　　　　　　}
　　　　}
　　}

6，支持多客戶的C/S程序

前面的Client/Server程序只能實現Server和一個客戶的對話。在實際應用中，每每是在服務器上運行一個永久的程序，它能夠接收來自其餘多個客戶端的請求，提供相應的服務。爲了實如今服務器方給多個客戶提供服務的功能，須要對上面的程序進行改造，利用多線程實現多客戶機制。服務器老是在指定的端口上監聽是否有客戶請求，一旦監聽到客戶請求，服務器就會啓動一個專門的服務線程來響應該客戶的請求，而服務器自己在啓動完線程以後立刻又進入監聽狀態，等待下一個客戶的到來。

代碼示例1：（服務端能夠接受多個客戶端發送的消息）

  
import java.io.*;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TalkServer
{
    public static void main(String args[])
    {
       new TalkServer();
    }
    private List<Socket> connectedSockets = new ArrayList();
    public TalkServer()
    {
        int port = 4700;
        try
        {
            ServerSocket serverSocket = new ServerSocket(port);            
            System.out.println("服務已啓動，端口號" + port);
            ExecutorService executorService = Executors.newCachedThreadPool();
            Socket socket;
            while (true)
            {
                socket = serverSocket.accept();
                String connectedMsg = "端口號" + socket.getPort() + " 已鏈接";
                System.out.println(connectedMsg);
                dispatchMessage(connectedMsg);
                connectedSockets.add(socket);
                executorService.execute(new ServerThread(socket));
            }                             
        } catch (IOException e)
        {
            System.out.println("Error:" + e); 
        }
    }
    public void dispatchMessage(String msg)
    {
        DataOutputStream dos;
        for (Socket soc : connectedSockets)
        {
            try
            {
                dos = new DataOutputStream(soc.getOutputStream());
                dos.writeUTF(msg);
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }   
    }   
    class ServerThread extends Thread
    {
        private Socket socket;
        private DataInputStream in;
        public ServerThread(Socket socket)
        {
            this.socket = socket;
            try
            {
                in = new DataInputStream(socket.getInputStream());
            } catch (IOException e)
            {
                System.err.println(e.getMessage());
            }
        }
        @Override
        public void run()
        {
            this.socket = socket;
            try
            {
                String str;
                while ((str = in.readUTF()) != null)
                {
                    str = socket.getPort() + "說：" + str;
                    System.out.println(str);
                    dispatchMessage(str);
                }
            } catch (IOException e)
            {
                System.err.println("Port " + socket.getPort() + " 已斷開鏈接");
                connectedSockets.remove(socket);
                closeSocket();
            }
        }
        private void closeSocket()
        {
            if (in != null)
            {
                try
                {
                    in.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            if (socket != null)
            {
                try
                {
                    socket.close();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }
}

import java.io.*;
import java.net.*;
public class TalkClient
{
    public static void main(String args[])
    {
        new TalkClient();
    }
    public TalkClient()
    {
        try
        {
            //向本機的4700端口發出客戶請求  
            Socket socket = new Socket("127.0.0.1", 4700);
            //由系統標準輸入設備構造BufferedReader對象  
            BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));
            //由Socket對象獲得輸出流，並構造PrintWriter對象  
            DataOutputStream os = new DataOutputStream(socket.getOutputStream());
            String message;
            while ((message = sin.readLine()) != null)
            {
                System.out.println("I wrote: " + message);
                os.writeUTF(message);
            }
            //由Socket對象獲得輸入流，並構造相應的BufferedReader對象
            //DataInputStream is = new DataInputStream(socket.getInputStream());
            //String inMsg;
            //while ((inMsg = is.readUTF()) != null)
            //{
            //    System.out.println(inMsg);
            //}
        } catch (IOException e)
        {
            System.out.println("Error" + e); //出錯，則打印出錯信息
        }
    }
}

代碼示例2：（多個客戶端和服務器能夠互相發送消息）

代碼參考： http://my.oschina.net/liuyuanyuangogo/blog/496262

7.客戶端與服務器端之間的文件傳輸

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

代碼參考： http://my.oschina.net/liuyuanyuangogo/blog/496269

8.通常的即時通信都是經過Socket實現的，鏈接穩定時一般使用UDP傳輸。