史上最全的python的web开发和网络编程【附属详细解释+案例】
文章目录
- 1. IP 地址
- 2. 端口
-
- 2.1 端口 介绍
- 2.2 端口号 介绍
- 3. TCP
-
- 3.1 为什么要用TCP？
- 3.2 TCP 和 UDP 的 解释
- 3.3 TCP 步骤 和 特点
- 4. socket(套接字)
- 5. TCP 网络应用程序开发流程(重要)
-
- 5.1 刚安装ubuntu20遇到的问题
- 5.2 TCP 两个程序开发过程
- 5.3 TCP 客户端开发程序
- 5.3 TCP 服务端开发程序
- 6. TCP 端口复用(释放端口)
- 7. 在服务端中,如何判断客户端是否关闭？
- 8. TCP服务端 单进程函数模式
- 9. TCP服务端 多任务开发(多进程)
- 10. http 协议
-
- 10.1 HTTP 协议的介绍
- 10.2 HTTP 协议的作用
- 10.3 浏览器使用 HTTP 访问web服务器的 通信流程
- 11. URL 统一资源定位符
- 12. HTTP 请求报文
- 13. HTTP 响应报文(应答报文)
- 14. 静态web服务器
-
- 14.1 静态web服务器 基本代码
- 14.2 静态web服务器 传输文件(图片，html，css等等类型文件)
- 14.3 静态web服务器 指定页面
- 14.4 静态web服务器 使用try-catch来解决找不到路径。
- 14.5 静态web服务器 函数版本
- 14.6 静态web服务器 多任务
- 14.7 静态web服务器 面向对象
- 14.8 静态web服务器 终端启动
- 14.9 静态web服务器 动态绑定端口
1. IP 地址
IP 地址就是标识网络中设备的一个地址。
在平时，我们直接百度IP地址，就可以查到我们当前所在的互联网外网地址。
咱们通过ifconfig或ipconfig来查看本机的网络配置时，经常看到192.168.xxx.xxx。
像192.168.xxx.xxx，这样是我们通过互联网拿到的内网(局域网)地址。
IPv4(inet)详解 :
- IPv4的ip是由10进制数表示的。
- 1个字节最大就是255，255的二进制位：1111 1111。
- IPv4的IP是由4个字节组成的，因此IPv4是有限的，最大就是255。例如：255.255.255.1。
- 127.0.0.1 指的是本机地址。
IPv6(inet6)详解:
- IPv6的ip是由16进制数表示。
- IPv6的数量远远大于IPv4，IPv4地址已经不够用了。据说，IPv6可能给地球每一粒沙子赋予ip也是够用的，可见它的数量多么庞大。
目前都是一个小区或者很多人都共用一个IP公网地址，这样也算是缓解了IPv4数量有限的问题，但因为好多人共用一个IP地址网络的速度肯定不是很快！！！
2. 端口
2.1 端口 介绍
通过网络IP，将数据传送到电脑中，但是传递给谁呢？？？
飞秋？QQ?还是微信？或者其他软件,游戏子类的？
为了解决这一问题，就用到了端口(端口号)，每一个网络程序软件都会有一个端口，想要给对应的程序或软件发送数据，找到对应的端口即可。
端口是传输数据的通道，好比教师的门，是数据传输必经之路。
2.2 端口号 介绍
端口号：操作系统为了统一管理这么多端口，就对端口进行了编号，这就是端口号。
端口号有65536个。
并不是所有的程序都需要端口，例如闹钟，单机游戏等等不需要联网的程序软件。
端口号分类：(知名端口号，动态端口号)
3. TCP
TCP讲述的是C/S架构，客户端和服务端的通信过程。
3.1 为什么要用TCP？
网络应用程序之间的通信流程:
通过IP地址找到对应的设备，然后再通过端口号找到对应的端口，再通过端口把数据传输给应用程序。流程是这样的，但数据不能随便发送，在发送之前还需要选择一个对应的传输协议，保证程序之间按照指定的传输规则进行数据的通信，而这个传输协议就是TCP。
3.2 TCP 和 UDP 的 解释
TCP(Transmission Control Protocol)简称传输协议，它是一种面向连接，可靠的，基于字节流的传输层通信协议。TCP就是先确认(建立连接)，然后传输数据。
UDP(User Datagram Protocol)简称用户数据报协议，是一种无连接不可靠传输的传输协议，它是广播式，数据我只管发送过去，能不能接受我不管，就像发短信一样。因此由于它的不可靠传输，就容易产生丢包或接受不到数据的情况。
3.3 TCP 步骤 和 特点
TCP通信步骤：
- 创建连接
- 传输数据
- 关闭连接
解释一下，TCP的流量控制和阻塞管理：
意思就是发送方和接收方的网络流畅不一样，发送方一下次发送1g，而接收方接受很慢远小于1g，这个时候TCP协议，就会设定发送方的流量控制和阻塞管理，从而达到双方一个流量平衡的状态。
解释一下，可靠传输和不可靠传输：
其实就是丢不丢包，信息是否完整，可靠传输不会丢包！像TCP采用发送应答机制，超时重传等等功能，就绝不会产生丢包的情况。UDP没有这些功能，它只管发送，其他都不管，因此算是不可靠传输。
像平时的下载文件(百度网盘，迅雷)，QQ，微信，浏览器上网等都是必须要可靠传输，信息必须完整，因此这里都是TCP协议支撑。像直播类似的，都是UDP传输。
4. socket(套接字)
socket(简称 套接字) 是进程之间通信一个工具，就像生活中的插座，进程之间想要进行网络通信需要基于这个socket。
socket作用：负责进程之间的网络数据传输，好比数据的搬运工。
两个进程之间通过socket来传输数据：
5. TCP 网络应用程序开发流程(重要)
5.1 刚安装ubuntu20遇到的问题
-
mNetAssist 是linux系统中tcp调试工具(很重要)！！！
-
在ubuntu20中安装时，是没有ssh服务，需要安装openssh-server服务。
-
root密码开始不知道，可以通过sudo passwd，修改root密码。
ubuntu20.04版本系统，安装桌面系统：
#！/bin/bash
#更新软件库
apt-get update
#升级软件
apt-get upgrade
#安装ubuntu桌面系统
apt-get install ubuntu-desktop
5.2 TCP 两个程序开发过程
TCP 网络应用程序开发分为：
- TCP客户端程序开发
- TCP服务端程序开发
TCP客户端和TCP服务端的程序开发流程：
recv英文就是receive接受。
5.3 TCP 客户端开发程序
开发TCP客户端程序开发步骤：
- 创建客户端套接字对象
- 和服务端套接字建立连接
- 发送数据
- 接受数据
- 关闭客户端套接字
编解码：( encode()和decode() )
- 网络中必须传输二进制的数据。
- 字符串转换为二进制 encode(“utf8”)。
- 二进制转换成字符串decode(“utf8”)。
注意：utf-8编码的数据必须用utf-8解码！！
TCP客户端代码案例：
import socket
# 1. 创建客户端套接字对象
# socket的参数：
# 参数1：ipv4(指定ip协议的版本) ， 指定ip版本ipv4，ipv6等
# 参数2：选择协议(SOCK_STREAM指的就是tcp协议 ， 指定协议tcp，udp等)
tcp_client_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM);
# 2. 和服务端套接字建立连接
# 参数：元组(有两个元素)
# 两个元素分别是 服务器端IP地址(字符串形式) 和 服务器的端口号(正常数字形式)。
tcp_client_socket.connect(("192.168.2.70",8080))
# 3. 发送数据
# 发送数据的时候需要先转化为二进制形式，这就需要用到encode()方法定义。
# encode()方法默认为utf-8编码。
data = "123456"
tcp_client_socket.send(data.encode("utf8"))
# 4. 接受数据
# 参数：以字节为单位的接受的数据大小(1024)
recv_data = tcp_client_socket.recv(1024)
print(recv_data.decode("utf8"))
# 5. 关闭客户端套接字
tcp_client_socket.close()
5.3 TCP 服务端开发程序
开发TCP 服务端程序开发步骤：
- 创建服务端套接字对象。
- 绑定端口号。
- 设置监听。
- 等待接受客户端的连接请求。
- 接受数据。
- 发送数据。
- 关闭套接字。
import socket
# 1. 创建服务端套接字对象。
# 参数是相同的
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 2. 绑定端口号。
# 参数：元组(两个元素)
# 两个元素，分别是服务器IP地址(字符串) ，端口号(数字形式)
# 不写默认是本机的ip地址("127.0.0.1"或"")
# bind()的作用就是绑定自己服务器的端口号。
tcp_server_socket.bind(("",8080))
# 3. 设置监听。
# 参数：最大监听个数(就是排队处理的最大等待数量，如果在这个排队中排129超过了128个，就会报错。)
# 注意：经过了listen监听后，tcp_server_socket从主动套接字变成了被动套接字。
tcp_server_socket.listen(128)
# 4. 等待接受客户端的连接请求,如果没有发过来请求就阻塞等待接受客户端请求。(打电话的客服人员一样，等待用户打过来电话)
# 返回值：是一个元组(也是有两个元素)
# 返回值元素 =》 元素1：和客户端进行通讯的socket。 元素2：客户端的地址信息(ip地址,端口号)
# 我们可以用拆包语法，将元组中的两个元素，赋予了 client_socket ， client_addr 。
client_socket,client_addr = tcp_server_socket.accept()
# 5. 接受数据。
# 参数一样，设置接受数据的大小(1个字节)
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() # 一定要先关闭这个socket变量服务
tcp_server_socket.close()
注意：代码中有两个socket变量，tcp_server_socket 和 client_socket ，它们两个在代码中的作用也不同。
6. TCP 端口复用(释放端口)
端口复用设置作用: 一旦服务端关闭，端口立马释放。
import socket
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用设置:
# setsocketopt:设置socket选项
# 参数1：socket选项列表(SOL)
# 参数2：地址复用
# 参数3：True(开启选项)，默认(False：不开启选项)
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 端口复用设置作用: 一旦服务端关闭，端口立马释放。
tcp_server_socket.bind(("",8080))
tcp_server_socket.listen(128)
client_socket,client_addr = tcp_server_socket.accept()
client_data = client_socket.recv(1024)
client_data = client_data.decode()
print(client_data)
send_data = "123".encode()
client_socket.send(send_data)
client_socket.close()
tcp_server_socket.close()
7. 在服务端中,如何判断客户端是否关闭？
import socket
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
tcp_server_socket.bind(("",8080))
tcp_server_socket.listen(128)
client_socket,client_addr = tcp_server_socket.accept()
# 如果客户端关闭，这里也相应的应该关闭才对
while True:
# 如果客户端关闭，这里会接受到空数据，因此可以通过这个来判断客户端是否关闭。
client_data = client_socket.recv(1024)
# 通过判断长度为零，来确认是否关闭数据。
if len(client_data) == 0:
print("客户端关闭了！！！")
break;
client_data = client_data.decode()
print(client_data)
send_data = "123".encode()
client_socket.send(send_data)
client_socket.close()
tcp_server_socket.close()
8. TCP服务端 单进程函数模式
这里是一个主进程的TCP服务函数版本。
import socket
# 该函数用来处理客户端请求函数
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.decode()
print(client_data)
send_data = "123".encode()
client_socket.send(send_data)
client_socket.close()
def main():
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
tcp_server_socket.bind(("",8080))
tcp_server_socket.listen(128)
# 这个while目的是让服务器一直等待客户请求。
while True:
client_socket,client_addr = tcp_server_socket.accept()
# 处理客户端的请求
handler_client_request(client_socket)
client_socket.close()
tcp_server_socket.close()
if __name__ == '__main__':
main()
9. TCP服务端 多任务开发(多进程)
目前以上的操作都是单进程的操作，如果再开一个服务端就会等待，等第一个服务端资源释放后，再接受数据。
通过创建子进程，能够处理多个TCP客户端发送的数据。
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.decode()
print(client_data)
send_data = "123".encode()
client_socket.send(send_data)
client_socket.close()
def main():
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
tcp_server_socket.bind(("",8080))
tcp_server_socket.listen(128)
# 这个while目的是让服务器一直等待客户请求。
while True:
client_socket,client_addr = tcp_server_socket.accept()
# 通过创建子进程，能够处理多个TCP客户端发送的数据。
# 创建一个子进程
sub_process = multiprocessing.Process(target=handler_client_request,args=(client_socket,))
# 开启子进程
sub_process.start()
client_socket.close()
tcp_server_socket.close()
if __name__ == '__main__':
main()
socket不是将数据直接发送给网卡的，而是发送给缓冲区。
10. http 协议
http讲述的是B/S架构，浏览器和服务器之间的通信。
10.1 HTTP 协议的介绍
HTTP 协议全称为：HyperText Transfer Protocol，超文本传输协议。
超文本是超级文本的缩写，是指超越文本限制或者超链接，比如：图片，音乐，视频，超链接等等属于超文本。
传输HTTP协议格式的数据是基于TCP传输协议的，发送数据之前需要先建立连接。
也就是HTTP协议是一个基于TCP传输协议传输数据的。
10.2 HTTP 协议的作用
它规定了浏览器和Web服务器通信数据的格式，也就是说浏览器和web服务器通信需要使用http协议。
10.3 浏览器使用 HTTP 访问web服务器的 通信流程
平时我们访问像Facebook，谷歌商店这样的网站，没法访问，就是因为域名解析服务器被限制了，域名无法找到对应的ip地址，不让我们访问，因此才访问不到的。
https和http的区别：
- https是一种安全的网络通信协议。
- https就是对数据进行了加密而已(就因此才会安全)。
11. URL 统一资源定位符
URL的组成部分：
- 第一部分：协议部分: https// , http:// , ftp://。
- 第二部分：域名部分：例如：baidu.com 。
- 第三部分：资源路径部分：服务器端的资源路径位置。
12. HTTP 请求报文
请求报文：给服务端发送的数据，就是请求报文。
应答报文：给浏览器端回复的数据，就是应答报文。
请求报文的两种格式：
- get：只向服务器要数据，是不给服务器提供数据的。
- post：会给服务器提供数据。
请求报文的组成：(从上到下的部分)
- 请求行
- 请求头
- 空行
- 请求体(get方式没有请求体)
请求行格式：
GET /index.html HTTP/1.1(HTTP版本一直都是1.1版本) \r\n
请求方式 请求资源路径 协议版本(中间一定要有空格！！) \r\n
\r\n(\r是将光标放到前面，\n是将光标放置到下一行，这样就变成了换行到下面的第一个位置，在linux中必须写\r\n，win版本\r就行。)
请求头格式：
key:value \r\n
请求头采用的是键值形式，来设置网页相关属性。
空格格式：
\r\n
空格没啥格式，就是空行。
请求体格式：
name age addr 想要给服务器传递的数据。
13. HTTP 响应报文(应答报文)
响应报文的组成：
- 响应行
- 响应头
- 空行
- 响应体
响应行格式：
HTTP/1.1 200 OK \r\n
HTTP协议版本 状态码 状态描述
响应头格式：
key:value \r\n
同样也是设置应答数据的相关属性。
空行格式：
\r\n
响应体格式：
(浏览器中有一张百度的图片， 这个图片一定是响应体传输给浏览器的)
html css js 图片视频 服务器发送给浏览器的数据
14. 静态web服务器
14.1 静态web服务器 基本代码
就是在原来tcp协议的基础上面，添加上请求头请求行请求体空行等操作。
import socket
# 创建socket，对应tcp流式协议
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 绑定地址和端口
tcp_server_socket.bind(("",8080))
# 设置监听
tcp_server_socket.listen(128)
while True:
# 接受tcp链接请求
client_socket,addr = tcp_server_socket.accept()
# 接受数据
recv_data = client_socket.recv(100000)
if len(recv_data) == 0:
print("客户端关闭！！！")
break
# 解码查看接受的数据内容
print(recv_data.decode())
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体
response_body = "aaa"
# 响应数据
resonse_data = response_line+response_header+response_rn+response_body
# 发送数据,不要忘记编码
client_socket.send(resonse_data.encode())
client_socket.close()
# 这里不是循环聊天，而是向浏览器发送数据，因此只需要发送一次就可以了
14.2 静态web服务器 传输文件(图片，html，css等等类型文件)
import socket
# 创建socket，对应tcp流式协议
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 绑定地址和端口
tcp_server_socket.bind(("",8080))
# 设置监听
tcp_server_socket.listen(128)
while True:
# 接受tcp链接请求
client_socket,addr = tcp_server_socket.accept()
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
break
# 解码查看接受的数据内容
print(recv_data.decode())
# 打开资源文件, rb是read和二进制，二进制读取
# open中，可以添加html文件，css文件等等一系列。
f = open("D:/壁纸/3.jpg","rb")
# 存放了图片资源
file_data = f.read()
f.close()
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line+response_header+response_rn).encode()+response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
client_socket.close()
# 这里不是循环聊天，而是向浏览器发送数据，因此只需要发送一次就可以了
14.3 静态web服务器 指定页面
实质上就是对请求报文体进行切割，将路径提取出来，访问对应的页面。
import socket
# 创建socket，对应tcp流式协议
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 绑定地址和端口
tcp_server_socket.bind(("",8080))
# 设置监听
tcp_server_socket.listen(128)
while True:
# 接受tcp链接请求
client_socket,addr = tcp_server_socket.accept()
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
break
# 解码查看接受的数据内容
recv_data = recv_data.decode()
print("请求报文：",recv_data)
# 对请求报文进行切割
path_list = recv_data.split(" ")
print("列表：",path_list)
# 请求资源路径,实质上就是将路径从请求报文中提取出来，在open中打开而已
request_path = path_list[1]
# 打开资源文件, rb是read和二进制，二进制读取
f = open("./static"+request_path,"rb")
# 存放了图片资源
file_data = f.read()
f.close()
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line+response_header+response_rn).encode()+response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
client_socket.close()
# 这里不是循环聊天，而是向浏览器发送数据，因此只需要发送一次就可以了
14.4 静态web服务器 使用try-catch来解决找不到路径。
使用try-catch来判断文件路径是否存在，从而告知浏览器端。
import socket
# 创建socket，对应tcp流式协议
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 绑定地址和端口
tcp_server_socket.bind(("",8080))
# 设置监听
tcp_server_socket.listen(128)
while True:
# 接受tcp链接请求
client_socket,addr = tcp_server_socket.accept()
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
break
# 解码查看接受的数据内容
recv_data = recv_data.decode()
print("请求报文：", recv_data)
# 对请求报文进行切割
path_list = recv_data.split(" ")
print("列表：", path_list)
# 请求资源路径,实质上就是将路径从请求报文中提取出来，在open中打开而已
request_path = path_list[1]
# 异常捕获(防止出现异常的时候，服务器直接崩溃)
try:
# 打开资源文件, rb是read和二进制，二进制读取
f = open("./static" + request_path, "rb")
# 存放了图片资源
file_data = f.read()
f.close()
except Exception as e:
# 证明：文件不存在
print("异常问题",e)
# 既然不存在就返回404
# 响应行
response_line = "HTTP/1.1 404 NOT FOUND\r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = "404,not found i am sorry!!!"
resonse_data = response_line + response_header + response_rn+ response_body
client_socket.send(resonse_data.encode())
else:
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line+response_header+response_rn).encode()+response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
finally:
client_socket.close()
# 这里不是循环聊天，而是向浏览器发送数据，因此只需要发送一次就可以了
14.5 静态web服务器 函数版本
import socket
def handler_client_request(client_socket):
"""和浏览器处理浏览器请求的函数"""
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
return
# 解码查看接受的数据内容
recv_data = recv_data.decode()
print("请求报文：", recv_data)
# 对请求报文进行切割
path_list = recv_data.split(" ")
print("列表：", path_list)
# 请求资源路径,实质上就是将路径从请求报文中提取出来，在open中打开而已
request_path = path_list[1]
# 异常捕获(防止出现异常的时候，服务器直接崩溃)
try:
# 打开资源文件, rb是read和二进制，二进制读取
f = open("./static" + request_path, "rb")
# 存放了图片资源
file_data = f.read()
f.close()
except Exception as e:
# 证明：文件不存在
print("异常问题", e)
# 既然不存在就返回404
# 响应行
response_line = "HTTP/1.1 404 NOT FOUND\r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = "404,not found i am sorry!!!"
resonse_data = response_line + response_header + response_rn + response_body
client_socket.send(resonse_data.encode())
else:
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line + response_header + response_rn).encode() + response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
finally:
client_socket.close()
def main():
"""控制整个服务器流程的函数
tcp_server_socket: 用来接受连接的socket
client_socket: 用来处理和浏览器之间的数据交流的socket
"""
# 创建socket，对应tcp流式协议
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 绑定地址和端口
tcp_server_socket.bind(("",8080))
# 设置监听
tcp_server_socket.listen(128)
while True:
# 接受tcp链接请求
client_socket,addr = tcp_server_socket.accept()
# 调用处理浏览器请求的函数handler_client_request
handler_client_request(client_socket)
if __name__ == '__main__':
main()
14.6 静态web服务器 多任务
如果向上面这样，多个任务访问时就会卡死，因为是单进程，因此我们要创建多进程来操作。
我们通过使用多进程，来解决多个任务访问我们服务器。
import socket
import multiprocessing
import time
def handler_client_request(client_socket):
"""和浏览器处理浏览器请求的函数"""
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
return
# 解码查看接受的数据内容
recv_data = recv_data.decode()
print("请求报文：", recv_data)
# 对请求报文进行切割
path_list = recv_data.split(" ")
print("列表：", path_list)
# 请求资源路径,实质上就是将路径从请求报文中提取出来，在open中打开而已
request_path = path_list[1]
# 异常捕获(防止出现异常的时候，服务器直接崩溃)
try:
# 打开资源文件, rb是read和二进制，二进制读取
f = open("./static" + request_path, "rb")
# 存放了图片资源
file_data = f.read()
f.close()
except Exception as e:
# 证明：文件不存在
print("异常问题", e)
# 既然不存在就返回404
# 响应行
response_line = "HTTP/1.1 404 NOT FOUND\r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = "404,not found i am sorry!!!"
resonse_data = response_line + response_header + response_rn + response_body
client_socket.send(resonse_data.encode())
time.sleep(60)
client_socket.close()
else:
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line + response_header + response_rn).encode() + response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
# 设置一个time来延缓关闭，这样浏览器端就会一直转圈
time.sleep(60)
client_socket.close()
def main():
"""控制整个服务器流程的函数
tcp_server_socket: 用来接受连接的socket
client_socket: 用来处理和浏览器之间的数据交流的socket
"""
# 创建socket，对应tcp流式协议
tcp_server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 端口复用
tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
# 绑定地址和端口
tcp_server_socket.bind(("",8080))
# 设置监听
tcp_server_socket.listen(128)
while True:
# 接受tcp链接请求
client_socket,addr = tcp_server_socket.accept()
# 创建多进程
sub_process = multiprocessing.Process(target=handler_client_request,args=(client_socket,))
sub_process.start()
print(sub_process)
if __name__ == '__main__':
main()
14.7 静态web服务器 面向对象
面向对象就是通过使用class类来表现服务器启动等等。
import socket
import multiprocessing
class WebServer:
def __init__(self):
# 创建socket，对应tcp流式协议
self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 端口复用
self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
# 绑定地址和端口
self.tcp_server_socket.bind(("", 8080))
# 设置监听
self.tcp_server_socket.listen(128)
@staticmethod
def handler_client_request(client_socket):
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
return
# 解码查看接受的数据内容
recv_data = recv_data.decode()
print("请求报文：", recv_data)
# 对请求报文进行切割
path_list = recv_data.split(" ")
print("列表：", path_list)
# 请求资源路径,实质上就是将路径从请求报文中提取出来，在open中打开而已
request_path = path_list[1]
# 异常捕获(防止出现异常的时候，服务器直接崩溃)
try:
# 打开资源文件, rb是read和二进制，二进制读取
f = open("./static" + request_path, "rb")
# 存放了图片资源
file_data = f.read()
f.close()
except Exception as e:
# 证明：文件不存在
print("异常问题", e)
# 既然不存在就返回404
# 响应行
response_line = "HTTP/1.1 404 NOT FOUND\r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = "404,not found i am sorry!!!"
resonse_data = response_line + response_header + response_rn + response_body
client_socket.send(resonse_data.encode())
client_socket.close()
else:
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line + response_header + response_rn).encode() + response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
client_socket.close()
def start(self):
while True:
# 接受tcp链接请求
client_socket,addr = self.tcp_server_socket.accept()
# 创建多进程
sub_process = multiprocessing.Process(target=self.handler_client_request,args=(client_socket,))
sub_process.start()
print(sub_process)
if __name__ == '__main__':
web_server = WebServer()
web_server.start()
14.8 静态web服务器 终端启动
将文件上传到我的云服务器端。
直接远程服务器python3 xxx.py 运行就可以了。
14.9 静态web服务器 动态绑定端口
注意：一般的云服务端口都要配置安全规则，想要测试一定要开发端口号。
import socket
import multiprocessing
import sys
class WebServer:
# port默认可以设置为8080
def __init__(self,port1=8080):
# 创建socket，对应tcp流式协议
self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 端口复用
self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
# 绑定地址和端口
self.tcp_server_socket.bind(("", int(port1)))
# 设置监听
self.tcp_server_socket.listen(128)
@staticmethod
def handler_client_request(client_socket):
# 接受数据
recv_data = client_socket.recv(1000000)
if len(recv_data) == 0:
print("客户端关闭！！！")
return
# 解码查看接受的数据内容
recv_data = recv_data.decode()
print("请求报文：", recv_data)
# 对请求报文进行切割
path_list = recv_data.split(" ")
print("列表：", path_list)
# 请求资源路径,实质上就是将路径从请求报文中提取出来，在open中打开而已
request_path = path_list[1]
# 异常捕获(防止出现异常的时候，服务器直接崩溃)
try:
# 打开资源文件, rb是read和二进制，二进制读取
f = open("./static" + request_path, "rb")
# 存放了图片资源
file_data = f.read()
f.close()
except Exception as e:
# 证明：文件不存在
print("异常问题", e)
# 既然不存在就返回404
# 响应行
response_line = "HTTP/1.1 404 NOT FOUND\r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = "404,not found i am sorry!!!"
resonse_data = response_line + response_header + response_rn + response_body
client_socket.send(resonse_data.encode())
client_socket.close()
else:
# 响应行
response_line = "HTTP/1.1 200 OK \r\n"
# 响应头
response_header = "server:py1.0\r\n"
# 空行
response_rn = "\r\n"
# 响应体, 此时这里file_data是二进制形式
response_body = file_data
# 响应数据 ， 因为字符串和二进制不能相加的，所以将响应头响应行等都转换为二进制形式，在组合。
resonse_data = (response_line + response_header + response_rn).encode() + response_body
# 发送数据 因为上面转换了二进制，所以这里不需要在进行encode编码了
client_socket.send(resonse_data)
client_socket.close()
def start(self):
while True:
# 接受tcp链接请求
client_socket,addr = self.tcp_server_socket.accept()
# 创建多进程
sub_process = multiprocessing.Process(target=self.handler_client_request,args=(client_socket,))
sub_process.start()
print(sub_process)
if __name__ == '__main__':
# 获取动态端口
if len(sys.argv) != 2:
print("正确的格式是 python3 文件名 端口号 ")
else:
# print(sys.argv), 通过sys.argv来获得终端定义的端口 ，
# 注意的是argv[x]里面的内容，都是str字符串类型的，因此可能涉及转换类型的问题，要注意！
port = sys.argv[1]
port1 = int(port)
web_server = WebServer(port1)
web_server.start()
# 在终端运行python3 静态web服务器-动态绑定端口 9090
# 让服务者自定义端口号，例如9090