什么是套接字

什么是套接字

套接字（Socket）是计算机网络通信中的一个基本概念，它是一种抽象的数据结构，用于在网络应用程序之间提供通信接口。套接字可以看作是一个端点，用于发送和接收数据。它使得运行在不同机器上的应用程序能够交换信息，从而实现网络功能。

套接字的概念最早由Unix系统的开发者比尔·贝宁顿（Bill Joy）在1983年引入。套接字API最初是为了提供一个统一的接口，以便程序员可以轻松地编写网络应用程序，而无需深入理解网络协议的复杂性。

套接字的工作原理

套接字工作在网络的传输层，它利用了TCP/IP协议族中的TCP或UDP协议来传送数据。TCP套接字保证了数据的有序和可靠传输，而UDP套接字则提供了无连接的服务，它不保证数据包的到达顺序或所有包都能到达。

当创建一个套接字时，需要指定它的类型（例如，TCP或UDP）、使用的协议以及绑定的端口号。一旦套接字被创建并配置好，就可以通过它发送和接收数据。

套接字的分类

根据不同的用途和功能，套接字主要分为以下两类：

1. 流式套接字（SOCK_STREAM）：它是一个面向连接的套接字类型，基于TCP协议。保证数据的顺序和可靠性。
2. 数据报套接字（SOCK_DGRAM）：它是一个无连接的套接字类型，基于UDP协议。不保证数据的顺序，可以快速发送和接收数据，但可能会丢失数据包。

使用套接字的示例

这段代码展示了如何使用Python的socket库创建一个简单的客户端和服务器应用程序。下面是对代码的解释和注解：

登录后复制

# 导入socket模块
import socket

# 创建一个客户端套接字对象
clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接到指定的服务器地址和端口号
clientsocket.connect(("www.pinginglab.net", 80))

# 创建一个服务器套接字对象
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定服务器套接字到指定的主机名和端口号
serversocket.bind((socket.gethostname(), 80))

# 开始监听连接请求，最大连接数为5
serversocket.listen(5)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.

解释：

1. import socket：导入Python的socket模块，该模块提供了用于网络编程的接口。
2. clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)：创建一个客户端套接字对象。socket.AF_INET表示使用IPv4地址，socket.SOCK_STREAM表示使用TCP协议。
3. clientsocket.connect(("www.pinginglab.net", 80))：连接到指定的服务器地址（www.pinginglab.net）和端口号（80）。这里的80通常用于HTTP通信。
4. serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)：创建一个服务器套接字对象，与客户端套接字类似。
5. serversocket.bind((socket.gethostname(), 80))：将服务器套接字绑定到本地主机名和一个指定的端口号（80）。这样，服务器就可以在该端口上接收来自客户端的连接请求。
6. serversocket.listen(5)：开始监听连接请求，并设置最大连接数为5。这意味着服务器可以同时处理最多5个客户端连接。

需要注意的是，这段代码只是创建了客户端和服务器的基本结构，并没有实际进行数据传输或处理客户端请求的功能。要实现完整的客户端-服务器通信，还需要编写相应的发送和接收数据的代码。

示例

下面通过一个简单的例子来说明如何使用套接字。我们将创建一个简单的服务器和客户端程序，服务器将监听来自客户端的连接，并向客户端发送一条消息。

服务器端代码（使用Python）

登录后复制

import socket 
 
# 创建一个流式套接字 
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# 设置服务器监听的IP地址和端口号 
server_address = ('', 10000)
 
# 绑定套接字到服务器地址 
sock.bind(server_address)
 
# 开始监听连接 
sock.listen(1)
 
print('Server is listening...')
 
while True:
    # 等待客户端连接 
    client_socket, client_address = sock.accept()
    
    print(f'Connected by {client_address}')
    
    # 向客户端发送消息 
    message = 'Hello from the server!'
    client_socket.sendall(message.encode())
    
    # 关闭连接 
    client_socket.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.

客户端代码（使用Python）

登录后复制

import socket 
 
# 创建一个流式套接字 
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# 连接到服务器 
server_address = ('localhost', 10000)
sock.connect(server_address)
 
# 接收来自服务器的消息 
data = sock.recv(1024)
 
print(f'Received: {data.decode()}')
 
# 关闭连接 
sock.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.

在这个例子中，服务器在本地主机的10000端口监听客户端的连接。当客户端连接到服务器时，服务器向客户端发送一条消息，并关闭连接。客户端收到消息后，打印出消息并关闭连接。

建议输入路径和python版本、以及代码说明、创建时间等

导入内置的import模块

定义端口

监听地址

监听连接

s.listen(5)

与客户端建立链接

结论

套接字是现代网络编程不可或缺的一部分，无论是开发简单的聊天程序还是复杂的Web服务，套接字都是基础。通过封装底层的网络协议，套接字为程序员提供了一个简洁而强大的接口，使得网络编程变得简单而高效。

TCP、UCP套接字如何使用

TCP（传输控制协议）和UDP（用户数据报协议）是两种不同的网络通信协议，它们在套接字编程中扮演着重要角色。套接字编程是一种网络编程技术，允许应用程序通过网络发送和接收数据。

TCP套接字编程

TCP是一种面向连接的协议，提供可靠的数据传输。在TCP套接字编程中，客户端和服务器之间建立一个连接，并通过这个连接交换数据。以下是一个简单的TCP服务器和客户端的Python示例，带有注释解释每个步骤：

TCP服务器示例（Python）

登录后复制

import socket
 
# 创建一个TCP套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 
# 绑定到特定的IP地址和端口
server_address = ('localhost', 12345)
server_socket.bind(server_address)
 
# 监听连接
server_socket.listen(1)
 
print('等待客户端连接...')
 
while True: 
    # 接受客户端连接 
    client_socket, client_address = server_socket.accept() 
    print(f'客户端 {client_address} 已连接')
 
    # 接收客户端消息 
    data = client_socket.recv(1024) 
    print(f'收到消息: {data.decode()}')
 
    # 发送响应给客户端
    response = '你好，客户端！'.encode() 
    client_socket.sendall(response) 
 
    # 关闭与客户端的连接 
    client_socket.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.

TCP客户端示例（Python）

登录后复制

import socket
 
# 创建一个TCP套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 
# 连接到服务器
server_address = ('localhost', 12345)
client_socket.connect(server_address)
 
# 发送消息给服务器 
message = '你好，服务器！'.encode()
client_socket.sendall(message)
 
# 接收服务器的响应
data = client_socket.recv(1024) 
print(f'收到服务器的响应: {data.decode()}')
 
# 关闭套接字
client_socket.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.

这段Python代码的主要功能是创建一个网络服务并连接到一个主机。下面是对代码的注解：

登录后复制

#!/usr/bin/python3  # 指定解释器为Python3

import socket  # 导入socket模块，用于网络编程

# 创建一个新的套接字对象
s = socket.socket()

# 获取当前主机名
host = socket.gethostname()

# 设置要连接的端口号
port = 9999

# 连接到指定的主机和端口
s.connect((host, port))

# 接收来自服务器的数据，最大接收1024字节，并将其解码为utf-8格式的字符串
print(s.recv(1024).decode('utf-8'))

# 关闭套接字连接
s.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.

这段代码首先导入了socket模块，然后创建了一个套接字对象s。接着，它获取当前主机的名称，并设置了要连接的端口号（在这个例子中是9999）。之后，代码使用connect方法连接到指定的主机和端口。一旦连接成功，它会尝试从服务器接收数据，并将接收到的数据解码为UTF-8格式的字符串，然后打印出来。最后，代码关闭了套接字连接。

成功！

返回了客户端的ip和端口号

UDP套接字编程

UDP是一种无连接的协议，提供不可靠的数据传输。在UDP套接字编程中，数据包（或称为数据报）直接从一个主机发送到另一个主机，不需要建立连接。以下是一个简单的UDP服务器和客户端的Python示例，带有注释解释每个步骤：

UDP服务器示例（Python）

登录后复制

import socket
 
# 创建一个UDP套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
 
# 绑定到特定的IP地址和端口
server_address = ('localhost', 12345)
server_socket.bind(server_address)
 
print('等待客户端消息...')
 
while True: 
    # 接收客户端消息 
    data, client_address = server_socket.recvfrom(1024)
    print(f'收到来自 {client_address} 的消息: {data.decode()}')
 
    # 发送响应给客户端
    response = '你好，客户端！'.encode() 
    server_socket.sendto(response, client_address)

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.

UDP客户端示例（Python）

登录后复制

import socket
 
# 创建一个UDP套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
# 发送消息给服务器
server_address = ('localhost', 12345) 
message = '你好，服务器！'.encode()
client_socket.sendto(message, server_address) 
 
# 接收服务器的响应
data, server_address = client_socket.recvfrom(1024) 
print(f'收到服务器的响应: {data.decode()}')
 
# 关闭套接字
client_socket.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.

请注意，这些示例是为了教学目的而编写的，并没有处理错误和异常情况。在实际应用中，您应该添加适当的错误检查和处理逻辑。此外，这些示例假设服务器和客户端都在同一台机器上运行，因此使用了localhost作为服务器的地址。在实际部署中，您需要使用服务器的实际IP地址。

登录后复制

#!/usr/bin/python3  # 指定使用Python3解释器来执行此脚本

import socket  # 导入socket模块，用于网络通信

# 创建一个新的套接字对象，这个套接字将用于与远程主机进行通信
s = socket.socket()

# 获取当前设备的主机名，这将通常是设备在本地网络中的名称
host = socket.gethostname()

# 设置一个端口号，用于与远程主机通信。端口号9999是一个常见的选择，但应确保该端口未被其他服务占用。
port = 9999

# 使用上面创建的套接字对象s来连接到指定的主机和端口。这里的(host, port)表示要连接的端点的地址和端口号。
s.connect((host, port))

# 一旦连接成功，使用recv方法接收来自连接的主机的数据。参数1024指定了接收的最大字节数。
# decode('utf-8')将接收到的字节数据解码成UTF-8编码的字符串，因为网络传输通常以字节流的形式进行。
print(s.recv(1024).decode('utf-8'))

# 关闭套接字连接。这是一个良好的网络编程实践，可以释放资源并避免潜在的安全问题。
s.close()

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.

核心思想：

1. 网络通信基础：这段代码展示了如何使用Python的socket库来建立一个简单的TCP客户端，它能够连接到本机上运行的服务，并接收数据。
2. 资源管理：通过在数据传输完成后关闭套接字，代码强调了资源管理的重要性，避免了可能的资源泄露。
3. 编码与解码：在处理网络数据时，重要的是要处理编码和解码，因为数据在网络上是以字节形式传输的。

教学示例：

• 实验设置：为了实际演示这段代码，你可以在本机上运行一个简单的TCP服务器，监听端口9999，并发送一条欢迎消息。
• 安全问题：提醒学习者注意不要在不安全的网络环境下暴露敏感信息，以及在实际部署时考虑网络安全性。
• 扩展概念：从这个基础出发，可以引入更多高级概念，如异步I/O、SSL加密通信等。

原创作者: zhuzhuxia 转载于: https://blog.51cto.com/zhuzhuxia/11408587