[JavaEE -- 传输层中UDP和TCP的api实现原理]

传输层中UDP和TCP的api实现原理

  • 1. UDP和TCP协议特点
    • 1.1 TCP
    • 1.2 UDP
  • 2. UDP协议中socket api的使用
    • 2.1 服务器:
    • 线程频繁创建,但是不频繁销毁?
    • 2.2 客户端
    • 2.3 整个流程
  • 3. TCP协议中的api使用
    • 3.1 TCP服务器
    • 3.2 TCP客户端
    • 3.3 整个流程

1. UDP和TCP协议特点

1.1 TCP

  • 有连接:抽象,虚拟的连接(如打电话)
  • 可靠传输:尽可能的完成数据传输,虽然无法确保数据到达对方,至少可以知道,当前数据是不是收到了
  • 面向字节流:此处的字节流和文件中的字节流完全一致
  • 全双工:一个通信可以双向通信。(而半双工只能单向通信)

1.2 UDP

  • 无连接:无论是否同意都会发送
  • 不可靠传输:不确定数据是否能收到
  • 面向数据报:每次传输的基本单位是一个数据报(由一系列的字节构成的)特定结构
  • 全双工

2. UDP协议中socket api的使用

操作系统中有一类文件,就叫做socket文件,抽象表示了 网卡 这样的硬件设备。进行网络通信最核心的硬件设备网卡,通过网卡发送数据,就是写socket文件,通过网卡接收数据,就是读socket文件
核心的类有两个:

  1. DatagramSocket
    DatagramSocket(),创建一个UDP数据报套接字的Socket,绑定到本机任意一个随机接口(一般用于客户端)
    DatagramSocket(port),创建一个UDP数据报套接字的Socket,绑定本机指定的端口(一般用于服务器)
    void receive(DatagramPacket p) :从此套接字接收数据报(如果没有接收数据报,该方法会阻塞等待)
    void send(DatagramPacket p) :从此套接字发送数据报(不会阻塞等待,直接发送)

  2. DatagramPacket
    UDP面向数据报,每次发送数据报的基本单位,就是UDP数据报。表示了一个UDP数据报。

2.1 服务器:

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.charset.StandardCharsets;


public class UdpEchoServer {
	//创建DatagramSocket对象
    private DatagramSocket socket = null;
    public UdpEchoServer(int port) throws SocketException { // 网络编程中常见的异常,通常表示socket创建失败,比如端口号已经被其他进程占用了,就会失败
        socket = new DatagramSocket(port);
    }

    // 服务器启动逻辑
    public void start() throws IOException {
        System.out.println("服务器启动!");
        // 对于服务器来说,需要不停的收到请求,返回响应
        while (true) {
            // 每次循环,就是处理一个请求-响应过程
            // 1. 读取请求并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);// 通过这个字节数组保存收到的消息正文(应用层数据包)也就是UDP数据报载荷部分
            // receive接收从网卡读取到一个UDP数据报,放入requestPacket对象中
            socket.receive(requestPacket);

            // 读到的字节数组,转成String方便后续逻辑处理
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            // 2. 根据请求计算响应(对于 回显服务器来说,这一步啥也不做)
            String response = process(request);
            // 3. 把响应返回到客户端
            //      构建一个DatagramPacket 作为响应对象
            // requestPacket.getSocketAddress()  从requestPacket客户端来的数据报,获得INetAddress对象这个对象就包含了ip和端口号(和服务器通信对端)
            //是把请求中的源ip和源端口作为响应的目的IP和目的端口,此时就可以把消息返回给客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(), response.getBytes().length,
                                        requestPacket.getSocketAddress());
            socket.send(responsePacket);

            //打印日志
            System.out.printf("[%s:%d] req: %s,resp: %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);
        }
    }

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

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

线程频繁创建,但是不频繁销毁?

即每个客户端处理过程都很长(游戏服务器),如果继续使用线程池/多线程,就会导致当前服务器一下积累了大量的线程.
解决方案:

  1. 协程
    轻量级协程,本质上还是一个线程,用户态可以通过手动调度的方式让这一个线程 "并发"的做多个任务
  2. IO多路复用
    系统内核级别的机制,本质上是让一个线程同时去负责处理多个socket,本质在于这些socket数据并非是同一时刻都需要处理.

理解IO多路复用:
通过三人买东西的方式来理解IO多路复用:

  1. 单线程(效率比较低):就是一个人先去买饼,等好了之后再去第二个地方买肉夹馍,等买好了之后再去第三个地方买饺子.
  2. 多线程(效率大大提升了,系统开销也变大了): 三个人分别各自去买一样东西.
  3. IO多路复用(效率不低,系统开销也不高):一个人先去买饼,点完单不等做好再去下一个地方买肉夹馍,同样点完单不等,再去买饺子

IO多路复用:
基本在于,虽然有多个socket但是同一时刻活跃的socket只是少数,(需要读写数据的socket)大部分socket都在等,使用一个线程来等多个socket.

2.2 客户端


import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;


    // 此处的IP使用的字符串,点分十进制,”192.168.2.100“ 不能直接使用serverIp,要InetAddress.getByName(serverIp)
    public UdpEchoClient(String serverIP,int serverPort) throws SocketException {
        this.serverIp = serverIP;
        this.serverPort = serverPort;
        // 客户端一般不要手动指定端口号,系统会自动分配一个空闲的端口号
        socket = new DatagramSocket();
    }
    public void start() throws IOException {
        System.out.println("启动客户端");
        // 从控制台读取,使用scanner读取字符串,最好使用next而不是nextline(如果读取文件就无所谓),
        // 如果使用nextline读取,需要手动输入换行符,enter来控制,由于enter键不仅仅会产生\n,还会产生其他字符,就会导致读取到的内容容易出现问题。
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("-> ");
            // 1. 从控制台读取要发送的请求数据
            if (!scanner.hasNext()) {
                break;
            }
            String request = scanner.next();

            // 2. 构造请求并发送  (把string里面的内容作为请求)
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length
            , InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);

            // 3, 获取服务器响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            // 4. 把响应显示到控制台上
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            System.out.println(response);
        }

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

2.3 整个流程

  1. 服务器启动,启动之后立即进入while循环,执行到receive,进入阻塞等待客户端的请求
  2. 客户端启动之后,阻塞在hasNext等待用户在控制台输入
  3. 用户在客户端输入之后,客户端就拿到字符串构造出一个(requestPacket)请求,send发送请求,然后创建responsePacket来执行receive接收操作并且等待响应返回。
  4. 服务器收到请求之后,就会从receive的阻塞中返回,之后就会根据读到的DatagramPacket对象,构造String request,通过process方法构造一个String response,再根据response构建一个DatagramPacket表示响应对象,再通过send来进行发送给客户端。(这个过程中,客户端在阻塞等待)。
  5. 客户端从receive中返回执行,就能得到服务器返回的响应,并且打印到控制台上,与此同时,服务器进入下一次循环,也要进入到第二次的receive阻塞。等待下一个请求。

3. TCP协议中的api使用

  • ServerSocket:这个socket类对应到网卡,但是这个类只能给服务器进行使用
  • Socket:对应到网卡,既可以给服务器使用,也可以给客户端使用。

TCP是面向字节流的,传输的基本单位是字节,是有连接的,通过accept来完成连接,accept也是可能会产生阻塞的操作,如果当前客户端还没有连接过来,此时accept就会阻塞。

3.1 TCP服务器

//  ServerSocket 这是Socket类对应到网卡,但是这个类只能给服务器使用
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    private ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            // 通过accept方法来”接听电话“,然后才能进行
            Socket clientSocket = serverSocket.accept();
            // 和客户端的交互
            processConnection(clientSocket);
        }
    }

    // 通过这个方法开处理一次连接,连接建立的过程中就会涉及到多次的请求响应交互
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线!\n",clientSocket.getInetAddress(),clientSocket.getPort());
        // 循环的读取客户端的请求并返回响应
        // 从网卡读/写数据,tcp是面向字节流和文件中的字节流完全一致
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()) {
            while (true) {
                Scanner scanner = new Scanner(inputStream);
                if (!scanner.hasNext()) {
                    // 读取完毕,客户端断开连接,就会产生读取完毕
                    System.out.printf("[%s:%d] 客户端下线!\n",clientSocket.getInetAddress(),
                            clientSocket.getPort());
                    break;
                }
                // 1. 读取请求并解析,这里注意隐的约定,next读的时候要读到空白符才会结束
                //  因此就要求客户端发来的请求必须带有空白符结尾,比如 \n 或空格
                String request = scanner.next();
                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 把响应返回给客户端
                //  通过这种方式可以写回,但是这种方式不方便给返回的响应添加 \n
                //outputStream.write(response.getBytes(),0,response.getBytes().length);
                // 也可以把outputStream 套上一层,完成更方便的写入
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                // PrintWriter 内置的缓冲区需要冲刷(刷新)
                // 冲刷缓冲区
                printWriter.flush();

                System.out.printf("[%s:%d] req:%s,resp: %s\n",clientSocket.getInetAddress(),
                        clientSocket.getPort(),request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

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

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

3.2 TCP客户端

// Socket 对应到网卡,既可以给服务器使用,又可以给客户端使用
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 TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIP,int serverPort) throws IOException {
        // 此处可以把这里的ip和port直接传给socket对象
        // 由于tcp是有连接的,因此socket里面就会保存好这俩信息,因此此处TcpEchoClient类就不必保存
        socket = new Socket(serverIP,serverPort);
    }

    public void start() {
        System.out.println("客户端启动!\n");
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) {
            Scanner scannerConsole = new Scanner(System.in);
            Scanner scannerNetwork = new Scanner(inputStream);
            PrintWriter writer = new PrintWriter(outputStream);
            while (true) {
                // 1. 从控制台读取输入的字符串
                System.out.print("-> ");
                if (!scannerConsole.hasNext()) {
                    // 没有下一个
                    break;
                }
                // 有下一个接着读取
                String request = scannerConsole.next();
                // 2. 把请求发给服务器  使用println 来发送的请求末尾带有\n
                //  这里是和服务器的scanner.next 呼应的
                writer.println(request);
                // 通过flush 主动刷新缓冲区,确保数据真的发出去了
                writer.flush();
                // 3.从服务器读取响应
                String response = scannerNetwork.next();
                // 4. 把响应显示出来
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


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

3.3 整个流程

  1. 服务器启动,阻塞在accept,等待客户端连接
  2. 客户端启动,new Socket(ServerIP,ServerPort)操作会触发和服务器之间的建立连接的操作,此时服务器就会从accept中返回
  3. 服务器从accept返回,进入到processConnection方法,执行到hasNext这里,产生阻塞,此时虽然连接建立了,但是客户端还没有发送任何的请求,hasNext阻塞等待请求到达。
  4. 客户端继续执行到hasNext,等待用户向控制台写入内容。
  5. 用户输入之后,此时hasNext就返回了,继续执行这里的发送请求的逻辑,这里就会把请求真的发出去,同时客户端等待服务器的响应返回,next也会产生阻塞。
  6. 服务器从hasNext返回读取到请求内容进行处理,读取到请求,构造出响应,把响应写回到客户端。服务器结束这次循环,继续阻塞在hasNext等待下一个请求。
  7. 客户端读取响应,并且显示出来。结束这次循环,进行下一次循环,继续阻塞在hasNext等待用户输入第二个数据。

你可能感兴趣的:(Java,EE,java-ee,udp,tcp/ip)