1、HTTP协议、HTML
在web应用中,服务器把网页传给浏览器,实际上就是把网页的HTML代码发送给浏览器,让浏览器显示出来。
HTTP是在网络上传输HTML的协议,用于浏览器和服务器的通信。
HTML是一种用来定义网页的文本,可以编写网页。
2、google浏览器的调试工具
快捷键:ctrl+shift+I打开
![](https://i-blog.csdnimg.cn/blog_migrate/fafac1e7ad485aad4ead389978853500.png)
说明:(1)Elements显示网页的结构。
(2)Network显示浏览器和服务器的通信。
在network页面,左上角出现红点,chrome就会记录所有浏览器和服务器之间的通信。
![](https://i-blog.csdnimg.cn/blog_migrate/cf6b176ef9593988e603109bea91d725.png)
3、http协议的分析
通过Network的记录,我们能知道浏览器都做了些什么
![](https://i-blog.csdnimg.cn/blog_migrate/50a75127d55e246b0597b2a49e2b9a53.png)
3.1 浏览器请求
当找到www.baidu.com这条记录时,点击,右侧将显示General、Response Headers、Request Headers,点击Request Headers右侧的view source,能够看到浏览器发送给百度服务器的请求。
![](https://i-blog.csdnimg.cn/blog_migrate/0ef24e243a94b93703b5ba03a381b123.png)
这些数据是有格式的,即HTTP协议。
说明:
GET / HTTP/1.1
GET表示一个读取请求,将从服务器获得网页数据,/表示url的路径,url总是以/开头,/就表示首页,最后的HTTP/1.1指示采用的HTTP协议版本是1.1。
HTTP协议的1.1版本和1.0版本的主要区别是1.1版本允许多个HTTP请求复用一个TCP连接,以加快传输速度。
Host www.baidu.com
表示请求的域名是www.baidu.com,当一台服务器有多个网站,服务器需要通过Host来区分浏览器请求的时哪个网站。
3.2 服务器响应
点击Response Headers右侧的view source,显示服务器返回的原始响应数据。
![](https://i-blog.csdnimg.cn/blog_migrate/f5fdda7835196f4c0fec08373db393ea.png)
HTTP响应分为Header和Body两部分(其中Body是可选项)。
HTTP/1.1 200 ok
200表示一个成功的响应,后面的ok是说明。
当返回的不是200,是404则表示网页不存在,是500则表示服务器内部出错。
Content-Type:text/html ...
Content-Type指示响应的内容,这里text/html表示HTML网页。
浏览器依靠Content-Type来判断响应的内容是网页还是图像,是视频还是音乐。
HTTP响应的Body就是HTML源码,‘查看网页源码’可以在浏览器中直接查看HTML源码。
3.3 浏览器解析过程
当浏览器读取到目标首页的HTML源码后,他会解析HTML并显示页面,然后根据HTML里面的各种链接再发送HTTP请求给目标的服务器,拿到相应的图片、视频、CSS等各种资源,最终显示出一个完整的页面。
4、HTTP总结
4.1 HTTP请求
4.1.1 步骤1:浏览器首先向服务器发送HTTP请求,请求包括:
方法:GET还是POST,GET仅请求资源,POST会附带用户数据;
路径:/full/url/path;
域名:由Host头指定:Host:www.baidu.com
以及其他相关的Header;
如果是POST,那么请求还包括一个Body,包含用户数据。
4.1.2 步骤2: 服务器向浏览器返回HTTP响应,响应包括:
响应代码:200表示成功,3xx表示重定向,4xx表示客户端发送的请求有错误,5xx表示服务器端处理时发生了错误;
响应类型:有Content-Type指定;
以及其他相关的Header;
通常服务器的HTTP响应会携带内容,即一个Body,包含响应的内容,网页的HTML源码就在Body中。
4.1.3 步骤3:如果浏览器还需要继续向服务器请求其他资源,就再次发出HTTP请求,重复步骤1、2。
HTTP协议同时具备极强的扩展性,虽然浏览器请求的是http://www.baidu.com
的首页,但是新浪在HTML中可以链入其他服务器的资源,比如<imgsrc="http://i1.sinaimg.cn/home/2013/1008/U8455P30DT20131008135420.png">
,从而将请求压力分散到各个服务器上,并且,一个站点可以链接到其他站点,无数个站点互相链接起来,就形成了World Wide Web,简称WWW。
为了分散服务器的压力,所以一个网站有多台服务器,比如一台存放图片,一台存放视频等。
4.2 HTTP格式
每个HTTP请求和响应都遵循相同的格式,一个HTTP包含Header和Body两部分,其中Body是可选的。
HTTP协议是一种文本协议,所以,它的格式也非常简单。
4.2.1 HTTP GET请求的格式
GET /path HTTP/1.1
Header1: Value1
Header2: Value2
Header3: Value3
每个Header一行一个,换行符是\r\n。
4.2.2 HTTP POST请求的格式
POST /path HTTP/1.1
Header1: Value1
Header2: Value2
Header3: Value3
body data goes here...
当遇到连续两个\r\n时,Header部分结束,后面的数据全部是Body。
4.2.3 HTTP响应的格式
HTTP/1.1 200 OK
Header1: Value1
Header2: Value2
Header3: Value3
body data goes here...
HTTP响应如果包含body,也是通过\r\n\r\n来分隔的。
请再次注意,Body的数据类型由Content-Type头来确定,如果是网页,Body就是文本,如果是图片,Body就是图片的二进制数据。
当存在Content-Encoding时,Body数据是被压缩的,最常见的压缩方式是gzip,所以,看到Content-Encoding: gzip时,需要将Body数据先解压缩,才能得到真正的数据。压缩的目的在于减少Body的大小,加快网络传输。
5、web静态服务器-1
import socket
def service_client(new_socket_client):
"""为这个客户端返回数据"""
# 接收浏览器发送过来的请求,即http请求
request = new_socket_client.recv(1024)
print(request)
# 返回http格式的数据,给浏览器
# 发送header
response = "HTTP/1.1 200 OK\r\n"
response += '\r\n'
# 发送body
response += "哈哈哈哈哈"
new_socket_client.send(response.encode("utf-8"))
# 关闭套接字
new_socket_client.close()
def main():
# 用来完成整体的控制
# 创建套接字
tcp_socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
# 绑定本地服务器
localaddr = ('',8080)
tcp_socket_server.bind(localaddr)
# 将主动套接字变成被动接听
tcp_socket_server.listen(128)
while True:
# 等待新客户端的链接
new_socket_client,client_addr = tcp_socket_server.accept()
# 服务客户端
service_client(new_socket_client)
# 关闭套接字
tcp_scoket_server.close()
if __name__=='__main__':
main()
6、web静态服务器-2(显示需要的页面)
需要的html页面
链接:https://pan.baidu.com/s/1RB8dPPu0mUtfmfGiPvOBbA
提取码:ipwx
import socket
import re
def service_client(new_socket_client):
"""为这个客户端返回数据"""
# 接收浏览器发送过来的请求,即http请求
request = new_socket_client.recv(1024).decode()
# print(request)
request_lines = request.splitlines()
print(request_lines)
# GET /index.html HTTP/1/1
file_name = re.match(r"[^/]+/([^ ]*)",request_lines[0])
if file_name:
file_name = file_name.group(1)
print("-"*50,file_name)
if file_name == '':
file_name = 'index.html'
# 返回http格式的数据,给浏览器
# 发送header
response = "HTTP/1.1 200 OK\r\n"
response += '\r\n'
# 发送body
# response += "哈哈哈哈哈"
# 读取html页面
try:
with open('./html/'+file_name,'rb') as f:
html_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
return_content = "Have not found file,please input innocent path"
new_socket_client.send(response.encode("utf-8"))
new_socket_client.send(return_content.encode("utf-8"))
else:
#发送header
new_socket_client.send(response.encode("utf-8"))
# 发送body
new_socket_client.send(html_content)
# 关闭套接字
new_socket_client.close()
def main():
# 用来完成整体的控制
# 创建套接字
tcp_socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定本地服务器
localaddr = ('',8080)
tcp_socket_server.bind(localaddr)
# 将主动套接字变成被动接听
tcp_socket_server.listen(128)
while True:
# 等待新客户端的链接
new_socket_client,client_addr = tcp_socket_server.accept()
# 服务客户端
service_client(new_socket_client)
# 关闭套接字
tcp_scoket_server.close()
if __name__=='__main__':
main()
7、web静态服务器-3(多进程)
import socket
import re
import threading
import multiprocessing
def service_client(new_socket_client):
"""为这个客户端返回数据"""
# 接收浏览器发送过来的请求,即http请求
request = new_socket_client.recv(1024).decode()
# print(request)
request_lines = request.splitlines()
print(request_lines)
# GET /index.html HTTP/1/1
file_name = re.match(r"[^/]+/([^ ]*)",request_lines[0])
if file_name:
file_name = file_name.group(1)
print("-"*50,file_name)
if file_name == '':
file_name = 'index.html'
# 返回http格式的数据,给浏览器
# 发送header
response = "HTTP/1.1 200 OK\r\n"
response += '\r\n'
# 发送body
# response += "哈哈哈哈哈"
# 读取html页面
try:
with open('./html/'+file_name,'rb') as f:
html_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
return_content = "Have not found file,please input innocent path"
new_socket_client.send(response.encode("utf-8"))
new_socket_client.send(return_content.encode("utf-8"))
else:
#发送header
new_socket_client.send(response.encode("utf-8"))
# 发送body
new_socket_client.send(html_content)
# 关闭套接字
new_socket_client.close()
def main():
# 用来完成整体的控制
# 创建套接字
tcp_socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定本地服务器
localaddr = ('',8080)
tcp_socket_server.bind(localaddr)
# 将主动套接字变成被动接听
tcp_socket_server.listen(128)
while True:
# 等待新客户端的链接
new_socket_client,client_addr = tcp_socket_server.accept()
p = multiprocessing.Process(target=service_client,args=(new_socket_client,))
p.start()
# 子进程会复制父进程的资源,所以需要关闭两次,类比硬链接
new_scoket_client.close()
# 关闭套接字
tcp_scoket_server.close()
if __name__=='__main__':
main()
8、web静态服务器-4(多线程)
import socket
import re
import threading
import multiprocessing
def service_client(new_socket_client):
"""为这个客户端返回数据"""
# 接收浏览器发送过来的请求,即http请求
request = new_socket_client.recv(1024).decode()
# print(request)
request_lines = request.splitlines()
print(request_lines)
# GET /index.html HTTP/1/1
file_name = re.match(r"[^/]+/([^ ]*)",request_lines[0])
if file_name:
file_name = file_name.group(1)
print("-"*50,file_name)
if file_name == '':
file_name = 'index.html'
# 返回http格式的数据,给浏览器
# 发送header
response = "HTTP/1.1 200 OK\r\n"
response += '\r\n'
# 发送body
# response += "哈哈哈哈哈"
# 读取html页面
try:
with open('./html/'+file_name,'rb') as f:
html_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
return_content = "Have not found file,please input innocent path"
new_socket_client.send(response.encode("utf-8"))
new_socket_client.send(return_content.encode("utf-8"))
else:
#发送header
new_socket_client.send(response.encode("utf-8"))
# 发送body
new_socket_client.send(html_content)
# 关闭套接字
new_socket_client.close()
def main():
# 用来完成整体的控制
# 创建套接字
tcp_socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定本地服务器
localaddr = ('',8080)
tcp_socket_server.bind(localaddr)
# 将主动套接字变成被动接听
tcp_socket_server.listen(128)
while True:
# 等待新客户端的链接
new_socket_client,client_addr = tcp_socket_server.accept()
t= threading.Thread(target=service_client,args=(new_socket_client,))
t.start()
# 关闭套接字
tcp_scoket_server.close()
if __name__=='__main__':
main()
9、web静态服务器-5(协程)
import socket
import re
import threading
import multiprocessing
from gevent import monkey
import gevent
monkey.patch_all()
def service_client(new_socket_client):
"""为这个客户端返回数据"""
# 接收浏览器发送过来的请求,即http请求
request = new_socket_client.recv(1024).decode()
# print(request)
request_lines = request.splitlines()
print(request_lines)
# GET /index.html HTTP/1/1
file_name = re.match(r"[^/]+/([^ ]*)",request_lines[0])
if file_name:
file_name = file_name.group(1)
print("-"*50,file_name)
if file_name == '':
file_name = 'index.html'
# 返回http格式的数据,给浏览器
# 发送header
response = "HTTP/1.1 200 OK\r\n"
response += '\r\n'
# 发送body
# response += "哈哈哈哈哈"
# 读取html页面
try:
with open('./html/'+file_name,'rb') as f:
html_content = f.read()
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
return_content = "Have not found file,please input innocent path"
new_socket_client.send(response.encode("utf-8"))
new_socket_client.send(return_content.encode("utf-8"))
else:
#发送header
new_socket_client.send(response.encode("utf-8"))
# 发送body
new_socket_client.send(html_content)
# 关闭套接字
new_socket_client.close()
def main():
# 用来完成整体的控制
# 创建套接字
tcp_socket_server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_socket_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
# 绑定本地服务器
localaddr = ('',8080)
tcp_socket_server.bind(localaddr)
# 将主动套接字变成被动接听
tcp_socket_server.listen(128)
while True:
# 等待新客户端的链接
new_socket_client,client_addr = tcp_socket_server.accept()
gevent.spawn(service_client,new_socket_client)
# 关闭套接字
tcp_scoket_server.close()
if __name__=='__main__':
main()
10、web静态服务器-6(非堵塞模式)
单进程非堵塞模型
#coding=utf-8
from socket import *
import time
# 用来存储所有的新链接的socket
g_socket_list = list()
def main():
server_socket = socket(AF_INET, SOCK_STREAM)
server_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR , 1)
server_socket.bind(('', 7890))
server_socket.listen(128)
# 将套接字设置为非堵塞
# 设置为非堵塞后,如果accept时,恰巧没有客户端connect,那么accept会
# 产生一个异常,所以需要try来进行处理
server_socket.setblocking(False)
while True:
# 用来测试
time.sleep(0.5)
try:
newClientInfo = server_socket.accept()
except Exception as result:
pass
else:
print("一个新的客户端到来:%s" % str(newClientInfo))
newClientInfo[0].setblocking(False) # 设置为非堵塞
g_socket_list.append(newClientInfo)
for client_socket, client_addr in g_socket_list:
try:
recvData = client_socket.recv(1024)
if recvData:
print('recv[%s]:%s' % (str(client_addr), recvData))
else:
print('[%s]客户端已经关闭' % str(client_addr))
client_socket.close()
g_socket_list.remove((client_socket,client_addr))
except Exception as result:
pass
print(g_socket_list) # for test
if __name__ == '__main__':
main()
单进程非堵塞实现
import time
import socket
import sys
import re
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root):
# 1. 创建套接字
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2. 绑定本地信息
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket.bind(("", port))
# 3. 变为监听套接字
self.server_socket.listen(128)
self.server_socket.setblocking(False)
self.client_socket_list = list()
self.documents_root = documents_root
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
# time.sleep(0.5) # for test
try:
new_socket, new_addr = self.server_socket.accept()
except Exception as ret:
print("-----1----", ret) # for test
else:
new_socket.setblocking(False)
self.client_socket_list.append(new_socket)
for client_socket in self.client_socket_list:
try:
request = client_socket.recv(1024).decode('utf-8')
except Exception as ret:
print("------2----", ret) # for test
else:
if request:
self.deal_with_request(request, client_socket)
else:
client_socket.close()
self.client_socket_list.remove(client_socket)
print(self.client_socket_list)
def deal_with_request(self, request, client_socket):
"""为这个浏览器服务器"""
if not request:
return
request_lines = request.splitlines()
for i, line in enumerate(request_lines):
print(i, line)
# 提取请求的文件(index.html)
# GET /a/b/c/d/e/index.html HTTP/1.1
ret = re.match(r"([^/]*)([^ ]+)", request_lines[0])
if ret:
print("正则提取数据:", ret.group(1))
print("正则提取数据:", ret.group(2))
file_name = ret.group(2)
if file_name == "/":
file_name = "/index.html"
# 读取文件数据
try:
f = open(self.documents_root+file_name, "rb")
except:
response_body = "file not found, 请输入正确的url"
response_header = "HTTP/1.1 404 not found\r\n"
response_header += "Content-Type: text/html; charset=utf-8\r\n"
response_header += "Content-Length: %d\r\n" % (len(response_body))
response_header += "\r\n"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8'))
# 将body返回给浏览器
client_socket.send(response_body.encode("utf-8"))
else:
content = f.read()
f.close()
response_body = content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length: %d\r\n" % (len(response_body))
response_header += "\r\n"
# 将header返回给浏览器
client_socket.send( response_header.encode('utf-8') + response_body)
# 设置服务器服务静态资源时的路径
DOCUMENTS_ROOT = "./html"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 2:
port = sys.argv[1]
if port.isdigit():
port = int(port)
else:
print("运行方式如: python3 xxx.py 7890")
return
print("http服务器使用的port:%s" % port)
http_server = WSGIServer(port, DOCUMENTS_ROOT)
http_server.run_forever()
if __name__ == "__main__":
main()
11、web静态服务器-7(epoll)
11.1 IO多路复用
IO多路复用,即select.poll.epoll,也称这种IO方式为event driven IO。
select/epoll的好处在于单个processs就可以同时处理多个网络连接的IO。
它的基本原理就是select,poll,epoll这个function会不断的轮询所负责的所有socket,当某个socket有数据到达了,就通知用户进程。
# epoll简单模型
import socket
import select
# 创建套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置可以重复使用绑定的信息
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
# 绑定本机信息
s.bind(("",7788))
# 变为被动
s.listen(10)
# 创建一个epoll对象
epoll = select.epoll()
# 测试,用来打印套接字对应的文件描述符
# print(s.fileno())
# print(select.EPOLLIN|select.EPOLLET)
# 注册事件到epoll中
# epoll.register(fd[, eventmask])
# 注意,如果fd已经注册过,则会发生异常
# 将创建的套接字添加到epoll的事件监听中
epoll.register(s.fileno(), select.EPOLLIN|select.EPOLLET)
connections = {}
addresses = {}
# 循环等待客户端的到来或者对方发送数据
while True:
# epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
epoll_list = epoll.poll()
# 对事件进行判断
for fd, events in epoll_list:
# print fd
# print events
# 如果是socket创建的套接字被激活
if fd == s.fileno():
new_socket, new_addr = s.accept()
print('有新的客户端到来%s' % str(new_addr))
# 将 conn 和 addr 信息分别保存起来
connections[new_socket.fileno()] = new_socket
addresses[new_socket.fileno()] = new_addr
# 向 epoll 中注册 新socket 的 可读 事件
epoll.register(new_socket.fileno(), select.EPOLLIN|select.EPOLLET)
# 如果是客户端发送数据
elif events == select.EPOLLIN:
# 从激活 fd 上接收
recvData = connections[fd].recv(1024).decode("utf-8")
if recvData:
print('recv:%s' % recvData)
else:
# 从 epoll 中移除该 连接 fd
epoll.unregister(fd)
# server 侧主动关闭该 连接 fd
connections[fd].close()
print("%s---offline---" % str(addresses[fd]))
del connections[fd]
del addresses[fd]
说明:(1)EPOLLIN(可读)
(2)EPOLLOUT(可写)
(3)EPOLLET(ET模式)
epoll对文件描述符的操作有两种模式:LT(level trigger)和ET(edge trigger)。
LT模式是默认模式,LT模式与ET模式的区别如下:
(1)LT模式:当epoll检测到描述符事件发生并将此事件通知应用程序,应用程序可以不立即处理该事件。下次调用epoll时,会再次响应应用程序并通知此事件。
(2)ET模式:当epoll检测到描述符事件发生并将此事件通知应用程序,应用程序必须立即处理该事件。如果不处理,下次调用epoll时,不会再次响应应用程序并通知此事件。
11.2 web静态服务器-epool
import socket
import time
import sys
import re
import select
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root):
# 1. 创建套接字
self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2. 绑定本地信息
self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket.bind(("", port))
# 3. 变为监听套接字
self.server_socket.listen(128)
self.documents_root = documents_root
# 创建epoll对象
self.epoll = select.epoll()
# 将tcp服务器套接字加入到epoll中进行监听
self.epoll.register(self.server_socket.fileno(), select.EPOLLIN|select.EPOLLET)
# 创建添加的fd对应的套接字
self.fd_socket = dict()
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
# epoll 进行 fd 扫描的地方 -- 未指定超时时间则为阻塞等待
epoll_list = self.epoll.poll()
# 对事件进行判断
for fd, event in epoll_list:
# 如果是服务器套接字可以收数据,那么意味着可以进行accept
if fd == self.server_socket.fileno():
new_socket, new_addr = self.server_socket.accept()
# 向 epoll 中注册 连接 socket 的 可读 事件
self.epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
# 记录这个信息
self.fd_socket[new_socket.fileno()] = new_socket
# 接收到数据
elif event == select.EPOLLIN:
request = self.fd_socket[fd].recv(1024).decode("utf-8")
if request:
self.deal_with_request(request, self.fd_socket[fd])
else:
# 在epoll中注销客户端的信息
self.epoll.unregister(fd)
# 关闭客户端的文件句柄
self.fd_socket[fd].close()
# 在字典中删除与已关闭客户端相关的信息
del self.fd_socket[fd]
def deal_with_request(self, request, client_socket):
"""为这个浏览器服务器"""
if not request:
return
request_lines = request.splitlines()
for i, line in enumerate(request_lines):
print(i, line)
# 提取请求的文件(index.html)
# GET /a/b/c/d/e/index.html HTTP/1.1
ret = re.match(r"([^/]*)([^ ]+)", request_lines[0])
if ret:
print("正则提取数据:", ret.group(1))
print("正则提取数据:", ret.group(2))
file_name = ret.group(2)
if file_name == "/":
file_name = "/index.html"
# 读取文件数据
try:
f = open(self.documents_root+file_name, "rb")
except:
response_body = "file not found, 请输入正确的url"
response_header = "HTTP/1.1 404 not found\r\n"
response_header += "Content-Type: text/html; charset=utf-8\r\n"
# 使用Content-Length,实现http的长连接
response_header += "Content-Length: %d\r\n" % len(response_body)
response_header += "\r\n"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8'))
# 将body返回给浏览器
client_socket.send(response_body.encode("utf-8"))
else:
content = f.read()
f.close()
response_body = content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
response_header += "\r\n"
# 将数据返回给浏览器
client_socket.send(response_header.encode("utf-8")+response_body)
# 设置服务器服务静态资源时的路径
DOCUMENTS_ROOT = "./html"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 2:
port = sys.argv[1]
if port.isdigit():
port = int(port)
else:
print("运行方式如: python3 xxx.py 7890")
return
print("http服务器使用的port:%s" % port)
http_server = WSGIServer(port, DOCUMENTS_ROOT)
http_server.run_forever()
if __name__ == "__main__":
main()
11.3 总结
I/O多路复用的特点:
通过一种机制使一个进程能同时等待多个文件描述符,而这些文件描述符(套接字描述符)其中的任意一个进入读就绪状态,epoll()函数就可以返回。 所以, IO多路复用,本质上不会有并发的功能,因为任何时候还是只有一个进程或线程进行工作,它之所以能提高效率是因为select\epoll 把进来的socket放到他们的 '监视' 列表里面,当任何socket有可读可写数据立马处理,那如果select\epoll 手里同时检测着很多socket, 一有动静马上返回给进程处理,总比一个一个socket过来,阻塞等待,处理高效率。
当然也可以多线程/多进程方式,一个连接过来开一个进程/线程处理,这样消耗的内存和进程切换页会耗掉更多的系统资源。 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发,IO复用负责提高接受socket的通知效率,收到请求后,交给进程池/线程池来处理逻辑。
11.4 epoll参考资料
https://blog.csdn.net/xiajun07061225/article/details/9250579