计算机网络 - 网络通信 (TCP与UDP)

最新推荐文章于 2024-08-22 20:31:49 发布
最新推荐文章于 2024-08-22 20:31:49 发布
阅读量543 收藏
点赞数
分类专栏： 计算机网络 文章标签： 计算机网络 java 后端 软件工程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69119792/article/details/130187116
版权
本文介绍了网络通信中的套接字概念，对比了TCP与UDP的主要特点，包括无连接、不可靠传输等，并详细讲解了UDP的DatagramSocket和DatagramPacketAPI，以及如何使用它们模拟实现UDP回显服务器和客户端。同时，也概述了TCP的ServerSocket和SocketAPI，为TCP回显程序的实现奠定了基础。
摘要由CSDN通过智能技术生成

前言

本篇通过了解套接字，TCP与UDP协议的特点，使用UDP的api套接字与TCP的api套接字进行回显程序的网络通信，如有错误，请在评论区指正，让我们一起交流，共同进步！

文章目录


本文开始

1. 认识网络通信需要的套接字 - socket

1.1 认识套接字
套接字：应用层调用传输层，操作系统内核给应用层提供一组用来网络编程的api，这就称为 socket api = 套接字api;

针对TCP与UDP协议，这里主要认识关于UDP的api 与 TCP的api 来用于网络通信；
认识api先认识 TCP 与 UDP 的特点吧！

1.2 TCP 与 UDP的主要特点
UDP：

① 无连接：使用UDP通信，双方不需要保存对端（客户端与服务器）的信息；
例如：发短信，不需要记录对方的电话，对方也不需要记录你的电话 (不用建立连接)，直接根据电话号直接发送信息；
② 不可靠传输：一方发送消息，不需要知道另一方是否接收到了信息；
③ 面向数据报：以一个UDP数据报为基本单位读写数据；- 有限制；
④ 全双工：一条路径双向通信；
【注】有无连接：通信双方是否记录对方的信息；
有连接：通信双方需要记录对方的信息；
无连接：通信双方不需要记录对方的信息；

TCP：

① 有连接：使用TCP通信，双方需要保存对端的信息；
例如：打电话，一方打电话，另一方需要接通电话 (建立连接)，双方才能通信；
② 可靠传输：一方发送信息，尽量保证信息发送到了另一方（但也不能保证一定成功，只是尽全力）；
③ 面向字节流：以一个字节为传输基本单位 - 读写数据比较灵活
④ 全双工：双向通信；
【注】半双工：在一条路径上，A方向B方发送消息，B只能等待A发完消息后才能向A发送信息；
全双工：A向B发送消息的同时，B也可以向A发送消息；

2. UDP的api

认识socket对象：
socket 是系统中一个特殊的文件进行网络通信，需要socket文件对象，通过socket文件对象，间接操作网卡；

2.1 DatagramSocket

Datagram: 数据报；Socket: socket对象；

在这里插入图片描述
构造方法：
在这里插入图片描述

【注】socket对象可以被客户端 与 服务器使用；服务器使用socket需要指定关联一个端口号 - 端口号不变才能方便客户端找到服务器；客户端使用socket不需要手动指定，系统会自动分配空闲的端口号；

2.2 DatagramPacket

DatagramPacket: udp数据报对象；

在这里插入图片描述
构造方法
在这里插入图片描述

2.3 根据DatagramSocket 与 DatagramPacket 模拟网络通信

回显程序：自己给自己发送并接收信息；

1.模拟实现UDP回显服务器

服务器的核心工作：
① 读取客户端请求并解析
② 根据请求计算响应
③ 把响应写回到客户端

首先构造socket对象，从而间接操作网卡进行读取；
再构造带有一个参数的构造方法，给服务器分配端口；

	private DatagramSocket socket = null;
    //绑定端口号不一定会成功；- 端口号可能被别的进程占用
    //同一主机，同一时刻，一个端口只能被一个进程所占用
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

服务器主要逻辑过程：
① 读取客户端请求：使用receive()方法, 需要构造requestPacket数据报把数据读取到数据报中；
② 知道客户端输入的是字符，为方便操作将数据报(字节数组)构造为字符串；
③ 根据请求计算具体响应 - 根据具体情况修改；
④ 将响应发送回客户端，根据响应是字符串，构造数据报此时需要指定客户端的IP和端口；

public void start() throws IOException {
        System.out.println("服务器启动！");
        //服务器执行不可能只执行一个请求，需要执行多个请求就用到了循环
        while (true) {
            //1.读取客户端请求
            DatagramPacket requestPacket = new DatagramPacket(new byte[5000],5000);
            //receive时输出型参数：在其中传入空的packet对象，然后receive方法内部就会把参数packet填充；
            // -》从网卡读取内容，写的数据报中；
            socket.receive(requestPacket);//服务器先启动，如果此时没有客户端请求，就会阻塞等待，等待客户端发送数据过来；
            //解析 -> 此处为了方便后续操作，拿字节数组构造成字符串
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //getLength ： 获取真实长度；
            //2.根据请求计算响应
            String response = process(request);
            //3.把响应写回客户端 - 写回网卡
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes(StandardCharsets.UTF_8).length,
                    //requestPacket是客户端得到的，getSocketAddress得到的就是客户端的IP和端口
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //4.打印日志
            System.out.printf("[%s : %d] request: %s, response: %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);
        }
    }
    //回显服务器，写什么，就返回什么；
    // 以后有其他服务器，可以根据具体请求重新构造响应；
    private String process(String request) {
        return request;
    }

【注】receive时输出型参数：在其中传入空的packet对象，然后receive方法内部就会把参数packet填充；

服务器总代码：

public class UdpEchoServer {
    private DatagramSocket socket = null;
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            //1.读取客户端请求
            DatagramPacket requestPacket = new DatagramPacket(new byte[5000],5000);
            socket.receive(requestPacket);
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            //2.根据请求计算响应
            String response = process(request);
            //3.把响应写回客户端 - 写回网卡
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes(StandardCharsets.UTF_8).length,
            requestPacket.getSocketAddress());
            socket.send(responsePacket);
            //4.打印
            System.out.printf("[%s : %d] request: %s, response: %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);
        }
    }
    private String process(String request) {
        return request;
    }

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

2.模拟实现客户端

首先构造socket对象，方便操作读取网卡；
再构造带两个参数的构造方法：指定服务器的IP和端口，让客户端容易找到服务器；

public class UdpEchoClient {
	private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;
    //客户端启动需要知道服务器的位置，根据服务器的IP和端口
    public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        //客户端不用指定端口，会自动分配空闲端口；
        socket = new DatagramSocket();
        //为了方便之后使用
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }
}

客户端执行逻辑：
① 等待客户端输入请求；
② 把请求发送给服务器，需构造数据报并指定服务器IP和端口；
③ 客户端接收响应，构造数据报使用receive()接收；
④ 打印响应结果，再将数据报转换为字符串
代码如下：

     public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        //多次交互
        while (true) {
            System.out.print(" -> ");
            //1.等待控制台输入
            String request = scanner.next();
            //2.把请求发送到服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
            //通过静态发送InetAddress设置IP地址；        
            InetAddress.getByName(serverIP),serverPort);
            socket.send(requestPacket);
            //3.客户端接收响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[5000],5000);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            //4.打印日志
            System.out.printf("request: %s, response: %s\n", request,response);
        }
    }

【注】构造数据报DatagramPacket requestPacket：请求的起始0位置和请求的最后长度length; 需要服务器的IP和端口；
区别：SocketAddress：包含IP和端口；InetSocketAddress设置 IP 再单独设置端口；

客户端总代码：

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;
    //客户端启动需要知道服务器的位置，根据服务器的IP和端口
    public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        //客户端不用指定端口，会自动分配空闲端口；
        socket = new DatagramSocket();
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }
    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        //多次交互
        while (true) {
            System.out.print(" -> ");
            //1.等待控制台输入
            String request = scanner.next();
            //2.把请求发送到服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(serverIP),serverPort);
            socket.send(requestPacket);
            //3.客户端接收响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[5000],5000);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
            //4.打印日志
            System.out.printf("request: %s, response: %s\n", request,response);
        }
    }

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

客户端与服务器的网络通信过程：
① 服务器先启动，执行到receive方法后就进行阻塞，等待客户端传输数据 / 请求；
② 客户端运行，等待控制台输入数据并读取，包装成数据报后发送send() 给服务器；
③ 客户端发送数据报后，继续向下执行，到receive方法会阻塞等待服务器返回响应；
     在客户端发送请求后的后的同时，服务器会读取客户端的请求，根据请求生成响应，把响应包装成数据报再次send发送给客户端，并打印日志；
④客户端收到服务器的响应，就会解除receive的阻塞，把响应转换为字符串进行打印；
      此时服务器会进入下一轮循环，再次等待新的客户端请求；
⑤ 客户端打印完，进入下一轮，再次等待控制台输入新的数据请求；
【注】本机IP地址：127.0.0.1; - 自己与自己发信息；

3. TCP的api

3.1 ServerSocet

ServerSocket: 服务器使用的
ServerSocket构造时需要让服务器绑定一个指定的端口，方便客户端能够找到；

在这里插入图片描述
构造方法：
在这里插入图片描述

3.2 Socket

Socket: 服务器 和 客户端都可以使用

在这里插入图片描述
构造方法
在这里插入图片描述

3.3 模拟实现TCP回显程序

3.3.1 模拟实现回显服务器
了解InputStream, OutputStream操作字节流对象；
InputStream: 读数据，相当于从网卡读数据；
OutputSteam: 写数据，相当于从网卡发送数据；

首先类TcpEchoServer, 类中创建ServerSocket变量，方便以后操作网卡读取数据；
构造一个参数的构造方法，构造serverSocket对象并指定端口号；

public class TcpEchoServer {
    private ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
    	//与之前的UDP的DatagramSocket中的socket一样，需要绑定端口
        serverSocket = new ServerSocket(port);
    }
}

然后服务器中的主逻辑：
① 先调用serverSocket的accept方法，等待与客户端建立连接

在这里插入图片描述

② 建立连接后，执行客户端连接的方法processConnectin();

核心逻辑代码：

public void start() throws IOException {
        System.out.println("服务器启动！");
        while (true) {
            //监听，看绑定的端口是否有客户端连接，如果连接accept就会马上返回Socket对象
            Socket clientSocket = serverSocket.accept();
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
            t.start();
        }

为什么使用线程呢？
服务器启动后，如果不使用线程，当一个客户端占用processConnection(clientSocket)方法，有其他客户端想要再次使用processConnection(clientSocket)方法，就需要一直等待；使用多线程，来一个客户端就创建一个新线程来执行processConnection(clientSocket)方法，就可以多线程使用了；

优化为线程池：
线程的频繁创建和销毁也会带来资源销毁，这里可以优化为线程池；将线程放入线程池，减少线程的创建和销毁；

public void start() throws IOException {
        System.out.println("服务器启动！");
        ExecutorService executorService = Executors.newCachedThreadPool();
        while (true) {
            //监听，看绑定的端口是否有客户端连接，如果连接accept就会马上返回Socket对象
            Socket clientSocket = serverSocket.accept();
           executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }

processConnection(clientSocket)方法具体执行内容：
代码逻辑：
① 读取数据需要对网卡的操作，就用到了InputStream，OutputStream; - try() 中允许写多个流对象；
② 上述字节流，不能清楚读取到哪是一个请求；这里约定服务器是字符串请求，请求之间用\n分隔，所以包装为字符流Scanner , PrintWrite 方便读写数据; - 根据具体情况可更改；
③ 执行客户端请求，与UDP相似，但这里需要判断客户端是否断开连接使用hasNext()方法;
【注】 根据请求计算完响应，发送响应时也应该带上 \n 让客户端分清楚请求 - 使用println加 \n ；（客户端也一样）
clientSocket 是文件，不用了需要关闭；而ServerSocket不需要，它的生命周期长；（循环创建clientSocket，有一个客户端就创建一个，为防止文件资源泄露，需要close()关闭一下文件；）

代码如下：

private void processConnection(Socket clientSocket) {
        System.out.printf("客户端上线！[%s : %d]\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        try(InputStream inputStrem = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            //为了后续操作，字节流包装为字符流 - 可根据具体情况修改；
            Scanner scanner = new Scanner(inputStrem);
            PrintWriter printWriter = new PrintWriter(outputStream);
            //执行具体请求
            while (true) {
                //1.读取客户端请求
                //判断客户端是否关闭了
                if(!scanner.hasNext()) {
                    System.out.printf("客户端下线！[%s : %d]\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                //scanner.next读取换行结束，读取一段请求；
                String request = scanner.next();
              // 读到空白符结束；空白符：\n，空格，制表符；
                //2.根据请求做出响应
                String response = process(request);
                //3.返回响应，响应中加上\n，上述读取一段请求时next不读取\n,这里发送时需要加上;
                printWriter.println(response);
                printWriter.flush();//刷新，将缓冲区数据立即发送
                //4.打印日志
                System.out.printf("[%s : %d] request: %s, response: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(), request, response);

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

为什么InputStream，OutputStream;写到try括号里？
放在try()中，InputStream，OutputStream最后会自动关闭，不用手动close;

为什么需要printWriter.flush() ?
发送的数据，先会写入内存的发送缓冲区，等到缓冲区满了，才会写入网卡；这里使用flush(), 使数据立即写入网卡，不用等待缓冲区满；- 客户端与服务器相同，都需要手动flush()一下；

3.3.2 模拟实现客户端

首先创建TcpEchoClient类，类中创建Socekt操作网卡，创建两个参数的构造方法，让客户端能够找到服务器，与服务器来连接；

public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String rerverIP, int port) throws IOException {
        socket = new Socket(rerverIP,port);
    }
}

核心逻辑代码：
与UDP类似；

public void start() {
        Scanner scanner = new Scanner(System.in);
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            //包装为字符流
            PrintWriter printWriter = new PrintWriter(outputStream);
            Scanner scFromSocket = new Scanner(inputStream);//读取网卡请求
            while (true) {
                //1.等待控制台输入
                System.out.println(" --> ");
                String request = scanner.next();//这里next以分隔符\n来分隔每段请求
                //2.发送请求给服务器
                printWriter.println(request);
                printWriter.flush();
                //3.接收服务器响应
                String response = scFromSocket.next();//读取字符流读取字符
                //4.打印日志
                System.out.printf("[%s : %d] request: %s, response: %s\n",socket.getInetAddress().toString(),
                        socket.getPort(),request,response);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

TCP客户端-服务器执行过程：
① 服务器先启动，阻塞在accept()，等待客户端连接
② 客户端启动，调用构造方法与服务器建立连接，此时服务器中accept()返回Socket对象；
③ 服务器执行processConnection方法，阻塞到读取客户端请求；
而客户端在调用构造方法后一直往下执行，阻塞等待用户输入，用户输入后读取数据；
④ 客户端读取用户数据发送给服务器，执行到要读取客户端响应后阻塞等待服务器返回响应；
⑤ 服务器接收请求后，读取请求，计算响应，并返回响应；
⑥ 服务器发送响应后重写循环等待下一轮客户端连接；
客户端收到响应，打印结果，再次循环，等待控制台输入；

TCP 客户端总代码：

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("服务器启动！");
        ExecutorService executorService = Executors.newCachedThreadPool();
        while (true) {
            //监听，看绑定的端口是否有客户端连接，如果连接accept就会马上返回Socket对象
            Socket clientSocket = serverSocket.accept();
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("客户端上线！[%s : %d]\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        try(InputStream inputStrem = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            //为了后续操作
            Scanner scanner = new Scanner(inputStrem);
            PrintWriter printWriter = new PrintWriter(outputStream);
            //执行具体请求
            while (true) {
                //1.读取客户端请求
                //判断客户端是否关闭了
                if(!scanner.hasNext()) {
                    System.out.printf("客户端下线！[%s : %d]\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort());
                    break;
                }
                String request = scanner.next();
                //2.根据请求做出响应
                String response = process(request);
                //3.返回响应
                printWriter.println(response);
                printWriter.flush();
                //4.打印日志
                System.out.printf("[%s : %d] request: %s, response: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(), request, response);

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

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

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

总结

✨✨✨各位读友，本篇分享到内容如果对你有帮助给个👍赞鼓励一下吧！！
感谢每一位一起走到这的伙伴，我们可以一起交流进步！！！一起加油吧！！！

Wpa.wk
关注
专栏目录
TCP和UDP通信
时间在流
12-08 197
UDP /* * 文件发送发送端: * 1.定义发送端 * 2.从文件中读入数据,字节数组 * 3.打包 * 4.发送 * 5.关闭 */ public class FileClient01 { public static void main(String[] args) throws IOException { System.out.println("-------...
计算机网络 --- TCP与UDP协议
HelloWorld
08-24 1万+
UDP协议 TCP协议 TCP建立连接的三次握手 TCP连接释放的四次挥手 TCP的可靠传输 -- 滑动窗口 TCP的拥塞避免算法 如何理解TCP/IP协议是面向数据流的，而UDP协议是面向数据报
传输层协议TCP和UDP协议
码里奥的博客
03-14 374
TCP和UDP协议TCP协议1、TCP报文段UDP协议TCP的“三次握手”和“四次挥手”1.三次握手2.四次挥手 TCP协议 TCP 协议是面向连接的、可靠的进程到进程通信的协议。TCP提供全双工服务，每一个TCP都有发送缓存和接收缓存，用来临时存储数据。 1、TCP报文段 TCP将若干字节构成一个分组，称为报文段。TCP报文段封装在IP数据报中。 1.源端口号：发送方进程对应的端口号。 2.目标端口号：对应的是接收端的进程的端口号。 3.序号：发送端为每个字节进行编号，便于接受端正确重组。 4.确认号
tcp 和udp通信
最新发布
m0_63897134的博客
08-22 1029
该函数通常与无连接的数据报服务（如 UDP）一起使用，但也可以与其他类型的套接字使用。与简单的 recv() 函数不同，recvfrom() 可以返回数据来源的地址信息。struct sockaddr ////通用地址结构 --- ip + 端口。src_addr：一个指针，指向一个 sockaddr 结构，用于保存发送数据的源地址。-----好 ---------------->-----好 ---------------->在成功的情况下，recvfrom() 返回接收到的字节数。
TCP/UDP网络的通信
vivtor_的博客
09-09 1779
tcp 和udp通信的架构以及实现
TCP/UDP 网络通信
bemy1008的博客
11-16 196
转自：https://www.cnblogs.com/ydjy/p/3942437.html C++ 利用socket实现TCP，UDP网络通讯 学习孙鑫老师的vc++深入浅出，有一段时间了，第一次接触socket说实话有点儿看不懂，第一次基本上是看他说一句我写一句完成的，第二次在看SOCKET多少有点儿感觉了，接下来我把利用SOCKET完成TCP和UDP两种通讯模式的流程和代码分享一下，希望对大家多少能有点儿帮助，有什么说的不对的欢迎各位大神指正。 TCP TCP是点对点的通讯模式，数据传输质量高，对
数据通信与计算机网络-TCP与UDP.pptx
10-29
数据通信与计算机网络是信息技术领域的核心组成部分，其中TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）是传输层的两种主要协议，它们在确保数据在互联网上传输时扮演着关键角色。...
计算机网络--TCP+UDP.zip
07-10
计算机网络是信息技术的基础，其中TCP（传输控制协议）和UDP（用户数据报协议）是两种主要的传输层协议，它们在互联网通信中扮演着至关重要的角色。本资料包聚焦于TCP与UDP的区别、TCP的三次握手与四次挥手过程以及...
TCP-UDP程序 _TCP/UDP通信程序_
10-04
在计算机网络中，TCP（传输控制协议）和UDP（用户数据报协议）是两种主要的传输层协议，它们各自有着不同的特性和应用场景。本篇将深入探讨TCP与UDP的通信程序设计及其工作原理。 首先，TCP是一种面向连接的、可靠...
桂电-计算机网络实验4-TCPUDP协议分析
12-14
计算机网络实验4主要聚焦于TCP和UDP协议的分析，旨在帮助学生深入理解TCP报文的结构和通信机制。实验中，学生将利用头歌Linux虚拟机桌面系统、网络报文分析工具Wireshark以及Firefox浏览器来追踪和分析TCP应用的通信...
TCP 和 UDP网络通讯技术
随心漂流的博客
06-08 623
TCP和UDP基本编程步骤： TCP: 服务器端： 　　1、创建一个socket，用函数socket()； 　　2、设置socket属性，用函数setsockopt(); (可选) 　　3、绑定IP地址、端口等信息到socket上，用函数bind(); 　　4、开启监听，用函数listen()； 　　5、接收客户端上来的连接，用函数accept()； 　　6、收发数据，用函数send()和recv()，或者read()和write(); 　　7、关闭网络连接； 　　8、关闭监听； 客户
网络通信TCP/UDP
xurongxin2006的博客
10-25 806
是一种不建立连接，不能够保证数据无丢失，无重复的通讯方式。返回值：成功返回一个文件描述符，失败返回-1。等）的参数传入的时候转换成 sockaddr。返回值：成功返回接收到的字节的个数，失败返回。如果不绑定，系统会自动分配一个端口号。返回值：成功返回发送的字节数，失败返回。通信是不连接的，不可靠的通信方式。通常的做法是：填值的时候使用。（）函数，取消端口号绑定限制。先运行服务器，再运行客户端。同时连接的客户端的最大数量。结构，而作为函数（如。结构就行了，毕竟都是。、三次握手与四次握手。
TCP通信 、 UDP通信
热门推荐
羽翼冰蓝
07-04 5万+
1. TCP通信 1.1. Socket通讯模型 1.1.1. Server端多线程模型 通过上一节我们已经知道了如何使用ServerSocket与Socket进行通讯了，但是这里存在着一个问题，就是只能“p2p”点对点。一个服务端对一个客户端。若我们想让一个服务端可以同时支持多个客户端应该怎么做呢？这时我们需要分析之前的代码。我们可以看到，当服务端的ServerSocket通过accept
TCP与UDP
qq_40769484的博客
06-05 260
TCP与UDP 1．TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议 2．UDP（用户数据报协议）是一种无连接的、不可靠的、基于数据报的传输层通信协议
UDP和TCP通信
super_jackey的博客
07-14 441
“打电话”TCP:TransmissionControl Protocol,即传输控制协议面向连接、可靠传输（发送应答、超时重传、错误校验、流量控制和阻塞管理）和效率较低。 注意点1.tcp服务器一般情况下都需要绑定，否则客户端找不到这个服务器；2.tcp客户端一般不绑定，因为是主动链接服务器，所以只要确定好服务器的ip、port等信息就好，本地客户端可以随机；3.tcp服务器中通过listen可...
计算机网络——TCP/UDP
漫长IT路
08-09 491
文章目录1. TCP保证可靠性：1.1 序列号、确认应答、超时重传1.2 窗口控制与高速重发控制/快速重传（重复确认应答）1.3 拥塞控制2. TCP建立连接和断开连接的过程：2.1 建立连接/三次握手2.2 断开连接/四次挥手2.3 三次握手原因2.4 四次挥手原因3. TCP/IP模型四层TCP/IP模型七层ISO模型4 HTTP/HTTPS区别如下：4.1 HTTPS优点：4.2 HTTPS缺点：4.3 HTTP4.3.1 返回码4.3.2 常见状态代码5. IP/MAC地址相关例题1.例。搜索bai
TCP与UDP(非常详细)
好好学习
11-18 6032
TCP/IP模型是一些列协议的总称（TCP，UDP，IP，FTP，HTTP，ICMP，SMTP）。这些协议可以划分为四层：链路层、网络层、传输层、应用层。TCP和UDP都位于计算机网络模型中的运输层，它们主要负责传输应用层产生的数据。。TCP与UDP区别总结：1、TCP传输效率慢、所需资源多，UDP则相反。2、TCP面向连接（打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接3、TCP提供可靠的服务，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;
什么是UDP、TCP,怎么用UDP和TCP实现网络通信和数据传输
weixin_46665411的博客
11-12 3070
网络编程：就是让两台计算机进行数据交互网络编程三要素IP地址：设备在网络中的地址，是唯一的标识端口：应用程序在设备中的唯一标识协议：数据在网络中传输的规则，常见的协议有UDP协议和TCP协议1.IPIP:全称"互联网协议地址"，也称IP地址。是分配给上网设备的数字标签。常见的ip分类为：IPv4和IPv6IPv4:IPv6:由于互联网的蓬勃发展，IP地址的需求量愈来愈大，而IPv4的模式下IP的总数是有限的。采用128位地址长度，分成8组。
TCP与UDP协议详解-计算机网络复习要点
"本资源主要涵盖了TCP和UDP协议的特点，以及计算机网络中的一些核心知识点，包括数据链路层、网络层、运输层的重点内容，互联网的发展历史，以及交换方式的比较等。" 在计算机网络中，TCP（Transmission Control ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值