简介

Socket(简称：套接字)是进程之间通信的一个工具，好比现实中的插座，所有的家用电器要想工作都是基于插座进行，进程之间想要进行网络通信需要基于这个socket，负责进程之间的网络数据传输，好比数据的搬运工

一、TCP客户端开发

import socket
 
# 1.创建客户端套接字对象
# 参数1：ipv4（ip协议的版本）
# 参数2：选择协议（SOCK_STREAM==>TCP协议）
tcp_client_socket = socket.socket(socket.AF_INEF, socket.SCOK_STREAM)
 
# 2.和服务端套接字建立连接
# 参数：元组（有两个元素！）
# 参数1：服务器的ip地址（字符串）
# 参数2：服务器的端口号（数字）
tcp_client_socket.connect(("127.0.0.1", 8080))
 
# 发送数据的时候需要先转换成二进制
data = '123'
# 编码
data = data.encode("utf8")
 
# 3.发送数据
tcp_client_socket.send(data)
 
# 4.接受数据
# 参数：以字节为单位的接受的数据的大小
recv_data = tcp_client_socket.recv(1024)
 
# 5.关闭客户端套接字
tcp_client_socket.close()

二、服务端开发

import socket
 
# 1.创建服务端的套接字对象
# 参数1：ipv4
# 参数2：tcp协议
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# 2.绑定端口号
# 参数：元组（两个元素） 参数1：ip地址（字符串） 参数2：端口号（数字）
# 参数1不写就是默认本地IP地址（127.0.0.1）
tcp_server_socket.bind(("参数1", 8080))
 
# 3.设置监听
# 参数：最大监听个数(排队等待处理的最大个数)
tcp_server_socket.listen(128)
 
# 4.阻塞等待接受客户端的连接请求
# 返回值是一个元组（有两个元素）
# 元素1：和客户端进行通信的socket 元素2：客户端的地址信息(ip,端口号）
# 通过拆包语法 我们分别获取两个元素(client_socket负责处理客户请求)
client_socket, client_addr = tcp_server_socket.accept()
 
# 5.接受数据
# 参数：接受数据的大小（字节）
client_data = client_socket.recv(1024)
# 对二进制的数据解码
client_data = client_data.decode()
print(client_data)
 
# 6.发送数据
send_data = "123".encode()
client_socket.send(send_data)
 
# 7.关闭套接字
client_socket.close()
tcp_server_socket.close()

三、端口复用

# 1.创建服务端套接字对象
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
# 在创建服务端后面设置端口复用
# 端口复用（一旦服务端关闭，端口马上释放）
# setsocketopt: 设置socket选项
# 参数1：socket选项列表（SOL）
# 参数2：地址复用
# 参数3：True：开启选项（默认都是不开启）
tcp_server_socket.setsocketopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)

四、持续接受数据，判断客户端关闭

while True:
    # 5.服务端接受数据
    client_data = client_socket.recv(1024)
    
    # 如果接受的数据长度为零，则证明客户端关闭
    if len(client_data) == 0:
        print("客户端关闭！")
        break
        
    # 对二进制的数据解码
    client_data = client_data.encode()
    print(client_data)
    # 6.发送数据
    send_data = "123".encode()
    client_data.send(send_data)

五、服务端的多任务

import socket
import multiprocessing
 
def handler_client_request(client_socket):
    """ 处理客户端请求 """
    while True:
        # 接受数据
        client_data = client_socket.recv(1024)
    
        # 如果接受的数据长度为零，则证明客户端关闭
        if len(client_data) == 0:
            print("客户端关闭！")
            break
    
        # 对二进制的数据解码
        client_data = client_data.encode()
        print(client_data)
        # 发送数据
        send_data = "123".encode()
        client_data.send(send_data)
 
def main():
    # 1.创建服务端的套接字对象
    # 参数1：ipv4
    # 参数2：tcp协议
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    
    # 2.绑定端口号
    # 参数：元组（两个元素） 参数1：ip地址（字符串） 参数2：端口号（数字）
    # 参数1不写就是默认本地IP地址（127.0.0.1）
    tcp_server_socket.bind(("参数1", 8080))
    
    # 3.设置监听
    # 参数：最大监听个数(排队等待处理的最大个数)
    tcp_server_socket.listen(128)
    
    while True:
        # 4.阻塞等待接受客户端的连接请求
        # 返回值是一个元组（有两个元素）（元素1：和客户端进行通信的socket 元素2：客户端的地址信息(ip,端口号)
        # 通过拆包语法 我们分别获取两个元素(client_socket负责处理客户请求)
        client_socket, client_addr = tcp_server_socket.accept()
        
        # 创建子进程
        sub_process = multiprocessing.Process(target=handler_client_request, args=(client_socket,))
        # 开启子进程
        sub_process.start()
 
    # 关闭客户端套接字
    client_socket.close()
    tcp_client_socket.close()
 
if __name__ == '__main__':