Java 網路程式設計

網路程式設計是指編寫執行在多個裝置（計算機）的程式，這些裝置都通過網路連線起來。

java.net 包中 J2SE 的 API 包含有類和介面，它們提供低層次的通訊細節。你可以直接使用這些類和介面，來專注於解決問題，而不用關注通訊細節。

java.net 包中提供了兩種常見的網路協議的支援：

TCP：TCP 是傳輸控制協議的縮寫，它保障了兩個應用程式之間的可靠通訊。通常用於網際網路協議，被稱 TCP / IP。

UDP：UDP 是使用者資料報協議的縮寫，一個無連線的協議。提供了應用程式之間要傳送的資料的資料包。

Socket 程式設計：這是使用最廣泛的網路概念，它已被解釋地非常詳細。

URL 處理：這部分會在另外的篇幅裡講，點選這裡更詳細地瞭解在 Java 語言中的 URL 處理。

Socket 程式設計

套接字使用TCP提供了兩臺計算機之間的通訊機制。 客戶端程式建立一個套接字，並嘗試連線伺服器的套接字。

當連線建立時，伺服器會建立一個 Socket 物件。客戶端和伺服器現在可以通過對 Socket 物件的寫入和讀取來進行通訊。

java.net.Socket 類代表一個套接字，並且 java.net.ServerSocket 類為伺服器程式提供了一種來監聽客戶端，並與他們建立連線的機制。

以下步驟在兩臺計算機之間使用套接字建立TCP連線時會出現：

伺服器例項化一個 ServerSocket 物件，表示通過伺服器上的埠通訊。

伺服器呼叫 ServerSocket 類的 accept() 方法，該方法將一直等待，直到客戶端連線到伺服器上給定的埠。

伺服器正在等待時，一個客戶端例項化一個 Socket 物件，指定伺服器名稱和埠號來請求連線。

Socket 類的建構函式試圖將客戶端連線到指定的伺服器和埠號。如果通訊被建立，則在客戶端建立一個 Socket
物件能夠與伺服器進行通訊。

在伺服器端，accept() 方法返回伺服器上一個新的 socket 引用，該 socket 連線到客戶端的 socket。

連線建立後，通過使用 I/O 流在進行通訊，每一個socket都有一個輸出流和一個輸入流，客戶端的輸出流連線到伺服器端的輸入流，而客戶端的輸入流連線到伺服器端的輸出流。

TCP 是一個雙向的通訊協議，因此資料可以通過兩個資料流在同一時間傳送.以下是一些類提供的一套完整的有用的方法來實現 socket。

ServerSocket 類的方法

伺服器應用程式通過使用 java.net.ServerSocket 類以獲取一個埠,並且偵聽客戶端請求。

ServerSocket 類有四個構造方法：

序號	方法	方法描述
1	public ServerSocket (int port) throws IOException	建立繫結到特定埠的伺服器套接字。
2	public ServerSocket (int port, int backlog) throws IOException	利用指定的 backlog 建立伺服器套接字並將其繫結到指定的本地埠號。
3	public ServerSocket (int port, int backlog, InetAddress address) throws IOException	使用指定的埠、偵聽 backlog 和要繫結到的本地 IP 地址建立伺服器。
4	public ServerSocket () throws IOException	建立非繫結伺服器套接字。

建立非繫結伺服器套接字。 如果 ServerSocket 構造方法沒有丟擲異常，就意味著你的應用程式已經成功繫結到指定的埠，並且偵聽客戶端請求。

這裡有一些 ServerSocket 類的常用方法：

序號	方法	方法描述
1	public int getLocalPort ()	返回此套接字在其上偵聽的埠。
2	public Socket accept () throws IOException	偵聽並接受到此套接字的連線。
3	public void setSoTimeout (int timeout)	通過指定超時值啟用/禁用 SO_TIMEOUT，以毫秒為單位。
4	public void bind (SocketAddress host, int backlog)	將 ServerSocket 繫結到特定地址（IP 地址和埠號）。

Socket 類的方法

java.net.Socket 類代表客戶端和伺服器都用來互相溝通的套接字。

客戶端要獲取一個 Socket 物件通過例項化 ，而 伺服器獲得一個 Socket 物件則通過 accept() 方法的返回值。

Socket 類有五個構造方法.

序號	方法	方法描述
1	public Socket (String host, int port) throws UnknownHostException, IOException.	建立一個流套接字並將其連線到指定主機上的指定埠號。
2	public Socket (InetAddress host, int port) throws IOException	建立一個流套接字並將其連線到指定 IP 地址的指定埠號。
3	public Socket (String host, int port, InetAddress localAddress, int localPort) throws IOException.	建立一個套接字並將其連線到指定遠端主機上的指定遠端埠。
4	public Socket (InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.	建立一個套接字並將其連線到指定遠端地址上的指定遠端埠。
5	public Socket ()	通過系統預設型別的 SocketImpl 建立未連線套接字

當 Socket 構造方法返回，並沒有簡單的例項化了一個 Socket 物件，它實際上會嘗試連線到指定的伺服器和埠。

下面列出了一些感興趣的方法，注意客戶端和伺服器端都有一個 Socket 物件，所以無論客戶端還是服務端都能夠呼叫這些方法。

序號	方法	方法描述
1	public void connect (SocketAddress host, int timeout) throws IOException	將此套接字連線到伺服器，並指定一個超時值。
2	public InetAddress getInetAddress ()	返回套接字連線的地址。
3	public int getPort ()	返回此套接字連線到的遠端埠。
4	public int getLocalPort ()	返回此套接字繫結到的本地埠。
5	public SocketAddress getRemoteSocketAddress ()	返回此套接字連線的端點的地址，如果未連線則返回 null。
6	public InputStream getInputStream () throws IOException	返回此套接字的輸入流。
7	public OutputStream getOutputStream () throws IOException	返回此套接字的輸出流。
8	public void close () throws IOException	關閉此套接字。

InetAddress 類的方法

這個類表示網際網路協議(IP)地址。下面列出了 Socket 程式設計時比較有用的方法：

序號	方法	方法描述
1	static InetAddress getByAddress (byte[] addr)	在給定原始 IP 地址的情況下，返回 InetAddress 物件。
2	static InetAddress getByAddress (String host, byte[] addr)	根據提供的主機名和 IP 地址建立 InetAddress。
3	static InetAddress getByName (String host)	在給定主機名的情況下確定主機的 IP 地址。
4	String getHostAddress ()	返回 IP 地址字串（以文字表現形式）。
5	String getHostName ()	獲取此 IP 地址的主機名。
6	static InetAddress getLocalHost ()	返回本地主機。
7	String toString ()	將此 IP 地址轉換為 String。

TCP Socket

Java 為 TCP 協議提供了兩個類:Socket 類和 ServerSocket 類。
一個 Socket 例項代表了TCP連線的一端。
一個 TCP 連線(TCP connection)是一條抽象的雙向通道,兩端分別由IP地址和埠號確定。在開始通訊之前,要建立一個 TCP 連線,這需要先由客戶端 TCP 向伺服器端 TCP傳送連線請求。
ServerSocket 例項則監聽 TCP 連線請求,併為每個請求建立新的 Socket 例項。
也就是說,伺服器端要同時處理ServerSocket 例項和 Socket 例項,而客戶端只需要使用 Socket例項。
每個Socket例項會關聯一個InputStream和OutputStream物件，我們通過將位元組寫入套接字的OutputStream來發送資料，並通過從InputStream來接收資料。

TCP連線的建立步驟

客戶端向伺服器端傳送連線請求後，就被動地等待伺服器的響應。典型的TCP客戶端要經過下面三步操作：

1、建立一個Socket例項：建構函式向指定的遠端主機和埠建立一個TCP連線；
2、通過套接字的I/O流與服務端通訊；
3、使用Socket類的close方法關閉連線。

服務端的工作是建立一個通訊終端，並被動地等待客戶端的連線。典型的TCP服務端執行如下兩步操作：

1、建立一個ServerSocket例項並指定本地埠，用來監聽客戶端在該埠傳送的TCP連線請求；
2、重複執行：

1）呼叫ServerSocket的accept（）方法以獲取客戶端連線，並通過其返回值建立一個Socket例項；
2）為返回的Socket例項開啟新的執行緒，並使用返回的Socket例項的I/O流與客戶端通訊；
3）通訊完成後，使用Socket類的close（）方法關閉該客戶端的套接字連線

TCP Demo

Demo1.基本的流傳送示例：

服務端開啟一個TCP伺服器，引數為埠號
客戶端啟動一個TCP服務，引數為服務端的地址，傳送的字元，埠號

客戶端

import java.net.Socket;
import java.net.SocketException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TCPClient {

    public static void main(String[] args) throws IOException {

        if ((args.length < 2) || (args.length > 3))

            throw new IllegalArgumentException(
                    "Parameter(s):<Server> <Word> [<Port>]");

        String server = args[0]; // Server name or IP address
        /* Convert argument String to bytes using the default character encoding */
        byte[] senddata = args[1].getBytes();
        int servPort = (args.length == 3) ? Integer.parseInt(args[2]) : 7;
        /* Create socket that is connected to server onspecified port*/
        Socket socket = new Socket(server, servPort);
        System.out.println("Connected to server...sending echo string");

        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
        out.write(senddata); // Send the encoded string to the server

        int totalBytesRcvd = 0; // Total bytes received so far
        byte[] recvdata = new byte[in.available()];
        int bytesRcvd; // Bytes received in last read
        while (totalBytesRcvd < recvdata.length) {
            if ((bytesRcvd = in.read(recvdata, totalBytesRcvd, recvdata.length
                    - totalBytesRcvd)) == -1)
                throw new SocketException("Connection closed prematurely");
            totalBytesRcvd += bytesRcvd;
        } // data array is full

        System.out.println("Received: " + new String(recvdata));

        socket.close(); // Close the socket and its streams
    }
}

服務端

import java.net.*; // for Socket, ServerSocket, andInetAddress
import java.io.*; // for IOException and Input/OutputStream

public class TCPServer {

    private static final int BUFSIZE = 32; // Size of receivebuffer

    public static void main(String[] args) throws IOException {

        if (args.length != 1) // Test for correct # of args
            throw new IllegalArgumentException("Parameter(s): <Port>");

        int servPort = Integer.parseInt(args[0]);

        /* Create a server socket to accept client connection requests */
        ServerSocket servSock = new ServerSocket(servPort);

        int recvMsgSize; // Size of received message
        byte[] receiveBuf = new byte[BUFSIZE]; // Receive buffer

        while (true) { // Run forever, accepting and servicing connections

            Socket clntSock = servSock.accept(); // Get client connection

            SocketAddress clientAddress = clntSock.getRemoteSocketAddress();

            System.out.println("Handling client at " + clientAddress);

            InputStream in = clntSock.getInputStream();
            OutputStream out = clntSock.getOutputStream();

            /* Receive until client closes connection, indicated by -1 return*/

            while ((recvMsgSize = in.read(receiveBuf)) != -1) {

                out.write(receiveBuf, 0, recvMsgSize);
            }
            clntSock.close(); // Close the socket. We are done with this client!
        }
        /* NOT REACHED */

    }
}

Demo2.

客戶端從控制檯輸入字串，傳送到服務端
服務端受到客戶端的字串後，加上部分資訊（echo字串）返回到客戶端

客戶端

package zyb.org.client;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.SocketTimeoutException;

public class Client {
    public static void main(String[] args) throws IOException {
        //客戶端請求與本機在20006埠建立TCP連線 
        Socket client = new Socket("127.0.0.1", 20006);
        client.setSoTimeout(10000);
        //獲取鍵盤輸入 
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        //獲取Socket的輸出流，用來發送資料到服務端  
        PrintStream out = new PrintStream(client.getOutputStream());
        //獲取Socket的輸入流，用來接收從服務端傳送過來的資料  
        BufferedReader buf =  new BufferedReader(new InputStreamReader(client.getInputStream()));
        boolean flag = true;
        while(flag){
            System.out.print("輸入資訊：");
            String str = input.readLine();
            //傳送資料到服務端  
            out.println(str);
            if("bye".equals(str)){
                flag = false;
            }else{
                try{
                    //從伺服器端接收資料有個時間限制（系統自設，也可以自己設定），超過了這個時間，便會丟擲該異常
                    String echo = buf.readLine();
                    System.out.println(echo);
                }catch(SocketTimeoutException e){
                    System.out.println("Time out, No response");
                }
            }
        }
        input.close();
        if(client != null){
            //如果建構函式建立起了連線，則關閉套接字，如果沒有建立起連線，自然不用關閉
            client.close();    //只關閉socket，其關聯的輸入輸出流也會被關閉
        }
    }
}

服務端

package zyb.org.server;

import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws Exception{
        //服務端在20006埠監聽客戶端請求的TCP連線
        ServerSocket server = new ServerSocket(20006);
        Socket client = null;
        boolean f = true;
        while(f){
            //等待客戶端的連線，如果沒有獲取連線
            client = server.accept();
            System.out.println("與客戶端連線成功！");
            //為每個客戶端連線開啟一個執行緒
            new Thread(new ServerThread(client)).start();
        }
        server.close();
    }
}

服務端 執行緒類

package zyb.org.server;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

/**
 * 該類為多執行緒類，用於服務端
 */
public class ServerThread implements Runnable {

    private Socket client = null;
    public ServerThread(Socket client){
        this.client = client;
    }
    
    @Override
    public void run() {
        try{
            //獲取Socket的輸出流，用來向客戶端傳送資料
            PrintStream out = new PrintStream(client.getOutputStream());
            //獲取Socket的輸入流，用來接收從客戶端傳送過來的資料
            BufferedReader buf = new BufferedReader(new InputStreamReader(client.getInputStream()));
            boolean flag =true;
            while(flag){
                //接收從客戶端傳送過來的資料
                String str =  buf.readLine();
                if(str == null || "".equals(str)){
                    flag = false;
                }else{
                    if("bye".equals(str)){
                        flag = false;
                    }else{
                        //將接收到的字串前面加上echo，傳送到對應的客戶端
                        out.println("echo:" + str);
                    }
                }
            }
            out.close();
            client.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

UDP Socket

UDP協議提供的服務不同於TCP協議的端到端服務，它是面向非連線的，屬不可靠協議，UDP套接字在使用前不需要進行連線。實際上，UDP協議實現了兩個功能：

1）在IP協議的基礎上添加了埠；
2）對傳輸過程中可能產生的資料錯誤進行了檢測，並拋棄已經損壞的資料。 UDP的Java支援

Java通過DatagramPacket類和DatagramSocket類來使用UDP套接字，客戶端和伺服器端都通過DatagramSocket的send（）方法和receive（）方法來發送和接收資料，用DatagramPacket來包裝需要傳送或者接收到的資料。傳送資訊時，Java建立一個包含待發送資訊的DatagramPacket例項，並將其作為引數傳遞給DatagramSocket例項的send（）方法；
接收資訊時，Java程式首先建立一個DatagramPacket例項，該例項預先分配了一些空間，並將接收到的資訊存放在該空間中，然後把該例項作為引數傳遞給DatagramSocket例項的receive（）方法。
在建立DatagramPacket例項時，要注意：如果該例項用來包裝待接收的資料，則不指定資料來源的遠端主機和埠，只需指定一個快取資料的byte陣列即可（在呼叫receive（）方法接收到資料後，源地址和埠等資訊會自動包含在DatagramPacket例項中），而如果該例項用來包裝待發送的資料，則要指定要傳送到的目的主機和埠。

UDP的通訊建立的步驟

UDP客戶端首先向被動等待聯絡的伺服器傳送一個數據報文。一個典型的UDP客戶端要經過下面三步操作：

1、建立一個DatagramSocket例項，可以有選擇地對本地地址和埠號進行設定，如果設定了埠號，則客戶端會在該埠號上監聽從伺服器端傳送來的資料；
2、使用DatagramSocket例項的send（）和receive（）方法來發送和接收DatagramPacket例項，進行通訊；
3、通訊完成後，呼叫DatagramSocket例項的close（）方法來關閉該套接字。

由於UDP是無連線的，因此UDP服務端不需要等待客戶端的請求以建立連線。另外，UDP伺服器為所有通訊使用同一套接字，這點與TCP伺服器不同，TCP伺服器則為每個成功返回的accept()方法建立一個新的套接字。一個典型的UDP服務端要經過下面三步操作：

1、建立一個DatagramSocket例項，指定本地埠號，並可以有選擇地指定本地地址，此時，伺服器已經準備好從任何客戶端接收資料報文；
2、使用DatagramSocket例項的receive（）方法接收一個DatagramPacket例項，當receive（）方法返回時，資料報文就包含了客戶端的地址，這樣就知道了回覆資訊應該傳送到什麼地方；
3、使用DatagramSocket例項的send（）方法向伺服器端返回DatagramPacket例項。

這裡有一點需要注意：

UDP程式在receive()方法處阻塞，直到收到一個數據報文或等待超時。由於UDP協議是不可靠協議，如果沒有收到DatagramPacket，那麼程式將會一直阻塞在receive()方法處，這樣客戶端將永遠都接收不到伺服器端傳送回來的資料，但是又沒有任何提示。為了避免這個問題，我們在客戶端使用DatagramSocket類的setSoTimeout()方法來制定receive()方法的最長阻塞時間，並指定重發資料報的次數，如果每次阻塞都超時，並且重發次數達到了設定的上限，則關閉客戶端。

TCP Demo

一個客戶端服務端UDP通訊的Demo（沒有用多執行緒），該客戶端在本地2222埠監聽接收到的資料，並將字串"Hello UDPserver"傳送到本地伺服器的3222埠，服務端在本地3222埠監聽接收到的資料，如果接收到資料，則返回字串"Hello UDPclient"到該客戶端的2222埠。在客戶端，由於程式可能會一直阻塞在receive（）方法處，因此這裡我們在客戶端用DatagramSocket例項的setSoTimeout（）方法來指定receive（）的最長阻塞時間TIMEOUT ，並設定重發資料的次數MAXNUM ，如果最終依然沒有接收到從服務端傳送回來的資料，我們就關閉客戶端。

客戶端

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpClient {
    private static final int MAXNUM = 5; // 設定重發資料的最多次數
    private static final int TIMEOUT = 5000;  //設定接收資料的超時時間
    private static final int CLIENT_PORT = 2222;
    private static final int SERVER_PORT = 3222;
    private static final int REV_SIZE = 1024; //接收資料的儲存空間大小
    
    public static void main(String[] args) throws IOException {
        String str_send = "Hello UDPserver"; //要傳送的字串
        byte[] buf_rev = new byte[REV_SIZE];     //要接收的儲存空間
        
        /*第一步 例項化DatagramSocket*/
        DatagramSocket mSoc = new DatagramSocket(CLIENT_PORT);
        mSoc.setSoTimeout(TIMEOUT);              //設定接收資料時阻塞的最長時間  
        
        /*第二步 例項化用於傳送的DatagramPacket和用於接收的DatagramPacket*/
        InetAddress inetAddress = InetAddress.getLocalHost();
        DatagramPacket data_send = new DatagramPacket(str_send.getBytes(),
                str_send.length(), inetAddress, SERVER_PORT);
        
        DatagramPacket data_rev = new DatagramPacket(buf_rev, REV_SIZE);

        
        /*第三步 DatagramPacket send傳送資料，receive接收資料*/
        int send_count = 0; // 重發資料的次數
        boolean revResponse = false; // 是否接收到資料的標誌位
        while (!revResponse && send_count < MAXNUM) {
            try {
                mSoc.send(data_send); //傳送資料
                mSoc.receive(data_rev);//接收資料
                if (!data_rev.getAddress().getHostAddress()
                        .equals(InetAddress.getLocalHost().getHostAddress())) {
                    throw new IOException(
                            "Received packet from an umknown source");
                }
                revResponse = true;
            } catch (InterruptedIOException e) {
                // 如果接收資料時阻塞超時，重發並減少一次重發的次數
                send_count += 1;
                System.out.println("Time out," + (MAXNUM - send_count)
                        + " more tries...");
            }
        }
        if (revResponse) {
            // 如果收到資料，則打印出來
            System.out.println("client received data from server：");
            String str_receive = new String(data_rev
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Java Socket網路程式設計
     
  
 
  
 Java Socket網路程式設計 
 計算機網路中，客戶機與伺服器之間進行通訊時，客戶機必須知道伺服器的IP地址和埠號。IP地址是標識Internet網路中的某臺計算機，而埠號則標識著在伺服器上執行的某個程式（程序），如果在伺服器上執行的程式，沒有埠號，則客戶端的程式就不能找到它，也不能和它 

  
 

    

    
    
java socket網路程式設計例項程式碼（含服務端和客戶端）
     
 
                本程式碼為java socket網路程式設計例項程式碼，包括客戶端和服務端，實現客戶端傳送訊息，服務端接收並反饋訊息。 server.java為服務端程式碼。 client.java為客戶端程式碼。

服務端程式碼server.java：


package socket;
 

  
 

    

    
    
Java-socket網路程式設計
     
  
  
  
 Java 網路程式設計 
 網路程式設計是指編寫執行在多個裝置（計算機）的程式，這些裝置都通過網路連線起來。 
 java.net 包中 J2SE 的 API 包含有類和介面，它們提供低層次的通訊細節。你可以直接使用這些類和介面，來專注於解決問題，而不用關注通訊細節。 
 java.net  

  
 

    

    
    
Java Socket網路程式設計：實現簡單的區域網共享檔案（PeertoPeer）
     
  
  
  
 介紹 
 程式碼很簡單，只需要兩個java檔案：Server.java和Client.java。 程式碼不是我寫的，出自：這裡（感興趣的可以自行下載，這裡就不貼出來了） 
 執行結果 
 簡要說一下怎麼執行，這裡演示在同一個電腦上執行（也可以在多個電腦上執行，但客戶端的ip要改為伺服器端所在 

  
 

    

    
    
Java Socket網路程式設計常見異常(轉)
     
 1.java.net.SocketTimeoutException
這個異常比較常見，socket超時。一般有2個地方會丟擲這個，一個是connect的時候，這個超時引數由connect(SocketAddress endpoint, int timeout)中的後者來決定，還有就是setSoTimeout 

  
 

    

    
    
JAVA SOCKET網路程式設計，服務端接收多個客戶端連線的實現
     
 
                
這是基於前面一篇文章的一個簡單擴充套件，當然這不是最好的實現

服務端如果要想接收多個客戶端連線，必須死迴圈去接收新的客戶端的連線請求，一個完整的客戶端服務端socket連線通過一個執行緒來維護

package com.tree.demo.socket;

import  

  
 

    

    
    
Java Socket網路程式設計的經典例子(轉)
     
 
                   事實上網路程式設計簡單的理解就是兩臺計算機相互通訊資料而已，對於程式設計師而言，去掌握一種程式設計介面並使用一種程式設計模型相對就會顯得簡單的多了，Java SDK提供一些相對簡單的Api來完成這些工作。Socket就是其中之一，對於Java而言，這些Api存在與jav 

  
 

    

    
    
java：socket 網路程式設計
     
  
 
 socket的通俗解釋： 
 套接字=主機+埠號。兩個東西配在一起，叫做“配套”。 
 另外“套”也有對應的意思，它可以把網路上的兩個應用對應起來，所以用“套”。 它是用來與另一個應用連線的，所以用“接”。 又因為它是一小段資料，很小一小段，所以叫“字”。 “套接字",就是一小段用來將網路個兩個應用 

  
 

    

    
    
java：網路程式設計（InetAddress，InetSocketAddress，URL，TCP（Socket與SeverSocket），TCP與UDP的區別）
     
 
   
 InerAddress: 
 /**IP地址:在網路上唯一標示一臺計算機 * 埠號:標示計算機上不同的應用程式 * java.net.InetAddress類:此類表示網際網路協議 (IP) 地址。  * 常用方法: * getByName(String host) 在給定主機名的情況下 

  
 

    

    
    
【翻譯】java-TCP-socket網路程式設計2
     
 
								
								            
							
							
							
我搬家到部落格園了。。。。

URL url = new URL("http://jenkov.com");//新建一個URL

URLConnection urlConnection = url.o 

  
 

    

    
    
Java 基於UDP的Socket網路程式設計的入門及示例
     
 
							
							
							
  前言：天吶！這兩天上班就像走鋼絲啊，老大家裡出事請假一週，手機關機，底層無人照看，機器又忙著定標，技術盲老闆事事問我這個底層小白。做人好難吶。。。還是祝願老大家裡沒有大礙吧，也保佑自己明天能安然度過。。保佑保佑。 
  原文出處：http://blog.c 

  
 

    

    
    
Java系列-Socket網路程式設計，TCP/IP和Http等網路協議理解
     
 
                

一、網路各個協議：TCP/IP、SOCKET、HTTP等
網路七層由下往上分別為物理層、資料鏈路層、網路層、傳輸層、會話層、表示層和應用層。
其中物理層、資料鏈路層和網路層通常被稱作媒體層，是網路工程師所研究的物件；
傳輸層、會話層、表示層和應用層則被稱作主機層，是使用者 

  
 

    

    
    
[Socket網路程式設計]一個封鎖操作被對 WSACancelBlockingCall 的呼叫中斷。
     
  
 原文地址：http://www.cnblogs.com/xiwang/archive/2012/10/25/2740114.html記錄在此，方便查閱。 
 C#中在使用UDPClient迴圈監聽埠，在斷開UPDClient的時候，使用try...catch捕獲了異常，System.NET.Socket 

  
 

    

    
    
Python_day6:socket網路程式設計
     
 一、socket 
　　socket即套接字，用於描述IP地址和埠，是一個通訊鏈的控制代碼，應用程式通常通過"套接字"向網路發出請求或者應答網路請求。 
　　最簡單的socket，一次 

 
  
  
   1 import socket
 2 server = socket.socket() #獲得例項 

  
 

    

    
    
python------Socket網路程式設計（二）粘包問題
     
 一.socket網路程式設計 
 粘包：服務端兩次傳送指令在一起，它會把兩次傳送內容合在一起傳送，稱為粘包，從而出現錯誤。 
 
解決方法：（比較low的方法） 
 
有些需要實時更新的，用sleep有延遲，不能這樣解決問題。 
解決方法之高階方法： 
 
客戶端： 
 
二.傳送檔案 
ftp s 

  
 

    

    
    
java基礎----網路程式設計 tcp
     
  
 
 package cn.itcast.tcp; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.n 

  
 

    

    
    
Java基礎---網路程式設計 ip udp
     
  

  package cn.itcast.ip;
 
 
  import java.io.IOException;
  import java.net.InetAddress;
  import java.net.UnknownHostException;
 
 
  /*
   網路程式設計 

  
 

    

    
    
Socket網路程式設計進階與實戰資源分享
     
  
 
 Socket網路程式設計進階與實戰資源分享 
 Socket網路程式設計進階與實戰資源分享 
 獲取資源新增qq+2100776785 
 獲取資源新增qq+2100776785 
 第1章 課程介紹 本章將從軟體測試的起源與發展、測試行業的現狀及職業生涯規劃等整體做介紹。 第2章 軟體測試工程師必 

  
 

    

    
    
python 協程及socket網路程式設計
     
  
  
  
 協程 
 什麼是協程 
 協程，英文Coroutines，是一種比執行緒更加輕量級的存在。正如一個程序可以擁有多個執行緒一樣，一個執行緒也可以擁有多個協程。 最重要的是，協程不是被作業系統核心所管理，而完全是由程式所控制（也就是在使用者態執行）。 這樣帶來的好處就是效能得到了很大的提升，不會 

  
 

    

    
    
Python Socket網路程式設計（一）初識Socket和Socket初步使用
     
  
 
  
  
  
  
  
   目錄
   
    
     
      
       前言
       網路程式設計
       
        實質
        IP地址和埠
        資料傳輸協議
        協議
       
       Socket