TCP协议风格的回显客户端——服务器

TCP协议风格的客户端——服务器是Java中提供的另外一种版本，特点就是面向字节流进行网络传输数据。其中涉及到两个类

1. ServerSocket
2. Socket

对于UDP协议风格来说，客户端和服务器之间的交互不需要进行连接，直接就可以以数据包的形式发送接收数据。
对于TCP协议风格来说，客户端和服务器先得建立好连接，才能去执行后面的操作

服务器端：主要分为两个步骤

1. 利用ServerSocket类来初始化服务器，给服务器指定ip和端口号。具体用法和UDP中的DatagramSocket一致
2. 进入主循环
   ①先去从内核中获取到一个连接对象
   ②处理这个连接对象：
   a.获取请求并且解析
   b.根据请求计算响应
   c.把响应写回客户端

示例代码

public class TcpEchoServer {
    //1初始化服务器
    private ServerSocket serverSocket = null;

    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);//不绑定ip的话同样会自动绑定这台主机上的所有网卡ip
    }
    //2.进入主循环
    public void start() throws IOException {
        while(true){
            //①首先需要从内核中获取这个连接对象
            Socket socket = serverSocket.accept();//这个连接对象里面描述的就是这次连接的客户端和服务器的ip和端口号
            //同时内核中会给这次连接创建一个socket文件。
            System.out.println((socket.getInetAddress()));

            //②处理这个连接对象
            processSocket(socket);

        }
    }

    private void processSocket(Socket socket) {
        System.out.println(("客户端上限"));
        try(BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {
            //首先通过getInputStream和getOutputStream来获取到这个连接对象的流对象，也就是处理这个连接对象描述的socket文件的流对象
            //然后把这个流对象转化为以字符流处理的流对象，然后再添加上Buffer里面的缓冲区。
            //这样一来就可以通过Buffer来针对这个socket网卡文件进行读写操作。也就是读取请求和写回响应
            while(true){//这里写成死循环是为了可以不断开连接的情况下，一直处理连接。
                //a读取请求并且解析
                String request = bufferedReader.readLine();//写成按行读取可以和客户端达成应用层协议，按行读按行写
                String respose = processRequest(request);
                bufferedWriter.write(respose+"\n");
                //把socket文件里面的内容读取到内存中处理之后又写回到socket文件里面通过网卡发送出去。
  
            


             }
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("客户端下线");
        }
    }

    private String processRequest(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer t = new TcpEchoServer(8888);
        t.start();
    }
}

客户端：同样大致分为两步

1. 初始化客户端，借助Socket网卡文件操作类来传入服务器的ip和端口号进行数据传输。同样不需要给自己指定端口号，由内核自动分配
2. 进入主循环
   a.用户输入请求
   b.将请求写入socket文件并通过网卡发送
   c.从socket文件里面读取响应。
   d.将响应打印出来

示例代码：

public class TcpEchoClient {
    //初始化
    private Socket socket = null;
    public String ServerIp;
    public int ServerPort;

    public TcpEchoClient(String serverIp, int serverPort) throws IOException {
        ServerIp = serverIp;
        ServerPort = serverPort;
        socket = new Socket(serverIp,serverPort);//借助Socket类访问服务器。这个类和网卡有关。
    }
    //2.进入循环
    public void start() {
        System.out.println("客户端启动");
        try(BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()))) {
           //获取socket文件的流对象。就可以借助Buffered来对这个文件进行读写请求回应。然后通过网卡发送出去。
            while(true){
                Scanner s = new Scanner(System.in);
                String resquest = s.nextLine();
                bufferedWriter.write(resquest+"\n");//把这个请求写入socket文件发送出去
                String respose = bufferedReader.readLine();//从socket文件里面读取响应
                System.out.println((respose));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient t = new TcpEchoClient("127.0.0.1",8888);
        t.start();
    }
}

以上代码虽然看似搭建好了客户端——服务器，但是其实还存在两个比较严重的Bug

1. 由于BufferedWriter里面内置了一个缓冲区，所以从内存中写到磁盘上时，需要先把缓冲区填满才会一起去写到磁盘上，如果一次一次的写入磁盘的话，效率会大大降低，因为程序访问磁盘的效率远远小于访问内存。所以当我们从内存往socket文件中写入的时候，如果没把缓冲区填满，它是不会写进磁盘的，需要我们每次写入之后调用flush方法手动刷新缓冲区
2. 客户端访问到服务器之后，服务器端内核就会产生一个连接对象，并且分配一个socket文件，当服务器还在处理上一个客户端的连接的时候，再次来一个客户端连接的话，就还调用不到accept方法获取这个连接，也就是说服务器一次只能和一个客户端做交互。所以需要我们通过调用一个线程池来处理连接。

public void start() throws IOException {
        ExecutorService executorService = Executors.newCachedThreadPool();//创建一个线程池示例
        while(true){
            //①首先需要从内核中获取这个连接对象
            Socket socket = serverSocket.accept();//这个连接对象里面描述的就是这次连接的客户端和服务器的ip和端口号
            //同时内核中会给这次连接创建一个socket文件。
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    processSocket(socket);
                }
            });

            System.out.println((socket.getInetAddress()));

            //②处理这个连接对象
        }
    }