【计算机网络实验二】网络基础编程实验 (Python-Socket)

已于 2022-10-31 14:01:34 修改
阅读量3k 收藏 44
点赞数 8
文章标签： 网络 计算机网络 python
于 2022-10-18 16:56:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yv_shu/article/details/127389521
版权

目录

1、前言

实验所用语言为Python，参考前辈们的比较多，在此仅作记录，文章中出现的图片还请不要随便使用，本人编程能力较弱，代码仅供参考

参考/学习：
Python Socket编程
Python threading编程
参考1
参考2

2、实验目的

通过本实验，学习采用Socket（套接字）设计简单的网络数据收发程序，理解应用数据包是如何通过传输层进行传送的。

3、实验内容

Socket（套接字）是一种抽象层，应用程序通过它来发送和接收数据，就像应用程序打开一个文件句柄，将数据读写到稳定的存储器上一样。一个socket允许应用程序添加到网络中，并与处于同一个网络中的其他应用程序进行通信。一台计算机上的应用程序向socket写入的信息能够被另一台计算机上的另一个应用程序读取，反之亦然。
不同类型的socket与不同类型的底层协议族以及同一协议族中的不同协议栈相关联。现在TCP/IP协议族中的主要socket类型为流套接字（sockets sockets）和数据报套接字（datagram sockets）。流套接字将TCP作为其端对端协议（底层使用IP协议），提供了一个可信赖的字节流服务。一个TCP/IP流套接字代表了TCP连接的一端。数据报套接字使用UDP协议（底层同样使用IP协议），提供了一个"尽力而为"（best-effort）的数据报服务，应用程序可以通过它发送最长65500字节的个人信息。一个TCP/IP套接字由一个互联网地址，一个端对端协议（TCP或UDP协议）以及一个端口号唯一确定。

3.1采用TCP进行数据发送的简单程序

在这里插入图片描述

服务端

# === TCP 服务端程序 ===

# 导入socket 库
from socket import *

# 主机地址为0.0.0.0, 表示绑定本机所有网络接口ip地址
# 主机地址127.0.0.1表示主机环回地址
# 等待客户端来连接
IP = '127.0.0.1'
# 端口号
PORT = 50000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512

# 实例化一个socket对象
# 参数 AF_INET表示该socket网络层使用IP协议
# 参数SOCK_STREAM 表示socket传输层使用tcp协议
listenSocket = socket(AF_INET, SOCK_STREAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))

# 使用socket处于监听状态， 等待客户端的连接请求
# 参数5表示，最多接收多少个等待连接的客户端
listenSocket.listen(5)
print(f"服务端启动成功， 在{PORT}端口等待客户端连接...")

# 当没有客户端连接时，服务端程序将会在此处阻塞，等待客户端连接
dataSocket, addr = listenSocket.accept()
# TCP连接建立之后accept()方法将会返回一个新的socket(用来收发数据)和一个客户端地址
print('接收一个客户端连接:', addr)

while True:
    # 尝试读取对方发送的消息
    # BUFLEN 指定从接收缓冲里最多读取多少字节
    recved = dataSocket.recv(BUFLEN)

    # 如果返回空bytes, 表示对方关闭了连接
    # 退出循环，结束消息收发
    if not recved:
        break

    # 读取的字节数据是bytes类型, 需要解码为字符串
    info = recved.decode()
    print(f'收到对方信息: {info}')

    # 发送的数据类型必须是bytes, 所以要编码
    dataSocket.send(f'服务端接收到了信息 {info}'.encode())

# 服务端也调用close()关闭socket
dataSocket.close()
listenSocket.close()

客户端

# === TCP客户端程序 ===
from socket import *

IP = '127.0.0.1'
SERVER_PORT = 60000
BUFLEN = 512

# 实例化一个socket对象，指明协议
dataSocket = socket(AF_INET, SOCK_STREAM)

# 连接服务端socket
dataSocket.connect((IP, SERVER_PORT))

while True:
    # 从终端读入用户输入的字符串
    toSend = input('>>')
    if toSend == 'exit':
        break
    # 发送消息，也要编码为bytes
    dataSocket.send(toSend.encode())

    # 等待接收服务端的消息
    recved = dataSocket.recv(BUFLEN)
    # 如果返回空bytes, 表示对方关闭了连接
    if not recved:
        break
    # 打印读取的信息
    print(recved.decode())

dataSocket.close()

实验结果

设置服务端在收到客户端消息之后将收到的消息再发送回去，验证二者收发能力正常。
在这里插入图片描述

3.2采用UDP进行数据发送的简单程序

在这里插入图片描述

服务端

# === UDP服务端程序 ===

# 导入socket 库
from socket import *

# 主机地址为0.0.0.0, 表示绑定本机所有网络接口ip地址
# 主机地址127.0.0.1表示主机环回地址
# 等待客户端来连接
IP = '127.0.0.1'
# 端口号
PORT = 50000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512

# 实例化一个socket对象
# 参数 AF_INET表示该socket网络层使用IP协议
# 参数SOCK_DGRAM 表示socket传输层使用udp协议
listenSocket = socket(AF_INET, SOCK_DGRAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))
print(f"服务端启动成功， 在{PORT}端口等待客户端连接...")

while True:
    # 接收UDP套接字的数据，返回接收到的数据和套接字地址
    recved, addr = listenSocket.recvfrom(BUFLEN)

    # 如果返回空bytes, 表示对方关闭了连接
    # 退出循环，结束消息收发
    if not recved:
        break

    # 读取的字节数据是bytes类型, 需要解码为字符串
    info = recved.decode()
    print(f'收到对方信息: {info}')

    # 发送的数据类型必须是bytes, 所以要编码
    listenSocket.sendto(f'服务端接收到了信息 {info}'.encode(), addr)

# 服务端也调用close()关闭socket
listenSocket.close()

客户端

# === UDP客户端套接字 ===

from socket import *

IP = '127.0.0.1'
SERVER_PORT = 50000
BUFLEN = 512

# 实例化一个socket对象，指明UDP协议
dataSocket = socket(AF_INET, SOCK_DGRAM)

while True:
    # 从终端读入用户输入的字符串
    toSend = input('>>')
    if toSend == 'exit':
        break
    # 发送UDP数据, 将数据发送到套接字
    dataSocket.sendto(toSend.encode(), (IP, SERVER_PORT))

    # 接收服务端的消息
    recved, addr = dataSocket.recvfrom(BUFLEN)
    # 如果返回空bytes, 表示对方关闭了连接
    if not recved:
        break
    # 打印读取的信息
    print(recved.decode())

dataSocket.close()

实验结果

设置服务端在收到客户端消息之后将收到的消息再发送回去，验证二者收发能力正常。
在这里插入图片描述

3.3多线程\线程池对比

当一个客户端向一个已经被其他客户端占用的服务器发送连接请求时，虽然其在连接建立后即可向服务器端发送数据，服务器端在处理完已有客户端的请求前，却不会对新的客户端作出响应。
并行服务器：可以单独处理没一个连接，且不会产生干扰。并行服务器分为两种：一客户一线程和线程池。
每个新线程都会消耗系统资源：创建一个线程将占用CPU周期，而且每个线程都自己的数据结构（如，栈）也要消耗系统内存。另外，当一个线程阻塞（block）时，JVM将保存其状态，选择另外一个线程运行，并在上下文转换（context switch）时恢复阻塞线程的状态。随着线程数的增加，线程将消耗越来越多的系统资源。这将最终导致系统花费更多的时间来处理上下文转换和线程管理，更少的时间来对连接进行服务。那种情况下，加入一个额外的线程实际上可能增加客户端总服务时间。
我们可以通过限制总线程数并重复使用线程来避免这个问题。与为每个连接创建一个新的线程不同，服务器在启动时创建一个由固定数量线程组成的线程池（thread pool）。当一个新的客户端连接请求传入服务器，它将交给线程池中的一个线程处理。当该线程处理完这个客户端后，又返回线程池，并为下一次请求处理做好准备。如果连接请求到达服务器时，线程池中的所有线程都已经被占用，它们则在一个队列中等待，直到有空闲的线程可用。
在这里插入图片描述

多线程服务端

# === 多线程 TCP 服务端 ===

# 导入库
from socket import *
import threading

# 主机地址为0.0.0.0, 表示绑定本机所有网络接口ip地址
# 主机地址127.0.0.1表示主机环回地址
# 等待客户端来连接
IP = '127.0.0.1'
# 端口号
PORT = 50000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512

# 实例化一个socket对象
# 参数 AF_INET表示该socket网络层使用IP协议
# 参数SOCK_STREAM 表示socket传输层使用tcp协议
listenSocket = socket(AF_INET, SOCK_STREAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))

# 使用socket处于监听状态， 等待客户端的连接请求
# 参数5表示，最多接收多少个等待连接的客户端
listenSocket.listen(5)
print(f"服务端启动成功， 在{PORT}端口等待客户端连接...")


# 接收到连接之后进行通信的方法
def TCP_Link(dataSocket, addr):
    while True:
        # 尝试读取对方发送的消息
        # BUFLEN 指定从接收缓冲里最多读取多少字节
        recved = dataSocket.recv(BUFLEN)

        # 如果返回空bytes, 表示对方关闭了连接
        # 退出循环，结束消息收发
        if not recved:
            break

        # 读取的字节数据是bytes类型, 需要解码为字符串
        info = recved.decode()
        print(f'收到来自{addr}的信息: {info}')

        # 发送的数据类型必须是bytes, 所以要编码
        dataSocket.send(f'服务端接收到了信息 {info}'.encode())

        # 服务端也调用close()关闭socket
    print(f'客户端{addr}断开连接')
    dataSocket.close()


# 服务端socket 持续接收客户端连接
while True:
    # 当没有客户端连接时，服务端程序将会在此处阻塞，等待客户端连接
    dataSocket, addr = listenSocket.accept()
    # TCP连接建立之后accept()方法将会返回一个新的socket(用来收发数据)和一个客户端地址
    print('接收一个客户端连接:', addr)

    # 接收到一个连接之后, 为该连接建立新的线程
    addThread = threading.Thread(target=TCP_Link, args=(dataSocket, addr))
    # 运行该线程
    addThread.start()

[多线程的客户端与使用TCP的客户端相同，可以复制多个程序与服务端连接模拟多线程的情况]

实验结果

这里以服务端同时接收两个客户端连接为例，验证服务端具备多线程处理客户端发送信息的能力。
在这里插入图片描述

线程池服务端

# === 线程池 TCP 服务端 ===

# 导入库
from socket import *
from concurrent.futures import ThreadPoolExecutor

# 主机地址为0.0.0.0, 表示绑定本机所有网络接口ip地址
# 主机地址127.0.0.1表示主机环回地址
# 等待客户端来连接
IP = '127.0.0.1'
# 端口号
PORT = 60000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512

# 实例化一个socket对象
# 参数 AF_INET表示该socket网络层使用IP协议
# 参数SOCK_STREAM 表示socket传输层使用tcp协议
listenSocket = socket(AF_INET, SOCK_STREAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))

# 使用socket处于监听状态， 等待客户端的连接请求
# 参数5表示，最多接收多少个等待连接的客户端
listenSocket.listen(5)
print(f"服务端启动成功， 在{PORT}端口等待客户端连接...")


# 接收到连接之后进行通信的方法
def TCP_Link(dataSocket, addr):
    while True:
        # 尝试读取对方发送的消息
        # BUFLEN 指定从接收缓冲里最多读取多少字节
        recved = dataSocket.recv(BUFLEN)

        # 如果返回空bytes, 表示对方关闭了连接
        # 退出循环，结束消息收发
        if not recved:
            break

        # 读取的字节数据是bytes类型, 需要解码为字符串
        info = recved.decode()
        print(f'收到来自{addr}的信息: {info}')

        # 发送的数据类型必须是bytes, 所以要编码
        dataSocket.send(f'服务端接收到了信息 {info}'.encode())

        # 服务端也调用close()关闭socket
    print(f'客户端{addr}断开连接')
    dataSocket.close()


# 建立一个线程池
thread_pool = ThreadPoolExecutor(max_workers=5)

# 服务端socket 持续接收连接
while True:
    # 当没有客户端连接时，服务端程序将会在此处阻塞，等待客户端连接
    dataSocket, addr = listenSocket.accept()
    # TCP连接建立之后accept()方法将会返回一个新的socket(用来收发数据)和一个客户端地址
    print('接收一个客户端连接:', addr)

    # 接收到一个连接之后, 为该连接建立新的线程
    thread_pool.submit(TCP_Link, dataSocket, addr)

[线程池的客户端与使用TCP的客户端相同，可以复制多个程序与服务端连接模拟多线程的情况]

实验结果

这里以服务端同时接收两个客户端连接为例，验证服务端具备多线程处理客户端发送信息的能力。
在这里插入图片描述

3.4写一个简单的chat程序，并能互传文件

在这里插入图片描述

服务端

# === Chat程序编写 TCP 服务端 ===

# 导入库
from socket import *
import threading
import os
import json

# 主机地址为0.0.0.0, 表示绑定本机所有网络接口ip地址
# 主机地址127.0.0.1表示主机环回地址
# 等待客户端来连接
IP = '127.0.0.1'
# 端口号
PORT = 40000
# 定义一次从socket缓冲区最多读入512个字节数据
BUFLEN = 512
# 上传文件的源地址 /serverfile.pdf
UPLOAD_PATH = r"ServerUPLOAD"
# 文件下载地址
DOWNLOAD_PATH = r"ServerDOWNLOAD"


# 实例化一个socket对象
# 参数 AF_INET表示该socket网络层使用IP协议
# 参数SOCK_STREAM 表示socket传输层使用tcp协议
listenSocket = socket(AF_INET, SOCK_STREAM)

# socket绑定地址和端口
listenSocket.bind((IP, PORT))

# 使用socket处于监听状态， 等待客户端的连接请求
# 参数5表示，最多接收多少个等待连接的客户端
listenSocket.listen(5)
print(f"服务端启动成功， 在{PORT}端口等待客户端连接...")

# 创建一个列表存放服务器所接收到的连接
LinkList = {}

# 定义服务端连接方法
def Chat(dataSocket, addr):
    global LinkList
    while True:
        # 尝试读取对方发送的消息
        # BUFLEN 指定从接收缓冲里最多读取多少字节
        recved = dataSocket.recv(BUFLEN).decode()

        # 如果返回空bytes, 表示对方关闭了连接
        # 退出循环，结束消息收发
        if not recved:
            break
        # 读取的字节数据是bytes类型, 需要解码为字符串
        # 客户端聊天
        if recved == "chat":
            print(f'收到来自{addr}的聊天请求')
            recved = dataSocket.recv(BUFLEN).decode()
            print(f'收到来自{addr}的信息: {recved}')
            toSend = input(f"发送给{addr}>>")
            dataSocket.send('chat'.encode())
            dataSocket.send(('收到来自服务器的消息: ' + toSend).encode())
        # 客户端转发聊天请求
        elif recved == "sendto":
            print(f'收到来自{addr}的转发聊天请求')
            recved = dataSocket.recv(BUFLEN).decode()
            target = dataSocket.recv(BUFLEN).decode()
            target = int(target)
            if target in LinkList:
                LinkList[target].send('chat'.encode())
                LinkList[target].send((f'收到来自{addr[1]}的消息: ' + recved).encode())
                print(f'成功将消息{recved}发送给{target}')
        # 客户端向服务端请求文件
        elif recved == "get":
            print(f'收到来自{addr}的文件请求')
            # 获取将要上传文件的名称、大小
            file_name = dataSocket.recv(BUFLEN).decode()
            if os.path.isfile(UPLOAD_PATH+'\\'+file_name):
                file_size = os.path.getsize(UPLOAD_PATH+'\\'+file_name)
                dict = {
                    'filename': file_name,
                    'filesize': file_size
                }
                # 将文件基本信息编码成JSON发送给客户端
                fileinfo = json.dumps(dict)
                dataSocket.send('file'.encode())
                dataSocket.send('0'.encode())
                dataSocket.send(fileinfo.encode('utf-8'))
                with open(UPLOAD_PATH+'\\'+file_name, 'rb') as f:
                    data = f.read()
                    dataSocket.sendall(data)
                print(f'已成功将文件{file_name}上传给{addr}')
            else:
                dataSocket.send('chat'.encode())
                dataSocket.send('请求文件不存在'.encode())
        # 收到来自用户上传的文件
        elif recved == "deliver":
            print(f'收到来自{addr}的上传请求')
            fileinfo = dataSocket.recv(BUFLEN)
            # 将从客户端收到的JSON文件信息解码
            dict = json.loads(fileinfo)
            file_name = dict['filename']
            file_size = dict['filesize']
            print(f'收到来自{addr}的文件:{file_name}, 文件大小:{file_size}')
            recv_size = 0
            recv_file = b''
            f = open(DOWNLOAD_PATH + '\\' + file_name, 'wb')
            while recv_size < file_size:
                if file_size - recv_size > BUFLEN:
                    recv_file = dataSocket.recv(BUFLEN)
                    f.write(recv_file)
                    recv_size += len(recv_file)
                else:
                    recv_file = dataSocket.recv(file_size - recv_size)
                    recv_size += len(recv_file)
                    f.write(recv_file)
            f.close()
            print('文件接收成功!')
        # 收到来自客户端的转发文件请求
        elif recved == "deliverto":
            print(f'收到来自{addr}的转发文件请求')
            target = int(dataSocket.recv(BUFLEN).decode())
            # 接收
            fileinfo = dataSocket.recv(BUFLEN)
            # 将从客户端收到的JSON文件信息解码
            dict = json.loads(fileinfo)
            file_name = dict['filename']
            file_size = dict['filesize']
            print(f'收到来自{addr}的文件:{file_name}, 文件大小:{file_size}')
            recv_size = 0
            recv_file = b''
            f = open(DOWNLOAD_PATH + '\\' + file_name, 'wb')
            while recv_size < file_size:
                if file_size - recv_size > BUFLEN:
                    recv_file = dataSocket.recv(BUFLEN)
                    f.write(recv_file)
                    recv_size += len(recv_file)
                else:
                    recv_file = dataSocket.recv(file_size - recv_size)
                    recv_size += len(recv_file)
                    f.write(recv_file)
            f.close()
            print('文件接收成功!')
            # 转发
            if target in LinkList.keys():
                # 将文件基本信息编码成JSON发送给客户端
                fileinfo = json.dumps(dict)
                LinkList[target].send('file'.encode())
                LinkList[target].send(str(target).encode())
                LinkList[target].send(fileinfo.encode('utf-8'))
                with open(DOWNLOAD_PATH + '\\' +file_name, 'rb') as f:
                    data = f.read()
                    LinkList[target].sendall(data)
                print(f'已成功将文件{file_name}转发给{target}')
                dataSocket.send('chat'.encode())
                dataSocket.send(f'服务器已成功将{file_name}转发给{target}'.encode())
            else:
                dataSocket.send('chat'.encode())
                dataSocket.send('目标用户不存在，文件已由服务器接收'.encode())
        elif recved == "exit":
            print(f'客户端{addr}断开连接')
            dataSocket.close()
            break

# 服务端socket 持续接收客户端连接
while True:
    # 当没有客户端连接时, 服务端程序在此处阻塞, 等待客户端连接
    dataSocket, addr = listenSocket.accept()
    # TCP连接建立之后accept()方法将会返回一个新的socket(用来收发数据)和一个客户端地址
    print('接收一个客户端连接:', addr)

    # 将该连接放入到连接的列表中
    print(addr[1])
    LinkList[addr[1]] = dataSocket
    # 接收到一个连接之后, 为该连接建立新的线程
    addThread = threading.Thread(target=Chat, args=(dataSocket, addr))
    # 运行该线程
    addThread.start()

客户端

# === Chat程序编写 TCP 客户端 ===

# 导入库
from socket import *
import os
import json
import threading

IP = '127.0.0.1'
PORT = 40000
BUFLEN = 512
# /client1file.pdf
UPLOAD_PATH = r"Client1UPLOAD"
DOWNLOAD_PATH = r"Client1DOWNLOAD"

# 实例化一个socket对象，指明协议
dataSocket = socket(AF_INET, SOCK_STREAM)

# 连接服务端socket
dataSocket.connect((IP, PORT))
print("已成功与服务端取得连接, 键入chat、sendto、get、deliver、deliverto进行不同功能")

def recvChat():
    while True:
        recved = dataSocket.recv(BUFLEN).decode()
        if recved == 'chat':
            recved = dataSocket.recv(BUFLEN).decode()
            print(f'{recved}')
        elif recved == 'file':
            source = dataSocket.recv(BUFLEN).decode()
            fileinfo = dataSocket.recv(BUFLEN)
            # 将收到的JSON文件信息解码
            dict = json.loads(fileinfo)
            file_name = dict['filename']
            file_size = dict['filesize']
            # 收到来自服务器的文件
            if source == '0':
                print(f'收到来自服务端的文件:{file_name}')
            # 收到来自客户端的文件
            else:
                print(f'收到来自{source}的文件:{file_name}')
            print(f'文件大小:{file_size}')
            recv_size = 0
            recv_file = b''
            f = open(DOWNLOAD_PATH + '\\' + file_name, 'wb')
            while recv_size < file_size:
                if file_size - recv_size > BUFLEN:
                    recv_file = dataSocket.recv(BUFLEN)
                    f.write(recv_file)
                    recv_size += len(recv_file)
                else:
                    recv_file = dataSocket.recv(file_size - recv_size)
                    recv_size += len(recv_file)
                    f.write(recv_file)
            f.close()
            print('文件接收成功!')

recvThreading = threading.Thread(target=recvChat)
recvThreading.start()

while True:
    # 从终端读入用户输入的字符串
    toSend = input()
    if toSend == 'exit':
        break
    # 聊天(与服务端)
    if toSend == 'chat':
        dataSocket.send(toSend.encode())
        toSend = input('输入消息内容:')
        dataSocket.send(toSend.encode())
        print('消息已发送, 等待服务端回应')
    # 聊天(与客户端)
    elif toSend == 'sendto':
        dataSocket.send(toSend.encode())
        toSend = input('输入消息内容:')
        dataSocket.send(toSend.encode())
        toSend = input('输入目标客户端地址:')
        dataSocket.send(toSend.encode())
    # 向服务端请求文件
    elif toSend == 'get':
        dataSocket.send(toSend.encode())
        file_name = input('输入请求文件: ')
        dataSocket.send(file_name.encode())
    # 向服务器上传文件
    elif toSend == 'deliver':
        file_name = input('输入要发送的文件: ')
        if os.path.isfile(UPLOAD_PATH + '\\' + file_name):
            dataSocket.send(toSend.encode())
            # 获取将要上传文件的名称、大小
            file_size = os.path.getsize(UPLOAD_PATH+'\\'+file_name)
            dict = {
                'filename': file_name,
                'filesize': file_size
            }
            # 将文件基本信息编码成JSON发送给客户端
            fileinfo = json.dumps(dict)
            dataSocket.send(fileinfo.encode('utf-8'))
            with open(UPLOAD_PATH+'\\'+file_name, 'rb') as f:
                data = f.read()
                dataSocket.sendall(data)
            print(f'已成功将文件{file_name}上传给服务端')
        else:
            print(f'文件不存在，请检查文件名{file_name}是否正确!')
    # 向指定客户端上传文件
    elif toSend == 'deliverto':
        file_name = input('输入要发送的文件: ')
        if os.path.isfile(UPLOAD_PATH + '\\' + file_name):
            dataSocket.send(toSend.encode())
            toSend = input('输入目标客户端地址: ')
            dataSocket.send(toSend.encode())
            file_size = os.path.getsize(UPLOAD_PATH+'\\'+file_name)
            dict = {
                'filename': file_name,
                'filesize': file_size
            }
            # 将文件基本信息编码成JSON发送给客户端
            fileinfo = json.dumps(dict)
            dataSocket.send(fileinfo.encode('utf-8'))
            with open(UPLOAD_PATH+'\\'+file_name, 'rb') as f:
                data = f.read()
                dataSocket.sendall(data)
            print(f'已成功将文件{file_name}上传给服务端')
        else:
            print(f'文件不存在，请检查文件名{file_name}是否正确!')
dataSocket.close()

实验结果

chat功能测试
chat功能实现客户端与服务器发送消息，此功能必须得到服务器的回应
在这里插入图片描述
sendto功能测试
sendto功能实现客户端与客户端之间的通信，这是一种更符合现实应用的一种场景，主要是利用服务器来记录所有连接的客户端，收到客户端的sendto请求时，根据客户端所指定的对象将消息转发给目标用户实现聊天功能
在这里插入图片描述
get功能测试
get功能实现客户端向服务器请求文件，与服务器建立连接的客户端键入get指令之后需要指明请求文件的文件名，服务端如果发现拥有该文件就将其发送给客户端，否则发送相应的消息告诉客户端不拥有该文件
初始的文件拥有情况：
在这里插入图片描述
首先客户端向服务端请求serverfile文件，服务端发现该文件未拥有，于是向客户端发送提示信息，之后客户端再次向服务端请求文件，并指明serverfile.pdf文件，服务端发现拥有该文件于是将其发送给客户端
在这里插入图片描述
执行get之后的文件拥有情况：
在这里插入图片描述
可以发现，客户端1的下载目录下已经拥有了从服务器所请求的文件
deliver功能测试
deliver功能用于实现客户端向服务器上传文件，与服务器建立连接的客户端在键入deliver之后需要指明上传文件的名称，之后将直接上传给服务器
初始的文件拥有情况：
在这里插入图片描述
首先客户端发起上传文件的请求，但此时该请求并不会发送给服务端，之后客户端键入要发送文件的名称，如果指定文件不存在，该请求将被忽略；如果成功找到要上传的文件，则向服务端发送该请求，服务端接收客户端上传的文件
在这里插入图片描述
执行deliver之后的文件拥有情况：
在这里插入图片描述
deliverto功能测试
deliverto功能用于实现客户端与客户端之间的互传文件，与服务器建立连接的客户端之间如果某一用户知道对方的地址时，就可以给对方发送文件，发送方先将文件发送给服务端，服务端再将文件发送给目标用户(如果存在的话)
初始的文件拥有情况：
在这里插入图片描述
客户端键入deliverto命令请求服务器转发文件，但是此时该条请求并不会立即发给服务器，在客户端程序确认确实拥有该文件时，在指定目标用户之后，将文件发送给服务器，服务器会首先接收该文件，之后再判断目标用户是否存在，在确定目标用户存在之后再将文件发送给目标用户完成文件传送
在这里插入图片描述
执行deliverto互传文件之后的文件拥有情况：
在这里插入图片描述

4.实验总结

通过本次实验，对socket编程有了初步的了解，学习了如何使用套接字采用TCP进行数据的收发、用UDP进行数据的收发，socket是应用层与TCP/IP协议中间的抽象层，作为一组接口，其将复杂的TCP/IP协议隐藏在socket接口后面，减轻了程序员编程的负担；同时也对比了多线程、线程池两种不同的多线程通信方案的实现方式和差别，相比于多线程方式，线程池预先创建多个线程，在需要新线程的时候将提前创建的线程直接取出来使用，在效率上是比多线程实现方式更优的，但两种方式都有自己的应用场景；最后利用python语言尝试编写了互传文件的程序，客户端与客户端之间的通信(聊天/传文件)本质上是一种通过服务器转发的方式，正确处理它们之间的关系非常重要，这次也是收获满满呀。

鱼树C
关注
  • 8
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
python-socket-网络编程实验报告.wps
09-30
python-socket-网络编程实验报告.wps
计算机网络——Socket实验1
上山打老虎的博客
04-17 3526
一、实验目的 学习网络编程基本概念、InetAddress的应用、URL的应用、URLConnection的应用 二、实验内容 InetAddress类和URLConnection类的使用 三、实验环境 使用Windows操作系统；Internet连接 Eclipse+Java开发环境 四、实验步骤 1 InetAddress类 1.1 InetAddress类的简介 Internet上的主机有两种表示地址的方式：域名和IP地址。有时候需要通过域名来查找它对应的IP地址，有时候
【Python--网络编程之Ping命令的实现】
最新发布
qq_45832651的博客
02-12 1541
使用Python网络编程实现Ping命令
实验五、Python网络编程 -2022.doc
10-13
实验内容与要求 1、 （1）从客户端输入一个学生的id、姓名、年龄、分数； （2）将其发送到服务端，由服务端写入到一个文本文件中； （3）每个信息占一行； （4）数据传输分别使用TCP和UDP套接字完成。
Python 网络编程 python网络编程 socket
01-06
Python 网络编程 python网络编程 socket
计算机网络实验二- Socket通信编程与传输协议分析
11-14
1、使用Java/C/C++/C#/Python等语言编写Socket通信程序。 2、基于TCP的SOCKET通信测试及验证。 3、TCP通信过程分析 1、端口扫描编程及验证，利用Socket connect扫描自己服务器至少1个端口 2、Socket 编程，编写Socket的服务器及客户端程序 3、Socket 测试，在局域网内，或者同学建立的小组内进行通信测试 4 、 传输层验证分析，分析三次握手建立连接过程，Sequence Number 计算 分析发送数据及确认过程，Sequence Number 计算 分析四次挥手拆除连接过程，Sequence Number 计算 5、 RST 至少导致一个RST 并说明原因 6、 Segments 发送一个至少需要分2个Segment的报文，Sequence Number 计算
Python网络编程实验报告，实验一、实验二、实验三，附优秀课程设计报告
08-14
第一次实验内容是：使用Python3 实现TCP全连接端口扫描器；第二次实验内容是：用户从客户端进行登录后，可以进行从服务端下载文件；第三次实验内容是：多线程TCP端口扫描。最后课程设计是《多功能服务端与客户端》，具体要求如下： Python网络编程实现如下功能： 1、服务器端能够同时为100个客户端提供服务； 2、服务器端使用数据库保存用户帐户、密码和email等信息； 3、服务器端提供FTP服务； 4、服务器端提供消息传递功能 5、客户端提供用户注册功能，登录功能，聊天功能，发送和接收email功能； 6、客户端提供用户间传递文件的功能； 7、客户端提供向服务器公共文件区上传下载文件的功能（全体用户可见）； 8、客户端提供向服务器用户个人文件区上传下载文件的功能（只有用户个人可见）；
socket 编程实验
qq_46023947的博客
11-11 4272
1 实验内容 编写一个基于UDP协议的客户机与服务器程序，实现相互通讯。 编写一个基于TCP协议的客户机与服务器程序，实现相互通讯。 捕获以上两种通讯的数据包，使用Wireshark进行分析，以深入了解TCP、UDP协议的数据传输机制。 2 TCP编程及监听分析 1、建立一个TCP服务器连接需要6个步骤： (1）创建socket对象。 调用socket构造函数： socket=socket.socket(familly,type) family的值可以是AF_UNIX(Unix域，用于同一台机器上的进程
计算机网络实验socket通信
qq_52645134的博客
10-17 2103
socket通信实验
深大计算机网络实验四—— Socket网络编程
AnakinRM的博客
03-03 4653
目录 实验内容 实验步骤 实验一 1.获取本机IP地址 2.获取指定网站IP地址 3. 使用URL类下载网页并统计大小 实验二 1.使用TCP连接和Socket类实现C/S通信 2.使用UDP连接来编写数据报通信程序 实验三 1.​​​​​​​利用TCP连接实现文件传输 实验内容 使用InetAddress类的方法获取本地机的名称和IP地址。 使用InetAddress类的方法获取网站www.csdn.net的IP地址，如果存在多个...
计算机网络——Socket实验2
上山打老虎的博客
04-17 5870
一、实验目的 掌握Socket的TCP通信、 Socket的UDP通信 二、实验内容 Socket、ServerSocket类和DatagramPacket 、DatagramSocket类的使用 三、实验环境 使用Windows操作系统；Internet连接 IDEA+Java开发环境 四、实验步骤与过程 1 套接字Socket 1.1 什么是Socket 套接字是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程
python-socket-网络编程实验报告.doc
01-18
python-socket-网络编程实验报告.doc
python通信原理实验_Python Socket实现心跳监测
weixin_39623671的博客
12-18 225
首先需要声明的是，现在写了一个客户端和服务端通信的小功能程序，利用Python，当然主要是Python的一些内置库。比如socket，sys，json，thread等。socket通信原理Server端建立一个socket，然后绑定到一个(IP，port)对里，然后开启监听，准备好接收来自客户端(另一方)的请求。其中和客户端通信的方法有send(), sendall(), accept(), re...
网络通信开发实战（基于TCP原理实现两台主机之间实现远程文件的收发应用）python实现
weixin_46900108的博客
08-18 1706
通过TCP可以实现网络间字符的发送和接收，既然可以实现网络的收发，那么自然可以实现文件的下载，市场上主流的下载器均使用socket实现网络通信。进行文件的远程传送。本项目应用场景，是作者经过学习网络通信原理为了实现虚拟机和主机进行实现文件的传送而开发的应用程序，十分的方便可以实现文件的传送和接收，因为作者虚拟机的Linux主机有的时候会很卡顿，莫名的bug。。。。。因此我通常在Windows主机写好代码最开始最笨的方法是通过U盘来实现文件的迁移，但是效率太低了，通过开发这个应用程序可以非常方便的实现数据的收
python（二十七）——网络编程（TCP/UDP编程，客户端与服务器信息传输，多任务原理，进程间通信）
苦作舟的空城机
07-13 1065
目录 网络编程 TCP编程 客户端与服务器之间信息传输 UDP编程 多任务原理 启动进程池 进程间通信 网络编程 网络编程概述： 自从互联网诞生以来，现在基本上所有的程序都是网络程序，很少有单机版的程序了 计算机网络就是把各个计算机连接到一起，让网络中的计算机可以互相通信。网络编程就是如何在程序中实现两台计算机的通信 用Python进行网络编程，就是在Python程序本身这...
python网络编程实战项目(一)
qq_39838607的博客
07-25 1871
文章目录一、TCP/IP简介二、网络设计模块1.Socket简介2、python中的socket模块，使用该模块建立服务器需要6个步骤。1.创建socket对象。2.将socket绑定（指派）到指定地址上。3.绑定后必须准备好套接字，以便接收连接。4.服务器套接字通过socket的accept 方法等待客户请求一个连接。5.处理阶段，服务器和客户通过send和reext方法通信(传输数据)。6.传输结束，服务器调用socket的close方法以关闭连接。代码案列3、python中的socket模块，使用该.
计算机网络实验2：网络编程实验 python3
Moyu-42的博客
04-10 1273
代码地址：网络编程实验 实验目的 通过本实验，学习采用 Socket（套接字）设计简单的网络数据收发程序，理解应用数据 包是如何通过传输层进行传送的。 实验内容 Socket（套接字）是一种抽象层，应用程序通过它来发送和接收数据，就像应用程序打开一个文件句柄，将数据读写到稳定的存储器上一样。一个 socket 允许应用程序添加到网 络中，并与处于同一个网络中的其他应用程序进行通信。一台计算机上的应用程序向 socket 写入的信息能够被另一台计算机上的另一个应用程序读取，反之亦然。 不同类型的 socket
计算机网络原理实验 python socket 编程
weixin_40884491的博客
04-13 3317
网络原理课程 Python socket编程实验 一、实验内容 1.编写一个基于UDP协议的客户机与服务器程序，实现相互通讯。 2.编写一个基于TCP协议的客户机与服务器程序，实现相互通讯。 3.捕获以上两种通讯的数据包，使用Wireshark进行分析，以深入了解TCP、UDP协议的数据传输机制。 二、实验基础知识 1、TCP编程 （1）、建立一个TCP服务器连接需要6个步骤： ...
UDP通信——使用python实现简单的UDP通信
热门推荐
Keeplearning
05-15 3万+
使用python实现简单的UDP通信 UDP 的英文单词是User Datagram Protocol，缩写为UDP，是一种用户数据报协议，又称为用户数据报文协议，是一种报文的协议，是一个简单的面向数据报的传输层协议。UDP的发起和接受是不需要经过连接的，仅仅只需要发送在对应端口上进行监听接受即可，不需要两个客户端一定是连接的。 这里大家要区别的是：另一种常用的通信协议是TCP协议，两者的区别是T...
python 3 网络编程基础
01-01
Python 3 网络编程基础主要包括使用 socket 模块进行网络通信和使用 urllib.request 模块进行网络数据的获取。在Python 3中，可以使用 socket 模块创建套接字，并且可以通过套接字进行网络通信。套接字是网络编程中用于在网络上进行通信的接口，通过套接字可以与其他计算机建立连接并进行数据的传输。 此外，Python 3还提供了 urllib.request 模块，可以用于在网络上获取数据。使用 urllib.request 模块，可以很容易地获取URL链接上的数据，比如网页内容、图片文件等。同时，urllib.request 模块也支持对URL的请求和响应的处理，允许我们模拟浏览器的行为来获取网络数据。 另外，Python 3 还提供了一些用于处理网络数据的标准库，比如 http.server 和 http.client 等。http.server 模块提供了一个简单的 HTTP 服务器，可以用于处理 HTTP 请求，并且通过http.client 模块可以创建HTTP客户端用来发送HTTP请求。 总之，Python 3 网络编程基础主要包括使用 socket 模块进行网络通信，使用 urllib.request 模块进行网络数据的获取，以及 使用http.server 和 http.client 等标准库来处理网络数据。掌握这些基础知识可以帮助我们更好地进行网络编程，并且可以实现各种复杂的网络应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鱼树C

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值