Java BIO及實現

發現日常學習過的知識不久就會遺忘，在此只是整理並記錄一下學習筆記，做個回憶，並方便以后查閱，若有錯誤，歡迎指正

 

網絡模型：TCP/IP網絡模型是從OSI七層模型中演化來的，osi模型分為物理層，數據鏈路層，網絡層，傳輸層，會話層，表示層，應用層，

TCP/IP網絡模型分為：網絡接口層，網際層，傳輸層，應用層

 

我對BIO的認識： 隨着技術的發展，兩個或以上的程序必然需要進行交互，於是BIO提供了一種端到端的通信，相當於對傳輸層的一種封裝，對於開發人員而言

隱藏了傳輸的細節，將這些固定的“套路”抽象出來，提供一種端到端的通信，可以使我們更加專注於業務的開發，並且這種通訊是阻塞式的（block input output）

 

阻塞式：服務端啟動，等待客戶端的連接，在客戶端連接到服務端后，服務端啟動一個線程去監聽客戶端消息，客戶端發送消息，並等待服務端返回（客戶端一直阻塞），服務端收到消息，

將消息返回給客戶端，此時一次交互完成。若還需交互，則不釋放連接，客戶端再次將消息發送給服務端，並等待返回，若不需要交互，則客戶端釋放連接。

 

生活中例子：A聘用了B干活，A讓B去打印材料，在B去打印的期間，A一直在等待B的回來，在B沒返回時，A將不做任何事情，一直等待B的返回，直到B返回后，A才接受到材料 （一次交互完成）

　　　　　　如果A還需要打印，則再次讓B去打印，並等待B返回，期間什么都不干，如果不需要B去打印，就解除和B的聘用關系。直至再需要時聘用C

 

BIO代碼實現（參考了一些市面上的視頻資料，侵刪）

服務端：

 

package com.study.server;

import com.study.info.HostInfo;

import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BIOEchoServer {
    public static void main(String[] args) throws Exception{
        ServerSocket socket = new ServerSocket(HostInfo.PORT);
        System.out.println("服務端已經啟動，監聽端口為：" + HostInfo.PORT);
        boolean flag = true;
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        while (flag){
            Socket client = socket.accept();
            executorService.submit(new EchoClientHandler(client));
        }
        executorService.shutdown();
        socket.close();
    }

    private static class EchoClientHandler implements Runnable{

        private Socket client;
        private Scanner scanner;
        private PrintStream out;
        private boolean flag = true;

        public EchoClientHandler(Socket client){
            this.client = client;
            try {
                this.scanner = new Scanner(this.client.getInputStream());
                this.scanner.useDelimiter("\n");
                this.out = new PrintStream(this.client.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        public void run() {
            while (this.flag){
                if(this.scanner.hasNext()){
                    String var = this.scanner.next().trim();
                    System.out.println("收到客戶端發來的"+var);
                    if("byebye".equals(var)){
                        this.out.print("888888");
                        this.flag = false;
                    } else {
                      out.println("【echo】" + var);
                    }
                }
            }
            try {
                this.scanner.close();
                this.out.close();
                this.client.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

 

 客戶端：

package com.study.client;

import com.study.info.HostInfo;
import com.study.util.InputUtil;

import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class BIOEchoClient {
    public static void main(String[] args) throws Exception{
        Socket client = new Socket(HostInfo.HOST_NAME, HostInfo.PORT);
        Scanner scan = new Scanner(client.getInputStream());
        scan.useDelimiter("\n");
        PrintStream out = new PrintStream(client.getOutputStream());
        boolean flag = true;
        while (flag){
            String inputData = InputUtil.getString("請輸入要發送的內容：").trim();
            out.println(inputData);
            if (scan.hasNext()){
                String str = scan.next();
                System.out.println(str);
            }
            if ("byebye".equalsIgnoreCase(inputData)){
                flag = false;
            }
        }
        client.close();
    }
}

 

工具包：

 

package com.study.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputUtil {
    private static final BufferedReader KEYBOARD_INPUT = new BufferedReader(new InputStreamReader(System.in));

    private InputUtil(){
    }

    public static String getString(String prompt){
        boolean flag = true;    //數據接受標記
        String str = null;
        while (flag){
            System.out.println(prompt);
            try {
                str = KEYBOARD_INPUT.readLine();    // 讀取一行數據
                if(str == null || "".equals(str)){
                    System.out.println("數據輸入錯誤，不允許為空！");
                }else {
                    flag = false;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return str;
    }
}

 

IP及端口常量：

package com.study.info;

public class HostInfo {
    public static final String HOST_NAME = "localhost";
    public static final int PORT = 9999;
}

 

效果

 

 

 

　　　　　　

代碼思路整理：

服務端：

　　1.通過ServerSocket創建監聽，並創建線程池

　　2.當ServerSocket通過accept方法接受到請求時，線程池將會分出一個線程來執行所要進行的操作

　　3.(分出的線程會)等待客戶端輸入完成（即客戶端安排做的事），客戶端輸入完成，則將會執行自己的處理並返回相應的結果（需要服務端來進行的運算，取數等一些操作，本例中是更改字符串）

　　4.服務端處理完成，則將數據返回客戶端，等待客戶端的下次輸入事件，循環3,4,直至客戶端釋放連接

 

客戶端：

　　通過Socket創建客戶端，在接受到鍵盤輸入后，將輸入信息寫入OutputStream流中，並等待客戶端返回信息，

　　接受到返回信息后，則接着往下執行，若不需輸入，則釋放連接