如何区分和理解TCP和UDP协议？

最新推荐文章于 2024-06-15 10:58:32 发布

南丘xf

最新推荐文章于 2024-06-15 10:58:32 发布

阅读量904

点赞数

分类专栏：基础

本文链接：https://blog.csdn.net/weixin_39309402/article/details/98126873

版权

基础专栏收录该内容

66 篇文章 2 订阅

订阅专栏

1、TCP与UDP区别总结：

1）TCP面向连接（如打电话要先拨号建立连接）；UDP是无连接的，即发送数据之前不需要建立连接。

2）TCP有保证、靠得住。通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达；UDP尽最大努力交付，即不保证可靠交付。

3）TCP效率慢，UDP实时性好，工作效率比TCP高，适用于高速传输和实时性较高的通信或广播通信。

4）每一条TCP连接只能是点对点；而UDP支持一对一，一对多，多对一和多对多的交互通信。

5）TCP对系统资源要求多，UDP对系统资源要求较少。

2、为什么UDP有时比TCP更有优势?

承上，因为UDP以其简单、传输快的优势（工作效率高），在越来越多场景下取代了TCP,如实时游戏。

1）网速的提升给UDP的稳定性提供可靠网络保障，丢包率很低，如果使用应用层重传，能够确保传输的可靠性。

2）TCP（为了实现网络通信的可靠性）的控制算法复杂，握手过程繁琐，一旦发生丢包，会将后续的包缓存起来，等前面的包重传并接收到后再继续发送，所以会导致延时越来越大，基于UDP对实时性要求较为严格的情况下，采用自定义重传机制，能够把丢包产生的延迟降到最低，尽量减少网络问题对游戏性造成影响。

3、UDP和TCP编程步骤也有些不同，如下：
TCP编程的服务器端一般步骤是：

a、创建一个socket，用函数socket()；

SOCKET SocketListen =socket(AF_INET,SOCK_STREAM, IPPROTO_TCP);

b、设置socket属性，用函数setsockopt();

c、绑定IP地址、端口等信息到socket上，用函数bind();

SOCKET_ERROR = bind(SocketListen,(const sockaddr*)&addr,sizeof(addr))

d、开启监听，用函数listen()；

SOCKET_ERROR == listen(SocketListen,2)

e、接收客户端上来的连接，用函数accept()；

 SOCKET SocketWaiter = accept(SocketListen,_Out_    struct sockaddr *addr_Inout_int *addrlen);

f、收发数据，用函数send()和recv()，或者read()和write();

g、关闭网络连接；

 closesocket(SocketListen);

closesocket(SocketWaiter);

h、关闭监听；

SOCK_STREAM这种的特点是面向连接的，即每次收发数据之前必须通过connect建立连接，而SOCK_DGRAM这种是User Datagram Protocol协议的网络通讯，它是无连接的，不可靠的。

UDP编程的服务器端一般步骤是：

(1)、创建一个socket，用函数socket()；

(2)、设置socket属性，用函数setsockopt();* 可选

(3)、绑定IP地址、端口等信息到socket上，用函数bind();

(4)、循环接收数据，用函数recvfrom();

2.1---DatagramPacket
2.1.1. 创建接收包
DatagramPacket：UDP数据报基于IP建立的,每台主机有65536个端口号可以使用。数据报中字节数限制为65536-8 。包含8字节的头信息。

    DatagramPacket(byte[] buf, int length)  //构造接收包
    DatagramPacket(byte[] buf, int offset, int length) //将数据包中从Offset开始、Length长的数据装进Buf数组

2.1.2. 创建发送包

    //构造发送包
    DatagramPacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)
    //从Buf数组中，取出Offset开始的、Length长的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端
    DatagramPacket(byte[] buf, int offset, int length, InetAddress clientAddress, int clientPort)

2.2---DatagramSocket
2.2.1. 服务端接收
DatagramSocke用于接收和发送UDP的Socket实例。

DatagramSocket(int port)    //创建实例，并固定监听Port端口的报文，通常用于服务端
//其中方法:
receive(DatagramPacket d)   //接收数据报文到d中。receive方法产生 “阻塞”。会一直等待知道有数据被读取到。

2.2.2. 客户端发送
无参的构造方法DatagramSocket()通常用于客户端编程，它并没有特定监听的端口，仅仅使用一个临时的。程序会让操作系统分配一个可用的端口。
其中方法:

send(DatagramPacket dp) //该方法用于发送报文dp到目的地。

代码如下：

package Paint;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * Server端应用程序
 */
public class ServerUDP {
    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket(8088);// 申请8088端口
            byte[] data = new byte[1024];
            DatagramPacket packet = new DatagramPacket(data, data.length);// 创建接收包
            socket.receive(packet);// 会产生阻塞，读取发送过来的数据
            String str = new String(packet.getData(), 0, packet.getLength());// 从包中取数据
            System.out.println(str);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                socket.close();// 关闭释放资源
            }
        }
    }
}

客户端代码如下：

package Paint;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * Client端应用程序
 */
public class ClientUDP {
    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket();// 创建Socket
            byte[] data = "udp--你好服务器!".getBytes();
            DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("localhost"), 8088);// 创建发送包
            socket.send(packet);// 发送数据

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (socket != null) {
                socket.close();// 关闭以释放资源
            }
        }
    }
}

执行结果，如下：

udp通信

------------------------------ Socket ---------------------------------------
1.1简介

socket通常称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄。在Internet上的主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。

应用程序通常通过“套接字”向网络发出请求或者应答网络请求。Socket和ServerSocket类库位于java .net包中。ServerSocket用于服务端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。

1.2获取本地地址和端口号

java.net.Socket为套接字类，其提供了很多方法，其中我们可以通过Socket获取本地的地址以及端口号。


intgetLocalPort()    //该方法用于获取本地使用的端口号

InetAddress getLocalAddress()    //该方法用于获取套接字绑定的本地地址

String getCanonicalHostName()    //使用InetAddress获取本地的地址方法

String getHostAddress()    //获取此 IP 地址的完全限定域名


//返回 IP 地址字符串（以文本表现形式）,代码如下:

publicvoidtestSocket()throwsException{

Socket socket=newSocket("localhost",8088);

InetAddress add=socket.getLocalAddress();//获取本地地址信息

System.out.println(add.getCanonicalHostName());

System.out.println(add.getHostAddress());

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

}

1.3获取远端地址和端口号
Socket也提供了获取远端的地址以及端口号的方法:

int getPort()    //该方法用于获取远端使用的端口号 。
InetAddress .getInetAddress()  //该方法用于获取套接字绑定的远端地址 

//该方法用于获取套接字绑定的远端地址 ，代码如下:
public void testSocket()throws Exception {
            Socket socket = new Socket("localhost",8088);
             InetAddress inetAdd = socket.getInetAddress();
            System.out.println(inetAdd.getCanonicalHostName());
            System.out.println(inetAdd.getHostAddress());
            System.out.println(socket.getPort()); 
        }

1.4. 获取网络输入流和网络输出流
通过Socket获取输入流与输出流是使用Socket通讯的关键方法。封装了TCP协议的Socket是基于流进行通讯的，所以我们在创建了双方连接后，只需要获取相应的输入与输出流即可实现通讯。

 InputStream getInputStream()    //该方法用于返回此套接字的输入流
 OutputStream getOutputStream()  //该方法用于返回此套接字的输出流

public void testSocket()throws Exception {
        Socket socket = new Socket("localhost",8088);
        InputStream in = socket.getInputStream();
        OutputStream out = socket.getOutputStream();
    } 

void close()  //当使用Socket进行通讯完毕后，要关闭Socket以释放系统资源,当关闭了该套接字后也会同时关闭由此获取的输入流与输出流

1.5C-S端通信模型
C-S的全称为(Client-Server):客户端-服务器端,C-S通信模型如下:

C-S通信模型.png

1-服务端创建ServerSocket
2-通过调用ServerSocket的accept方法监听客户端的连接
3-客户端创建Socket并指定服务端的地址以及端口来建立与服务端的连接
4-当服务端accept发现客户端连接后，获取对应该客户端的Socket
5-双方通过Socket分别获取对应的输入与输出流进行数据通讯
6-通讯结束后关闭连接。
代码如下:

package Paint;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Server端应用程序
 */
public class Server {
    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            // 创建ServerSocket并申请服务端口为8088
            server = new ServerSocket(8088);

            // 侦听客户端的连接
            Socket socket = server.accept();

            // 客户端连接后，通过该Socket与客户端交互
            // 获取输入流，用于读取客户端发送过来的消息
            InputStream in = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));

            // 获取输出流，用于向该客户端发送消息
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(out, "UTF-8"), true);

            // 读取客户端发送的消息
            String message = reader.readLine();
            System.out.println("客户端说:" + message);

            // 向客户端发送消息
            writer.println("你好客户端!");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (server != null) {
                try {
                    server.close();
                } catch (IOException e) {
                }
            }
        }

    }
}

package Paint;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * Client端应用程序
 */
public class Client {
    public static void main(String[] args) {
        Socket socket = null;
        try {
            socket = new Socket("localhost", 8088);
            // 获取输入流，用于读取来自服务端的消息
            InputStream in = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));

            // 获取输出流，用于向服务端发送消息
            OutputStream out = socket.getOutputStream();
            OutputStreamWriter osw = new OutputStreamWriter(out, "UTF-8");
            PrintWriter writer = new PrintWriter(osw, true);

            // 向服务端发送一个字符串
            writer.println("你好服务器！");

            // 读取来自客户端发送的消息
            String message = reader.readLine();
            System.out.println("服务器说:" + message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null) {
                    // 关闭Socket
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

启动服务端，然后启动客户端，执行：

现在，我们已经初步知道如何使用ServerSocket与Socket进行通讯，但是这里存在着一个问题，就是只能“p2p”点对点：一个服务端对一个客户端。若我们想让一个服务端可以同时支持多个客户端应该怎么做呢？

当服务端的ServerSocket通过accept方法侦听到一个客户端Socket连接后，就获取该Socket并与该客户端通过流进行双方的通讯了，这里的问题在于，只有不断的调用accept方法，我们才能侦听到不同客户端的连接。但是若我们循环侦听客户端的连接，又无暇顾及与连接上的客户端交互，这时我们需要做的事情就是并发。

我们可以创建一个线程类ClientHandler，并将于客户端交互的工作全部委托线程来处理。这样我们就可以在当一个客户端连接后，启动一个线程来负责与客户端交互，而我们也可以循环侦听客户端的连接了。

我们需要对服务端的代码进行修改:

package Paint;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Server端应用程序
 */
public class Server {
    public static void main(String[] args) {
        ServerSocket server = null;
        try {
            // 创建ServerSocket并申请服务端口为8088
            server = new ServerSocket(8088);

            while (true) {
                // 循环侦听客户端的连接
                Socket socket = server.accept();
                // 当一个客户端连接后，启动线程来处理该客户端的交互
                new ClientHandler(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (server != null) {
                try {
                    server.close();
                } catch (IOException e) {
                }
            }
        }
    }   
}

新建ClientHandler类，代码如下:

package Paint;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * 线程类 
 * 该线程的作用是并发与客户端进行交互
 * 这里的代码就是原来在Server中客户端连接后交互的代码
 */
class ClientHandler extends Thread {
    private Socket socket;

    public ClientHandler(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        try {
            // 获取输入流，用于读取客户端发送过来的消息
            InputStream in = socket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in, "UTF-8"));

            // 获取输出流，用于向该客户端发送消息
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(new OutputStreamWriter(out, "UTF-8"), true);

            // 读取客户端发送的消息
            String message = reader.readLine();
            System.out.println("客户端说:" + message);

            // 向客户端发送消息
            writer.println("你好客户端!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这样就可以反复监听啦：

启动了三次客户端的输出

关于TCP 三次握手和四次挥手，我们看这篇：
链接：https://www.jianshu.com/p/f876f19112a2

南丘xf

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
如何区分和理解TCP和UDP协议？

1、TCP与UDP区别总结：1）TCP面向连接（如打电话要先拨号建立连接）；UDP是无连接的，即发送数据之前不需要建立连接。2）TCP有保证、靠得住。通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达；UDP尽最大努力交付，即不保证可靠交付。3）TCP效率慢，UDP实时性好，工作效率比TCP高，适用于高速传输和实时性较高的通信或广播通信。4）每一条TCP连接只能是点对点；...
复制链接

扫一扫

专栏目录