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流中，并等待客户端返回信息，

　　接受到返回信息后，则接着往下执行，若不需输入，则释放连接