JAVA BIO 和 NIO 網絡編程揭秘

標簽： java

OSI網絡七層模型

為使用不同計算機廠家的計算機能夠相互通信，以便在更大的范圍內建立計算機網絡，有必要建立一個國際范圍的網絡體系結構標準。
在這里插入圖片描述 ## 各層的主要功能
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-B9LeGin3-1586442516270)(30682F89DBF24F92B4C4B0DD5A333C45)]

傳輸控制協議TCP

傳輸控制協議（TCP）是Internet一個重要的傳輸協議。TCP提供面向連接，可靠，有序，字節流傳輸服務。應用程序在使用TCP之前，必須先建立TCP連接。

TCP握手機制

在這里插入圖片描述

用戶數據報協議UDP

用戶數據報協議UDP是Internet傳輸協議。
提供無連接，不可靠，數據報盡力傳輸服務。

開發應用人員在UDP上構建應用，關注以下幾點：

應用進程更容易控制并發發送什么數據以及何時發送
無需建立連接
無連接狀態
首部開銷下

UDP和TCP比較

TCP	UDP
面向連接	無連接
提供可靠性保證	不可靠
慢	塊
資源占用多	資源占用少

Socket編程

Internet中應用最廣泛的網絡應用編程接口，實現與3種底層協議接口：

數據報類型套接字SOCK_DGRAM（面向UDP接口）
流式套接字SOCK_STREAM(面向TCP接口)
原始套接字SOCK_RAW(面向網絡層協議接口IP，ICMP等)

主要socket API及其調用過程

在這里插入圖片描述

Socket API 函數定義

listen(),accept()函數只用用于服務器端；
connect()函數只能用于客戶端
socket(),bind(),send(),recv(),sendto().recvfrom(),close()

Http協議-請求數據包解析

在這里插入圖片描述

Http協議-響應數據包解析

在這里插入圖片描述

Http協議-響應狀態碼

在這里插入圖片描述

BIO - 阻塞IO的定義

阻塞（blocking）IO:資源不可用時，IO請求一直阻塞，直到反饋結果（有數據或超時）。
非阻塞（non-blocking）IO:資源不可用時，IO請求離開放回，放回數據表示資源不可用。
同步（synchronous）IO:應用阻塞在發送或接受數據后立刻放回，實際處理是異步執行的。

阻塞和非阻塞是獲取資源的方式，同步/異步是程序如何處理資源的邏輯設計。代碼中使用的API：ServerSocket#accept,InputStream#read都是阻塞的API。操作系統底層API中，默認Socket操作都是Blocking型，send/recv等接口都是阻塞的

NIO操作說明

Buffer緩存區

package cn.tk.myproject.nio;

import java.nio.Buffer;
import java.nio.ByteBuffer;

public class BufferDemo {

    public static void main(String[] args) {
        ByteBuffer buffer= ByteBuffer.allocate(4);//申請堆內內存   allocateDirect 申請堆外內存
        System.out.println("buffer===positon:"+buffer.position()+",capacity:"+buffer.capacity()+",limit:"+buffer.limit());
        buffer.put((byte) 1);
        buffer.put((byte) 2);
        buffer.put((byte) 3);
        System.out.println("buffer===positon:"+buffer.position()+",capacity:"+buffer.capacity()+",limit:"+buffer.limit());
        buffer.flip();//切換讀寫
        System.out.println("================讀=======================");
        System.out.println("buffer===positon:"+buffer.position()+",capacity:"+buffer.capacity()+",limit:"+buffer.limit());
        buffer.get();
        buffer.get();
        System.out.println("buffer===positon:"+buffer.position()+",capacity:"+buffer.capacity()+",limit:"+buffer.limit());
        buffer.compact();//清除已讀的元素
        buffer.put((byte) 4);
        buffer.put((byte) 5);
        buffer.put((byte) 6);
        System.out.println("buffer===positon:"+buffer.position()+",capacity:"+buffer.capacity()+",limit:"+buffer.limit());
        buffer.rewind();//重置positon位置
        System.out.println("buffer===positon:"+buffer.position()+",capacity:"+buffer.capacity()+",limit:"+buffer.limit());

    }
}

緩存區本質上是一個可以寫入數據的內存塊（類似數組），然后可以再次讀取。此內存塊包含在NIO Buffer對象中，該對象提供了一組方法，可以更輕松地使用內存塊。

相比較直接對數組的操作，Buffer API更加容易操作和管理。

使用Buffer進行數據寫入與讀取，需要進行如下四個步驟：

將數據寫入緩存區
調用buffer,flip(),轉換為讀取模式
緩存區讀取數據
調用buffer.clear()或buffer.compact()清除緩沖區

Buffer 工作原理

Buffer三個重要屬性：

?1. capacity容量：作為一個內存塊，Buffer具有一定的固定大小，也稱為“容量”。
?2. position位置：寫入模式時代表寫數據的位置。讀取模式時代表讀取的位置。
3. limit限制：寫入模式，限制等于buffer的容量。讀取模式下，limit等于寫入的數據量

在這里插入圖片描述

ByteBuffer內存類型

? ByteBuffer為性能關鍵型代碼提供了直接內存（direct堆外）和非直接內存（heap堆）兩種實現。

? 堆外內存獲取的方式：ByteBuffer directByteBuffer=ByteBuffer.allocateDirect(noBytes);

優點

進行網絡IO或者文件IO時比heapBuffer少一次拷貝。（file/socket----OS memory —jvm heap)GC會移動對象內存，在寫file或socket的過程中，JVM的實現中，會先把數據復制到堆外，再進行寫入。
GC范圍之外，降低GC壓力，但實現了自動管理。DirectByteBuffer中有一個Cleaner對象（PhantomReference）,Cleaner被GC前會執行clean 方法，觸發DirectByteBuffer中定義的Deallocator

建議

性能確實可觀的時候才去使用；分配給大型，長壽命；（網絡傳輸，文件讀寫場景）
通過虛擬機參數MaxDirectMemorySiz現在大小，防止耗盡整個機器的內存

Channel通道

客戶端代碼

package cn.tk.myproject.nio;


import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

/**
 * 客戶端
 */
public class NioClient {
    public static void main(String[] args) throws IOException {
        SocketChannel socketClinet=SocketChannel.open();
        socketClinet.configureBlocking(false);//設置為非阻塞 默認為不阻塞
        socketClinet.connect(new InetSocketAddress("localhost",8080));//連接指定的服務器路徑
        while (!socketClinet.finishConnect()){
            //如果沒有連接成功就等待
            Thread.yield();
        }
        Scanner scanner=new Scanner(System.in);
        System.out.println("請輸入：");
        //發送數據
        String msg = scanner.nextLine();
        ByteBuffer sendBuffer = ByteBuffer.wrap(msg.getBytes());
        while (sendBuffer.hasRemaining()){//如果有數據
            //往服務器寫入數據
            socketClinet.write(sendBuffer);
        }
        System.out.println("讀取服務器數據");
        ByteBuffer reposetBuffer = ByteBuffer.allocate(1024);
        while (socketClinet.isOpen()&&socketClinet.read(reposetBuffer)!=1){
            if(reposetBuffer.position()>0) break;
        }
        //讀取數組中的數據
        reposetBuffer.flip();
        byte[] content=new byte[reposetBuffer.limit()];
        reposetBuffer.get(content);
        System.out.println(new String(content));
        scanner.close();
        socketClinet.close();


    }
}

服務端代碼
版本1

package cn.tk.myproject.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

/**
 * 模仿BIO的寫法
 */
public class NioServer {

    public static void main(String[] args) throws IOException {
        //創建網絡服務端
        ServerSocketChannel socketServer=ServerSocketChannel.open();
        socketServer.configureBlocking(false);
        socketServer.bind(new InetSocketAddress(8080)); //綁定端口
        System.out.println("啟動成功");
        while (true){
            SocketChannel accept = socketServer.accept();
            if(accept!=null){
                System.out.println("接受到新的連接："+accept.getRemoteAddress());
                accept.configureBlocking(false);
                //讀取數據
                ByteBuffer requestBuffer=ByteBuffer.allocate(1024);
                while (accept.isOpen()&&accept.read(requestBuffer)!=-1){
                    if (requestBuffer.position()>0) break;
                }
                if (requestBuffer.position()==0) continue;
                requestBuffer.flip();
                byte[] bytes=new byte[requestBuffer.limit()];
                requestBuffer.get(bytes);
                System.out.println(new String(bytes));
                System.out.println("接到連接的數據："+accept.getRemoteAddress());
                //返回數據給客戶端
                // 響應結果 200
                String response = "HTTP/1.1 200 OK\r\n" +
                        "Content-Length: 11\r\n\r\n" +
                        "Hello World";
                ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                while (buffer.hasRemaining()) {
                    accept.write(buffer);// 非阻塞
                }
            }
        }

    }
}

版本2：

package cn.tk.myproject.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.Iterator;

public class NioServer1 {

    private static ArrayList<SocketChannel> socketChannels=new ArrayList<>();

    public static void main(String[] args) throws IOException {
        //創建網絡服務端
        ServerSocketChannel socketServer=ServerSocketChannel.open();
        socketServer.configureBlocking(false);
        socketServer.bind(new InetSocketAddress(8080)); //綁定端口
        System.out.println("啟動成功");
        while (true){
            SocketChannel accept = socketServer.accept();
            if(accept!=null) {
                System.out.println("接受到新的連接：" + accept.getRemoteAddress());
                //讀取數據
                accept.configureBlocking(false);
                socketChannels.add(accept);
            }else{

                Iterator<SocketChannel> iterator = socketChannels.iterator();
                while (iterator.hasNext()){
                    SocketChannel next = iterator.next();
                    ByteBuffer requestBuffer=ByteBuffer.allocate(1024);
                    if(next.read(requestBuffer)==0) continue;
                    if (requestBuffer.position()==0) continue;
                    requestBuffer.flip();
                    byte[] bytes=new byte[requestBuffer.limit()];
                    requestBuffer.get(bytes);
                    System.out.println(new String(bytes));
                    System.out.println("接到連接的數據："+next.getRemoteAddress());
                    //返回數據給客戶端
                    // 響應結果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                    while (buffer.hasRemaining()) {
                        next.write(buffer);// 非阻塞
                    }
                    iterator.remove();
                }

            }
        }

    }
}

在這里插入圖片描述

ServerSocketChannel

ServerSocketChanner可以監聽新建的TCP連接通道，類似ServerSocket.
在這里插入圖片描述

ServerSocketChanner.accept():如果該通道處理非阻塞模式，那么如果沒有掛起的連接，該方法立即返回null.必須檢查放回的SocketChanner是否為null

Selector選擇器

package cn.tk.myproject.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/**
 * 結合Selector實現非阻塞服務端(放棄對channel的輪詢,借助消息通知機制)
 */
public class NioServer2 {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel socketServer=ServerSocketChannel.open();
        socketServer.configureBlocking(false);
        //構建一個Selector選擇器，并把channer注冊上去
        Selector selector = Selector.open();
        SelectionKey selectionKey = socketServer.register(selector, 0, socketServer);
        selectionKey.interestOps(selectionKey.OP_ACCEPT);//只對accept方法感興趣

        socketServer.bind(new InetSocketAddress(8080));

        System.out.println("啟動成功");

        while (true){
            // 不再輪詢通道,改用下面輪詢事件的方式.select方法有阻塞效果,直到有事件通知才會有返回
            selector.select();

            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while (iterator.hasNext()){
                SelectionKey next = iterator.next();
                iterator.remove();

                //關注read 和 accept事件
                if(next.isAcceptable()){
                    ServerSocketChannel socketChannel= (ServerSocketChannel) next.attachment();

                    SocketChannel accept = socketChannel.accept();
                    accept.configureBlocking(false);
                    //注冊read事件
                    SelectionKey register = accept.register(selector, 0, accept);
                    register.interestOps(register.OP_READ);
                    System.out.println("接受到一個新的請求："+accept.getRemoteAddress());

                }
                //處理接受的數據
                if(next.isReadable()){
                    SocketChannel socketChannel= (SocketChannel) next.attachment();
                    ByteBuffer requestBuffer = ByteBuffer.allocate(1024);
                    while (socketChannel.isOpen() && socketChannel.read(requestBuffer) != -1) {
                        // 長連接情況下,需要手動判斷數據有沒有讀取結束 (此處做一個簡單的判斷: 超過0字節就認為請求結束了)
                        if (requestBuffer.position() > 0) break;
                    }
                    if(requestBuffer.position() == 0) continue; // 如果沒數據了, 則不繼續后面的處理
                    requestBuffer.flip();
                    byte[] content = new byte[requestBuffer.limit()];
                    requestBuffer.get(content);
                    System.out.println(new String(content));
                    System.out.println("收到數據,來自：" + socketChannel.getRemoteAddress());
                    // TODO 業務操作 數據庫 接口調用等等

                    // 響應結果 200
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Length: 11\r\n\r\n" +
                            "Hello World";
                    ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                    while (buffer.hasRemaining()) {
                        socketChannel.write(buffer);
                    }
                }
            }
        }

    }
}

Selector是一個Java NIO組件，可以檢查一個或多個NIO通道，并確定哪些通道已準備好進行讀取或寫入。實現單個線程可以管理多個通道，從而管理多個網絡連接。

在這里插入圖片描述

一個線程使用Selector監聽多個channel的不同事件：

四個事件分別對應SelctionKey四個常量。

Connect 連接（SelectionKey.OP_CONNET）
Accept準備就緒（OP_ACCEPT）
Read讀取（OP_READ）
Write寫入（OP_WRITE)

核心

實現一個線程處理多個通道的核心概念理解：事件驅動機制。

非阻塞的網絡通道下，開發者通過Selector注冊對于通道感興趣的世界類型，線程通過監聽事件來觸發相應的代碼執行。（擴展：更底層是操作系統的多路復用機制）

在這里插入圖片描述

NIO對比BIO

在這里插入圖片描述

如果你的程序需要支撐大量的連接，使用NIO是最好的方式。

Tomcat8中，已經完全去除BIO相關的網絡出了代碼，默認采用NIO進行網絡處理。

NIO與多線程結合的改進方案

在這里插入圖片描述

總結

? NIO為開發者提供了功能豐富及強大的IO處理API，但是在應用于網絡開發的過程中，直接使用JDK提供的API，比較繁瑣。而且要想將性能進行提升，光有NIO還不夠，還需要將多線程技術與之結合起來。

因為網絡編程本身的復雜性，已經JDK API開發的使用難度較高，所以在開源社區中，涌出很多對JDK NIO進行封裝，增強后的網絡編程框架，列如：Netty,Mina等。

本文鏈接：https://blog.csdn.net/xb1964109474/article/details/105422004

智能推薦

BIO和NIO原理

NIO中主要包括： Buffer的主要屬性：直接緩沖區：ByteBuffer buffer = ByteBuffer.allocateDirect(1024); 將文件拷貝到內存中，而不是jvm中，改變buffer中內容就直接改變文件內容，比較牛了。其中 MappedByteBuffer也是相同的功能；通道：實現類：反應堆：R...

freemarker + ItextRender 根據模板生成PDF文件

1. 制作模板 2. 獲取模板，并將所獲取的數據加載生成html文件 2. 生成PDF文件其中由兩個地方需要注意，都是關于獲取文件路徑的問題，由于項目部署的時候是打包成jar包形式，所以在開發過程中時直接安照傳統的獲取方法沒有一點文件，但是當打包后部署，總是出錯。于是參考網上文章，先將文件讀出來到項目的臨時目錄下，然后再按正常方式加載該臨時文件；還有一個問題至今沒有解決，就是關于生成PDF文件...

電腦空間不夠了？教你一個小秒招快速清理 Docker 占用的磁盤空間！

Docker 很占用空間，每當我們運行容器、拉取鏡像、部署應用、構建自己的鏡像時，我們的磁盤空間會被大量占用。如果你也被這個問題所困擾，咱們就一起看一下 Docker 是如何使用磁盤空間的，以及如何回收。 docker 占用的空間可以通過下面的命令查看： TYPE 列出了docker 使用磁盤的 4 種類型： Images：所有鏡像占用的空間，包括拉取下來的鏡像，和本地構建的。 Con...

requests實現全自動PPT模板

http://www.1ppt.com/moban/ 可以免費的下載PPT模板，當然如果要人工一個個下，還是挺麻煩的，我們可以利用requests輕松下載訪問這個主頁，我們可以看到下面的樣式點每一個PPT模板的圖片，我們可以進入到詳細的信息頁面，翻到下面，我們可以看到對應的下載地址點擊這個下載的按鈕，我們便可以下載對應的PPT壓縮包那我們就開始做吧首先，查看網頁的源代碼，我們可以看到每一...