【计算机网络】网络编程 Socket

1.TCP和UDP的区别

2.基于UDP的 Socket API

总结

3.基于TCP的Socket API

服务器程序的问题

网络编程的目的：通过网络，让不同主机之间能够进行通信。

在进行网络编程的时候，需要操作系统提供一组API，也就是Socket API，才能完成编程。Socket API可以认为是应用层和传输层之间交互的路径。

Socket：也被称为套接字，就是网络中不同主机上的应用程序之间进行双向通信的端点的抽象。其本质上是一种特殊的文件。与普通文件不同的是，普通文件都是在同一台计算机上，两个进程之间传输数据。而Socket可以实现在不同计算机之间传输数据，也就是网络传输数据。比如说打开QQ,打开一个网页，这些都是socket来实现通信的，而网络通信又必须遵守的两个协议，tcp/ip协议和udp协议，Socket里面已经封装好了这两个协议，我们直接拿来用即可。Socket就属于是把"网卡"这个设备给抽象成文件了。往Socket文件中写数据，就相当于通过网卡发送数据；从Socket文件读数据，就相当于通过网卡接收数据。

传输层提供的网络协议主要有两个：TCP和UDP。

1.TCP和UDP的区别

TCP是有连接的，UDP是无连接的。
TCP是可靠传输的，UDP是不可靠传输的。
TCP是面向字节流的，UDP是面向数据报的。
TCP和UDP都是全双工的。

详细来说这四个区别。

1. TCP是有连接的，UDP是无连接的。

这里的连接只是抽象的说法，就是连接双方各自保存了对方的信息。两台计算机连接就是双方彼此保存了对方的关键信息。TCP想要通信，就要先建立连接，如果一方请求建立连接，而另一方拒绝连接，则无法连接，也就无法通信。而UDP想要通信，直接发送数据即可，不需要关心对方是否同意，UDP自身也不会保存对方的信息。

2. TCP是可靠传输的，UDP是不可靠传输的。

举个例子：A给B发送消息，发送成功还是失败，若A这边都能及时知道，那这就是可靠传输，否则就是不可靠传输。但是要想可靠传输，也得付出一些代价：

可靠传输的机制更复杂。
可靠传输的传输效率会降低。

3. TCP是面向字节流的，UDP是面向数据报的。

即TCP是以字节为基本单位来进行传输的。
UDP是以数据报为基本单位进行传输的。
网络通信数据的基本单位有多种说法：数据报(Datagram)，数据包(Packet)，数据帧(Frame)，数据段(Segment)。

4. TCP和UDP都是全双工的。

一个信道，允许双向通信，就是全双工。

一个信道，只能单向通信，就是半双工。

双向通信的原因：与网线有关，一根网线里通常有8根网线，4个为一组，每一组又是单向传输的，这样这一组负责数据传过来，另一组负责数据传过去。就构成了双向通信。

2.基于UDP的 Socket API

在Java中也提供了一组API，用来操作Socket，具体使用DatagramSocket这个类操作。其常用方法有接收数据receive()方法，发送数据send()方法，关闭文件close()方法。DatagramPacket这个类用来创建数据包，每次发送数据或者是接收数据都要以数据包的形式传递。且发送数据时数据包还要加上发送目的地(IP，端口等)。接收数据时还要提前创建好空的数据报。

为啥要以数据包的形式接收和发送？

因为UDP是面向数据包的。是以数据报为基本单位。

接下来我们实现一个简单的基于UDP的客户端/服务器通信的程序。(回显服务器)

服务器程序

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

//服务器程序
public class  MyServer {
    private DatagramSocket socket = null;
    //port 端口号 服务器需要手动指定端口号
    public MyServer(int port) throws SocketException {
        //折磨写就是手动指定端口
        socket = new DatagramSocket(port);
        //这么写就是让系统自动分配端口
        //socket = new DatagramSocket();
    }
    //服务器启动方法start
    public void start() throws IOException {
        System.out.println("服务器启动!");
        while(true) {
            // 1.读取请求并解析
            //创建一个空的数据报，用来存储服务器接收客户端传来的请求
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            //讲数据报传入socket中
            socket.receive(requestPacket);
            //将数据报中存储的客户端的请求数据从字节流转成字符串
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            // 2.根据请求计算响应
            String response = process(request);
            //将计算后的响应数据一个传入新创建的数据报 参数有 字节数组 字节数组长度 数据报的发送地址
            DatagramPacket responsePacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    requestPacket.getSocketAddress());
            // 3.把响应写回给客户端 以数据包形式
            socket.send(responsePacket);
            // 4.打印日志
            System.out.printf("[%s:%d] request=%s response=%s\n",requestPacket.getAddress().toString(),
                    responsePacket.getPort(),request,response);
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        //设置服务器的端口号为9090
        MyServer server = new MyServer(9090);
        server.start();
    }

}

客户端程序

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

//客户端程序
public class MyClient {
    private DatagramSocket socket = null;
    //服务器IP
    private String serverIp =null;
    //服务器端口
    private int serverPort = 0;

    //构造方法 参数为服务器IP和服务器端口号
    public MyClient(String IP,int port) throws SocketException {
        //客户端端口号不需要手动指定 由系统自动分配
        socket = new DatagramSocket();
        this.serverIp = IP;
        this.serverPort = port;
    }
    //客户端启动程序
    public void start() throws IOException {
        System.out.println("客户端启动!");
        Scanner sc = new Scanner(System.in);
        while(true) {
            // 1.将客户端的请求数据发给服务器
            System.out.print("->");
            String request = sc.next();
            //创建数据报 将请求数据以字节流形式装入包中
            //因为是充当发送的数据报 所以数据包中要有 数据+发送目的地
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,InetAddress.getByName(serverIp),serverPort);
            //将数据报发送给服务器
            socket.send(requestPacket);
            // 2.接收服务器响应回的数据
            //再创建一个空的数据包接收服务器返回的数据
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            //接收服务器返回的响应
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            System.out.println(response);
        }
    }
    public static void main(String[] args) throws IOException {
        //参数为服务器IP地址和端口号
        MyClient client = new MyClient("127.0.0.1",9090);
        client.start();
    }
}

总结

基于UCP协议的话：服务器和客户端之间的来回receive和send都是以数据包形式传递数据所以要经常创建数据包。数据包中可包含数据发送的目的地。充当发送的数据包中是要有发送的地址的，充当接收的数据包要预先创建一个空的数据包。这就是两种方式下数据包的不同的用法。

上述代码中的几个细节：

1.既然说Socket是文件，为啥使用完后不进行close操作呢？不怕文件资源泄露吗？

原因是Socket在整个程序的运行过程中都是需要使用的，并且也没有去频繁地打开文件。我们都知道打开文件，就会占用一个文件描述符表，造成文件资源泄露的原因也是因为文件描述符表满了。而文件描述符表又是在PCB上的，当整个程序运行结束，进程结束了，PCB就会还给操作系统，被销毁，那么文件描述符也就会被回收。

文件资源泄露的原因：在一个程序中，频繁地打开文件而不去关闭。会使文件描述符表满。

2.服务器和客户端的端口号都需要手动添加吗？

服务器端口号需要手动指定添加，而客户端端口号不需要指定。
因为服务器是在程序员手里的，是可控的，而不同的用户，其电脑上下载的程序，占用的端口号都不同，如果给客户端去指定端口号可能会引发冲突。而最好的做法是让系统去自动分配一个端口号，这样就可以保证分配的这个端口号一定是不冲突的。

3.这段代码服务器和客户端各自的工作流程？

服务器先启动，启动之后，就会进入while循环，执行到receive这里，若是未收到客户端的请求，就会一直阻塞，直到客户端有请求发送过来，才会继续往下执行。
客户端后启动，也先进入while循环，执行.next()，等待用户输入请求，这里也会阻塞等待。当用户输入请求后，以字节形式封装进数据报，将请求数据包发送(send)给服务器。然后继续往下执行到receive(接收)处，等待服务器响应。
服务器接收(receive)到请求后，将接收到的数据报里的数据又从字节流转成(解析成)字符串，再执行process操作来处理请求，处理完成后，先将响应数据转成字节数组，再封装入数据报，再返回给客户端。
客户端收到响应后，从receive处向下执行，再次将数据包中的数据解析成字符串并进行打印。
服务器执行完一次循环后，又执行到receive这里，等待客户端的请求。客户端执行完一次循环后，又执行到next()这里，等待用户输入请求。也就是双双进入阻塞。

4.为啥接收数据的时候需要提前手动创建一个有大小的数据报？

因为DatagramPacket不能自己分配内存。因此需要提前手动创建好一个字节数组和长度。

基于上述代码再写一个简单的翻译器程序(继承)


import java.io.IOException;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

public class udpTranServer extends udpServer{
    private Map<String,String> map = new HashMap<>();
    public udpTranServer(int port) throws SocketException {
        super(port);
        map.put("cat","猫");
        map.put("dog","狗");
        map.put("tiger","老虎");
        //......
    }

    //重写process方法 服务器处理请求
    @Override
    public String process(String request) {
        //英译汉
        String response = map.getOrDefault(request,"没有这个单词!");
        return response;
    }

    public static void main(String[] args) throws IOException {
        udpTranServer server = new udpTranServer(9090);
        server.start();
    }
}

3.基于TCP的Socket API

有两个关键的类：

ServerSocket：只给服务器使用，用来绑定端口号。

Socket：既给服务器用，也给客户端用，用来接收(receive)和发送(send)数据(字节流)。

常用的四个方法：

得到对端的网络地址和端口号

得到本地的网络地址和端口号

由于TCP是面向字节流的，以字节为基本单位。所以传输过程中就会用到InputStream和OutputStream流进行接收和发送。通过InputStream进行read操作，就是接收，通过OutputStream进行write操作，就是发送。

服务器

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

//服务器
public class tcpServer {

    private ServerSocket serverSocket = null;
    public tcpServer(int port) throws IOException {
        //服务器手动指定端口号
        serverSocket = new ServerSocket(port);
    }

    //这个方法用来启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while(true) {
            //服务器接收请求
            Socket requestSocket = serverSocket.accept();
            //先需要建立连接 细节流程是由内核完成的 只需要调用即可
            processConnection(requestSocket);
        }
    }

    private void processConnection(Socket requestSocket) throws IOException {
        //打印日志
        System.out.printf("[%s:%d] 上线啦! %s\n",requestSocket.getInetAddress(),requestSocket.getPort());
        //处理请求
        try(InputStream is = requestSocket.getInputStream();
            OutputStream os = requestSocket.getOutputStream()) {
            Scanner sc = new Scanner(is);
            PrintWriter writer = new PrintWriter(os);
            while(true) {
                // 字节流转字符流
                // 先读 Scanner
                if (!sc.hasNext()) {
                    System.out.printf("[%s:%d] 下线啦!\n",requestSocket.getInetAddress(),requestSocket.getPort());

                    break;
                }
                String request = sc.next();
                // 处理请求
                String response = process(request);
                //打印日志
                System.out.printf("[%s:%d] req=%s res=%s\n",requestSocket.getInetAddress(),requestSocket.getPort(),request,response);

                // 将请求处理结果返回给客户端
                // 再写 PrintWriter 或者将 字符串转成字节数组
                writer.println(response);
                // 字符串转成字节数组
                // os.write(response.getBytes());
                // 刷新缓冲
                writer.flush();
                // os.flush();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            requestSocket.close();
        }

    }

    private String process(String request) {
        //这里负责处理请求并返回响应
        return request;
    }

    public static void main(String[] args) throws IOException {
        tcpServer server = new tcpServer(9090);
        server.start();
    }
}

客户端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

//客户端
public class tcpClient {
    Socket socket = null;
    //需要明确访问服务器的IP地址和端口号
    public tcpClient(String serverIp,int serverPort) throws IOException {
        //具体链接的细节，不需要我们手动干预，内核自动负责
        //当我们new这个对象的时候，操作系统就进行三次握手 具体细节，完成建立的细节
        socket = new Socket(serverIp,serverPort);
    }
    public void start() {
        System.out.println("客户端启动!");
        Scanner sc = new Scanner(System.in);
        try(InputStream is = socket.getInputStream();
            OutputStream os = socket.getOutputStream()) {
            Scanner res = new Scanner(is);
            PrintWriter writer = new PrintWriter(os);
            while(true) {
                System.out.print("->");
                String request = sc.next();
                //将请求以字节流形式发送给服务器
                //os.write(request.getBytes());
                writer.println(request);
                //刷新缓冲区
                writer.flush();
                //os.flush();
                //接收服务器传回来的响应
                //传回来的是字节流 进一步要转成字符流
                String response = res.next();
                System.out.println(response);

            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) throws IOException {
        tcpClient client = new tcpClient("127.0.0.1",9090);
        client.start();
    }
}

服务器程序的问题

问题一：为啥光Socket对象要进行close操作而ServerSocket不用close，为啥这个会资源泄露？

原因是这个对象在while循坏中，每次有一个客户端来请求都会创建一个，这个Socket对象也就会占据文件描述符的位置，久而久之，不及时关闭就会造成文件资源泄露，而同一个代码中ServerSocket不用close，是因为它的对象只有一个，且生命周期贯穿整个程序。

但是我们不是加了try()语句吗，这种语句形式不是会自动关闭的吗？

原因是这只是关闭了Socket对象自带的流对象，本身本体Socket对象并没有被关闭。

问题二：上面这种代码如果启动多个客户端会有什么问题，如何解决？

虽然客户端是多个，但其实进线程只有一个。最先启动的客户端是可以正常交互的。而后面启动的这些客户端没有响应。并且当第一个客户端结束后，第二个又可以正常运行，并且会将之前积压的请求由服务器全部正常处理。以此类推，即同一时间只能正常运行一个，仿佛是其他客户端都在等待自己的前一个客户端结束后才活过来。这是与我们服务器的代码逻辑有关，在代码中，我们有两层嵌套while(true)循环，这样第一个客户端上线后，进程就会阻塞在里面的while循环的判断语句hasNext这块，还是上面所说的虽然客户端是多个，但其实线程只有一个。所以只有这个用户下线后，里面的while循环才能跳出来，继续执行。

解决办法：使用多线程并发执行。

1. 把连接操作放在Thread里

这样会有效，但是这样每个客户进来，都会创建一个线程，如果客户端多了，并且频繁地建立连接/断开连接，就会频繁地创建和销毁线程，开销就会很大。还可以采用线程池(2)。

2. 采用线程池

线程池的方式虽然可以降低线程的频繁创建与销毁的开销。但如果同一时刻大量用户进行访问，线程池也要同时创建多个线程，也会招架不住。还可以采用协程(3)或IO多路复用(4)。

3.协程

4.IO多路复用/IO多路转接

IO多路复用/IO多路转接：用一个线程可以同时处理多个客户端的Socket。在Java中是NIO，其底层就是IO多路复用。

代码如下：

只需要改服务器程序。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//服务器
public class tcpServer {

    private ServerSocket serverSocket = null;
    //使用线程池 保证多个客户端正常运行
    ExecutorService service = Executors.newCachedThreadPool();
    public tcpServer(int port) throws IOException {
        //服务器手动指定端口号
        serverSocket = new ServerSocket(port);
    }

    //这个方法用来启动服务器
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while(true) {
            //服务器接收请求
            Socket requestSocket = serverSocket.accept();
            //先需要建立连接 细节流程是由内核完成的 只需要调用即可

            //第一种 最简单的多线程处理
            /*
            Thread thread = new Thread(() -> {
                try {
                    processConnection(requestSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            thread.start();

             */
            //第二种 线程池
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(requestSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
            //协程和IO多路复用以后实现
        }
    }

    private void processConnection(Socket requestSocket) throws IOException {
        //打印日志
        System.out.printf("[%s:%d] 上线啦! \n",requestSocket.getInetAddress(),requestSocket.getPort());
        //处理请求
        try(InputStream is = requestSocket.getInputStream();
            OutputStream os = requestSocket.getOutputStream()) {
            Scanner sc = new Scanner(is);
            PrintWriter writer = new PrintWriter(os);
            while(true) {
                // 字节流转字符流
                // 先读 Scanner
                if (!sc.hasNext()) {
                    System.out.printf("[%s:%d] 下线啦!\n",requestSocket.getInetAddress(),requestSocket.getPort());

                    break;
                }
                String request = sc.nextLine();
                // 处理请求
                String response = process(request);
                //打印日志
                System.out.printf("[%s:%d] req=%s res=%s\n",requestSocket.getInetAddress(),requestSocket.getPort(),request,response);

                // 将请求处理结果返回给客户端
                // 再写 PrintWriter 或者将 字符串转成字节数组
                writer.println(response);
                // 字符串转成字节数组
                // os.write(response.getBytes());
                // 刷新缓冲
                writer.flush();
                // os.flush();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            requestSocket.close();
        }

    }

    private String process(String request) {
        //这里负责处理请求并返回响应
        return request;
    }

    public static void main(String[] args) throws IOException {
        tcpServer server = new tcpServer(9191);
        server.start();
    }
}