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。

Socket 客戶端例項

如下的 GreetingClient 是一個客戶端程式，該程式通過 socket 連線到伺服器併發送一個請求，然後等待一個響應。
GreetingClient.java 檔案程式碼：

// 檔名 GreetingClient.java
 
import java.net.*;
import java.io.*;
 
public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("連線到主機：" + serverName + " ，埠號：" + port);
         Socket client = new Socket(serverName, port);
         System.out.println("遠端主機地址：" + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);

     out.writeUTF("Hello from " + client.getLocalSocketAddress());
     InputStream inFromServer = client.getInputStream();
     DataInputStream in = new DataInputStream(inFromServer);
     System.out.println("伺服器響應： " + in.readUTF());
     client.close();
  }catch(IOException e)
  {
     e.printStackTrace();
  }
   }
}

Socket 服務端例項

如下的GreetingServer 程式是一個伺服器端應用程式，使用 Socket 來監聽一個指定的埠。
GreetingServer.java 檔案程式碼：

// 檔名 GreetingServer.java
 
import java.net.*;
import java.io.*;
 
public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }
 
   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("等待遠端連線，埠號為：" + serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("遠端主機地址：" + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("謝謝連線我：" + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.run();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

編譯以上兩個 java 檔案程式碼，並執行以下命令來啟動服務，使用埠號為 6066：

$ javac GreetingServer.java 
$ java GreetingServer 6066
等待遠端連線，埠號為：6066...

新開一個命令視窗，執行以上命令來開啟客戶端：

$ javac GreetingClient.java 
$ java GreetingClient localhost 6066
連線到主機：localhost ，埠號：6066
遠端主機地址：localhost/127.0.0.1:6066
伺服器響應： 謝謝連線我：/127.0.0.1:6066
Goodbye!

筆記

Socket的概念：上面已經解釋了，不在複述。

同步和非同步：同步和非同步是針對應用程式和核心的互動而言的，同步指的是使用者程序觸發IO 操作並等待或者
輪詢的去檢視IO 操作是否就緒，而非同步是指使用者程序觸發IO 操作以後便開始做自己的事情，而當IO 操作已經完成的
時候會得到IO 完成的通知。

以銀行取款為例：

同步 ： 自己親自出馬持銀行卡到銀行取錢（使用同步 IO 時，Java 自己處理IO 讀寫）；

非同步 ： 委託一小弟拿銀行卡到銀行取錢，然後給你（使用非同步IO 時，Java 將 IO 讀寫委託給OS 處理，需要將資料緩衝區
地址和大小傳給OS(銀行卡和密碼)，OS 需要支援非同步IO操作API）；

阻塞和非阻塞：阻塞和非阻塞是針對於程序在訪問資料的時候，根據IO操作的就緒狀態來採取的不同方式，說白了是一種
讀取或者寫入操作方法的實現方式，阻塞方式下讀取或者寫入函式將一直等待，而非阻塞方式下，讀取或者寫入方法會立即
返回一個狀態值。

以銀行取款為例：

阻塞 ： ATM排隊取款，你只能等待（使用阻塞IO時，Java呼叫會一直阻塞到讀寫完成才返回）；

非阻塞 ： 櫃檯取款，取個號，然後坐在椅子上做其它事，等號廣播會通知你辦理，沒到號你就不能去，你可以不斷問大堂
經理排到了沒有，大堂經理如果說還沒到你就不能去（使用非阻塞IO時，如果不能讀寫Java呼叫會馬上返回，當IO事件
分發器通知可讀寫時再繼續進行讀寫，不斷迴圈直到讀寫完成）

1.BIO 程式設計

Blocking IO： 同步阻塞的程式設計方式。

BIO程式設計方式通常是在JDK1.4版本之前常用的程式設計方式。程式設計實現過程為：首先在服務端啟動一個ServerSocket來
監聽網路請求，客戶端啟動Socket發起網路請求，預設情況下ServerSocket回建立一個執行緒來處理此請求，
如果服務端沒有執行緒可用，客戶端則會阻塞等待或遭到拒絕。

且建立好的連線，在通訊過程中，是同步的。在併發處理效率上比較低。大致結構如下：

同步並阻塞，伺服器實現模式為一個連線一個執行緒，即客戶端有連線請求時伺服器端就需要啟動一個執行緒進行處理，
如果這個連線不做任何事情會造成不必要的執行緒開銷，當然可以通過執行緒池機制改善。

BIO方式適用於連線數目比較小且固定的架構，這種方式對伺服器資源要求比較高，併發侷限於應用中，
JDK1.4以前的唯一選擇，但程式直觀簡單易理解。

使用執行緒池機制改善後的BIO模型圖如下:

2.NIO 程式設計：Unblocking IO（New IO）： 同步非阻塞的程式設計方式。

NIO本身是基於事件驅動思想來完成的，其主要想解決的是BIO的大併發問題，NIO基於Reactor，當socket有流可讀或
可寫入socket時，作業系統會相應的通知引用程式進行處理，應用再將流讀取到緩衝區或寫入作業系統。也就是說，
這個時候，已經不是一個連線就要對應一個處理執行緒了，而是有效的請求，對應一個執行緒，當連線沒有資料時，
是沒有工作執行緒來處理的。

NIO的最重要的地方是當一個連線建立後，不需要對應一個執行緒，這個連線會被註冊到多路複用器上面，所以所有的
連線只需要一個執行緒就可以搞定，當這個執行緒中的多路複用器進行輪詢的時候，發現連線上有請求的話，才開啟一個
執行緒進行處理，
也就是一個請求一個執行緒模式。

在NIO的處理方式中，當一個請求來的話，開啟執行緒進行處理，可能會等待後端應用的資源(JDBC連線等)，
其實這個執行緒就被阻塞了，當併發上來的話，還是會有BIO一樣的問題

3.AIO程式設計：Asynchronous IO： 非同步非阻塞的程式設計方式。

與NIO不同，當進行讀寫操作時，只須直接呼叫API的read或write方法即可。這兩種方法均為非同步的，對於讀操作而言，
當有流可讀取時，作業系統會將可讀的流傳入read方法的緩衝區，並通知應用程式；對於寫操作而言，當作業系統將
write方法傳遞的流寫入完畢時，作業系統主動通知應用程式。即可以理解為，read/write方法都是非同步的，完成後會
主動呼叫回撥函式。在JDK1.7中，這部分內容被稱作NIO.2，主要在java.nio.channels包下增加了下面四個非同步通道：
AsynchronousSocketChannel、AsynchronousServerSocketChannel、AsynchronousFileChannel、	AsynchronousDatagramChannel

bio示例

server示例：

public class Server {

    public static void main(String[] args) {
        int port = genPort(args);
        
        ServerSocket server = null;
        ExecutorService service = Executors.newFixedThreadPool(50);
        
        try{
            server = new ServerSocket(port);
            System.out.println("server started!");
            while(true){
                Socket socket = server.accept();
                
                service.execute(new Handler(socket));
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(server != null){
                try {
                    server.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            server = null;
        }
    }
    
    static class Handler implements Runnable{
        Socket socket = null;
        public Handler(Socket socket){
            this.socket = socket;
        }
        @Override
        public void run() {
            BufferedReader reader = null;
            PrintWriter writer = null;
            try{
                
                reader = new BufferedReader(
                        new InputStreamReader(socket.getInputStream(), "UTF-8"));
                writer = new PrintWriter(
                        new OutputStreamWriter(socket.getOutputStream(), "UTF-8"));
                String readMessage = null;
                while(true){
                    System.out.println("server reading... ");
                    if((readMessage = reader.readLine()) == null){
                        break;
                    }
                    System.out.println(readMessage);
                    writer.println("server recive : " + readMessage);
                    writer.flush();
                }
            }catch(Exception e){
                e.printStackTrace();
            }finally{
                if(socket != null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                socket = null;
                if(reader != null){
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                reader = null;
                if(writer != null){
                    writer.close();
                }
                writer = null;
            }
        }
        
    }
    
    private static int genPort(String[] args){
        if(args.length > 0){
            try{
                return Integer.parseInt(args[0]);
            }catch(NumberFormatException e){
                return 9999;
            }
        }else{
            return 9999;
        }
    }
    
}

2.client示例：

public class Client {
    public static void main(String[] args) {
        String host = null;
        int port = 0;
        if(args.length > 2){
            host = args[0];
            port = Integer.parseInt(args[1]);
        }else{
            host = "127.0.0.1";
            port = 9999;
        }
        
        Socket socket = null;
        BufferedReader reader = null;
        PrintWriter writer = null;
        Scanner s = new Scanner(System.in);
        try{
            socket = new Socket(host, port);
            String message = null;
            
            reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream(), "UTF-8"));
            writer = new PrintWriter(
                    socket.getOutputStream(), true);
            while(true){
                message = s.nextLine();
                if(message.equals("exit")){
                    break;
                }
                writer.println(message);
                writer.flush();
                System.out.println(reader.readLine());
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            socket = null;
            if(reader != null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            reader = null;
            if(writer != null){
                writer.close();
            }
            writer = null;
        }
    }
}

以上只是簡單示例，僅供參考！

DatagramSocket(UDP)簡單示例

服務端：

public class Server {
    public static void main(String[] args) {
        try {
            DatagramSocket server = new DatagramSocket(5060);
            DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
            server.receive(packet);
            System.out.println(packet.getAddress().getHostName() + "(" + packet.getPort() + "):" + new String(packet.getData()));
            packet.setData("Hello Client".getBytes());
            packet.setPort(5070);
            packet.setAddress(InetAddress.getLocalHost());
            server.send(packet);
            server.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客戶端:

public class Client {
    public static void main(String[] args){
        try {
            DatagramSocket client = new DatagramSocket(5070);
            DatagramPacket packet = new DatagramPacket(new byte[1024],1024);
            packet.setPort(5060);
            packet.setAddress(InetAddress.getLocalHost());
            packet.setData("Hello Server".getBytes());
            client.send(packet);
            client.receive(packet);
            System.out.println(packet.getAddress().getHostName() + "(" + packet.getPort() + "):" + new String(packet.getData()));
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}