Java回顧之網絡通訊

時間  2019-11-10
標籤 java 回顧 網絡 通訊 欄目 Java 简体版
原文   原文鏈接

　　在這篇文章裏，咱們主要討論如何使用Java實現網絡通訊，包括TCP通訊、UDP通訊、多播以及NIO。java

　　TCP鏈接

　　TCP的基礎是Socket，在TCP鏈接中，咱們會使用ServerSocket和Socket，當客戶端和服務器創建鏈接之後，剩下的基本就是對I/O的控制了。數據庫

　　咱們先來看一個簡單的TCP通訊，它分爲客戶端和服務器端。編程

　　客戶端代碼以下：數組

簡單的TCP客戶端
import java.net.*;
import java.io.*;
public class SimpleTcpClient {

    public static void main(String[] args) throws IOException
    {
        Socket socket = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        BufferedReader brTemp = null;
        try
        {
            socket = new Socket(InetAddress.getLocalHost(), 5678);
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            pw = new PrintWriter(socket.getOutputStream());
            brTemp = new BufferedReader(new InputStreamReader(System.in));
            while(true)
            {
                String line = brTemp.readLine();
                pw.println(line);
                pw.flush();
                if (line.equals("end")) break;
                System.out.println(br.readLine());
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
        finally
        {
            if (socket != null) socket.close();
            if (br != null) br.close();
            if (brTemp != null) brTemp.close();
            if (pw != null) pw.close();
        }
    }
}

　　

　　服務器端代碼以下：服務器

簡單版本TCP服務器端
import java.net.*;
import java.io.*;
public class SimpleTcpServer {

    public static void main(String[] args) throws IOException
    {
        ServerSocket server = null;
        Socket client = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        try
        {
            server = new ServerSocket(5678);
            client = server.accept();
            br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            pw = new PrintWriter(client.getOutputStream());
            while(true)
            {
                String line = br.readLine();
                pw.println("Response:" + line);
                pw.flush();
                if (line.equals("end")) break;
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
        finally
        {
            if (server != null) server.close();
            if (client != null) client.close();
            if (br != null) br.close();
            if (pw != null) pw.close();
        }
    }
}

　　

　　這裏的服務器的功能很是簡單，它接收客戶端發來的消息，而後將消息「原封不動」的返回給客戶端。當客戶端發送「end」時，通訊結束。網絡

　　上面的代碼基本上勾勒了TCP通訊過程當中，客戶端和服務器端的主要框架，咱們能夠發現，上述的代碼中，服務器端在任什麼時候刻，都只能處理來自客戶端的一個請求，它是串行處理的，不能並行，這和咱們印象裏的服務器處理方式不太相同，咱們能夠爲服務器添加多線程，當一個客戶端的請求進入後，咱們就建立一個線程，來處理對應的請求。多線程

　　改善後的服務器端代碼以下：框架

複製代碼 
 1 import java.net.*;
 2 import java.io.*;
 3 public class SmartTcpServer {
 4     public static void main(String[] args) throws IOException
 5     {
 6         ServerSocket server = new ServerSocket(5678);
 7         while(true)
 8         {
 9             Socket client = server.accept();
10             Thread thread = new ServerThread(client);
11             thread.start();
12         }
13     }
14 }
15 
16 class ServerThread extends Thread
17 {
18     private Socket socket = null;
19 
20     public ServerThread(Socket socket)
21     {
22         this.socket = socket;
23     }
24     
25     public void run() {
26         BufferedReader br = null;
27         PrintWriter pw = null;
28         try
29         {
30             br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
31             pw = new PrintWriter(socket.getOutputStream());
32             while(true)
33             {
34                 String line = br.readLine();
35                 pw.println("Response:" + line);
36                 pw.flush();
37                 if (line.equals("end")) break;
38             }
39         }
40         catch(Exception ex)
41         {
42             System.err.println(ex.getMessage());
43         }
44         finally
45         {
46             if (socket != null)
47                 try {
48                     socket.close();
49                 } catch (IOException e1) {
50                     e1.printStackTrace();
51                 }
52             if (br != null)
53                 try {
54                     br.close();
55                 } catch (IOException e) {
56                     e.printStackTrace();
57                 }
58             if (pw != null) pw.close();
59         }
60     }
61 }
複製代碼

　　修改後的服務器端，就能夠同時處理來自客戶端的多個請求了。socket

　　在編程的過程當中，咱們會有「資源」的概念，例如數據庫鏈接就是一個典型的資源，爲了提高性能，咱們一般不會直接銷燬數據庫鏈接，而是使用數據庫鏈接池的方式來對多個數據庫鏈接進行管理，已實現重用的目的。對於Socket鏈接來講，它也是一種資源，當咱們的程序須要大量的Socket鏈接時，若是每一個鏈接都須要從新創建，那麼將會是一件很是沒有效率的作法。ide

　　和數據庫鏈接池相似，咱們也能夠設計TCP鏈接池，這裏的思路是咱們用一個數組來維持多個Socket鏈接，另一個狀態數組來描述每一個Socket鏈接是否正在使用，當程序須要Socket鏈接時，咱們遍歷狀態數組，取出第一個沒被使用的Socket鏈接，若是全部鏈接都在使用，拋出異常。這是一種很直觀簡單的「調度策略」，在不少開源或者商業的框架中（Apache/Tomcat），都會有相似的「資源池」。

　　TCP鏈接池的代碼以下：

多線程版本的TCP服務器端
import java.net.*;
import java.io.*;
public class SmartTcpServer {
    public static void main(String[] args) throws IOException
    {
        ServerSocket server = new ServerSocket(5678);
        while(true)
        {
            Socket client = server.accept();
            Thread thread = new ServerThread(client);
            thread.start();
        }
    }
}

class ServerThread extends Thread
{
    private Socket socket = null;

    public ServerThread(Socket socket)
    {
        this.socket = socket;
    }
    
    public void run() {
        BufferedReader br = null;
        PrintWriter pw = null;
        try
        {
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            pw = new PrintWriter(socket.getOutputStream());
            while(true)
            {
                String line = br.readLine();
                pw.println("Response:" + line);
                pw.flush();
                if (line.equals("end")) break;
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
        finally
        {
            if (socket != null)
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            if (br != null)
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if (pw != null) pw.close();
        }
    }
}

　　

　　UDP鏈接

　　UDP是一種和TCP不一樣的鏈接方式，它一般應用在對實時性要求很高，對準肯定要求不高的場合，例如在線視頻。UDP會有「丟包」的狀況發生，在TCP中，若是Server沒有啓動，Client發消息時，會報出異常，但對UDP來講，不會產生任何異常。

　　UDP通訊使用的兩個類時DatagramSocket和DatagramPacket，後者存放了通訊的內容。

　　下面是一個簡單的UDP通訊例子，同TCP同樣，也分爲Client和Server兩部分，Client端代碼以下：

一個簡單的TCP鏈接池
import java.net.*;
import java.io.*;
public class TcpConnectionPool {

    private InetAddress address = null;
    private int port;
    private Socket[] arrSockets = null;
    private boolean[] arrStatus = null;
    private int count;
    
    public TcpConnectionPool(InetAddress address, int port, int count)
    {
        this.address = address;
        this.port = port;
        this .count = count;
        arrSockets = new Socket[count];
        arrStatus = new boolean[count];
        
        init();
    }
    
    private void init()
    {
        try
        {
            for (int i = 0; i < count; i++)
            {
                arrSockets[i] = new Socket(address.getHostAddress(), port);
                arrStatus[i] = false;
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
    
    public Socket getConnection()
    {
        if (arrSockets == null) init();
        int i = 0;
        for(i = 0; i < count; i++)
        {
            if (arrStatus[i] == false) 
            {
                arrStatus[i] = true;
                break;
            }
        }
        if (i == count) throw new RuntimeException("have no connection availiable for now.");
        
        return arrSockets[i];
    }
    
    public void releaseConnection(Socket socket)
    {
        if (arrSockets == null) init();
        for (int i = 0; i < count; i++)
        {
            if (arrSockets[i] == socket)
            {
                arrStatus[i] = false;
                break;
            }
        }
    }
    
    public void reBuild()
    {
        init();
    }
    
    public void destory()
    {
        if (arrSockets == null) return;
        
        for(int i = 0; i < count; i++)
        {
            try
            {
                arrSockets[i].close();
            }
            catch(Exception ex)
            {
                System.err.println(ex.getMessage());
                continue;
            }
        }
    }
}

　　

　　Server端代碼以下：

UDP通訊客戶端
import java.net.*;
import java.io.*;
public class UdpClient {

    public static void main(String[] args)
    {
        try
        {
            InetAddress host = InetAddress.getLocalHost();
            int port = 5678;
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            while(true)
            {
                String line = br.readLine();
                byte[] message = line.getBytes();
                DatagramPacket packet = new DatagramPacket(message, message.length, host, port);
                DatagramSocket socket = new DatagramSocket();
                socket.send(packet);
                socket.close();
                if (line.equals("end")) break;
            }
            br.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　這裏，咱們也假設和TCP同樣，當Client發出「end」消息時，認爲通訊結束，但其實這樣的設計不是必要的，Client端能夠隨時斷開，並不須要關心Server端狀態。

　　多播（Multicast）

　　多播採用和UDP相似的方式，它會使用D類IP地址和標準的UDP端口號，D類IP地址是指224.0.0.0到239.255.255.255之間的地址，不包括224.0.0.0。

　　多播會使用到的類是MulticastSocket，它有兩個方法須要關注：joinGroup和leaveGroup。

　　下面是一個多播的例子，Client端代碼以下：

UDP通訊服務器端
import java.net.*;
import java.io.*;
public class UdpServer {

    public static void main(String[] args)
    {
        try
        {
            int port = 5678;
            DatagramSocket dsSocket = new DatagramSocket(port);
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            while(true)
            {
                dsSocket.receive(packet);
                String message = new String(buffer, 0, packet.getLength());
                System.out.println(packet.getAddress().getHostName() + ":" + message);
                if (message.equals("end")) break;
                packet.setLength(buffer.length);
            }
            dsSocket.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　服務器端代碼以下：

多播通訊客戶端
import java.net.*;
import java.io.*;
public class MulticastClient {

    public static void main(String[] args)
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try
        {
            InetAddress address = InetAddress.getByName("230.0.0.1");
            int port = 5678;
            while(true)
            {
                String line = br.readLine();
                byte[] message = line.getBytes();
                DatagramPacket packet = new DatagramPacket(message, message.length, address, port);
                MulticastSocket multicastSocket = new MulticastSocket();
                multicastSocket.send(packet);
                if (line.equals("end")) break;
            }
            br.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　NIO（New IO）

　　NIO是JDK1.4引入的一套新的IO API，它在緩衝區管理、網絡通訊、文件存取以及字符集操做方面有了新的設計。對於網絡通訊來講，NIO使用了緩衝區和通道的概念。

　　下面是一個NIO的例子，和咱們上面提到的代碼風格有很大的不一樣。

多播通訊服務器端
import java.net.*;
import java.io.*;
public class MulticastServer {

    public static void main(String[] args)
    {
        int port = 5678;
        try
        {
            MulticastSocket multicastSocket = new MulticastSocket(port);
            InetAddress address = InetAddress.getByName("230.0.0.1");
            multicastSocket.joinGroup(address);
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            while(true)
            {
                multicastSocket.receive(packet);
                String message = new String(buffer, packet.getLength());
                System.out.println(packet.getAddress().getHostName() + ":" + message);
                if (message.equals("end")) break;
                packet.setLength(buffer.length);
            }
            multicastSocket.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　上述代碼會試圖訪問一個本地的網址，而後將其內容打印出來。

　　　　
做者： 李勝攀
　　　　 　　　　
本文版權歸做者和博客園共有，歡迎轉載，但未經做者贊成必須保留此段聲明，且在文章頁面明顯位置給出原文鏈接，不然保留追究法律責任的權利。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程