HTTP协议：超文本传输协议，在浏览器发送请求给服务器时，服务器会收到按照HTTP协议规定的格式的请求字符串，并且服务器对浏览器应答时也必须按照HTTP协议规定的格式进行应答
实例：
`
百度服务器所返回的数据请求：
Response Headers + body
● 区分header和body的就是空一行，再没出现空一行之前全部都属于header头数据。
● header 为规范的协议格式， body为展现给服务器展现给浏览器的内容
·
·
·
简单web服务器的搭建，返回浏览器需要的页面
示例代码(短连接)：
# -*- coding:utf-8 -*-
import socket
import re
def handle_data(new_client_socket):
"""处理客户端服务"""
# 接收客户端发来的请求
recv_data = new_client_socket.recv(1204*1024).decode("utf-8")
# 将请求内容按行分割保存在数组里
recv_data_list = recv_data.splitlines()
print(recv_data_list)
# 通过正则表达式，找到请求内容里面的请求页面路径
find_dire = re.match(r"[^/]+(/[^ ]*)", recv_data_list[0])
# 这个路径如果为根目录时，保存一个html界面，group(1)第二个括号里的内容
find_data = find_dire.group(1)
if find_data == "/":
find_data = "./1.html"
# 打开请求页面的路径文件，如果服务器中存在这个路径下的文件则发送给客户端数据内容(按照HTTP协议)
try:
f = open(find_data, "rb")
except:
print("文件没有打开")
responds = "HTTP/1.1 404 NOT FOUND\r\n"
responds += "\r\n"
responds += "file not found"
new_client_socket.send(responds.encode("gbk"))
else:
print("文件打开")
content = f.read()
f.close()
responds = "HTTP/1.1 200 OK \r\n"
responds += "\r\n"
new_client_socket.send(responds.encode("utf-8"))
new_client_socket.send(content)
# 关闭服务客户端的套接字
new_client_socket.close()
def main():
# 创建服务器套接字
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置服务器先close 即服务器端4次挥手之后资源能够立即释放，这样就保证下次运行程序前，端口资源不会被占用
tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定服务器端口
tcp_socket.bind(("", 7890))
# 将服务器套接字改主动为被动
tcp_socket.listen(128)
while True:
# 设置监听状态，并返回为客户端服务的套接字和客户端地址
new_client_socket, client_addr = tcp_socket.accept()
handle_data(new_client_socket)
# 关闭服务器套接字
tcp_socket.close()
if __name__ == "__main__":
main()
·
用多任务的方式实现http服务器
1.多进程(短连接)：
代码：
# -*- coding:utf-8 -*-
import socket
import re
import multiprocessing
def handle_data(new_client_socket):
"""处理客户端服务"""
# 接收客户端发来的请求
recv_data = new_client_socket.recv(1204*1024).decode("utf-8")
# 将请求内容按行分割保存在数组里
recv_data_list = recv_data.splitlines()
print(recv_data_list)
# 通过正则表达式，找到请求内容里面的请求页面路径
find_dire = re.match(r"[^/]+(/[^ ]*)", recv_data_list[0])
# 这个路径如果为根目录时，保存一个html界面
find_data = find_dire.group(1)
if find_data == "/":
find_data = "./1.html"
# 打开请求页面的路径文件，如果服务器中存在这个路径下的文件则发送给客户端数据内容(按照HTTP协议)
try:
f = open(find_data, "rb")
except:
print("文件没有打开")
responds = "HTTP/1.1 404 NOT FOUND\r\n"
responds += "\r\n"
responds += "file not found"
new_client_socket.send(responds.encode("gbk"))
else:
print("文件打开")
content = f.read()
f.close()
responds = "HTTP/1.1 200 OK \r\n"
responds += "\r\n"
new_client_socket.send(responds.encode("utf-8"))
new_client_socket.send(content)
# 关闭服务客户端的套接字
new_client_socket.close()
def main():
# 创建服务器套接字
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置服务器先close 即服务器端4次挥手之后资源能够立即释放，这样就保证下次运行程序前，端口资源不会被占用
tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定服务器端口
tcp_socket.bind(("", 7890))
# 将服务器套接字改主动为被动
tcp_socket.listen(128)
while True:
# 设置监听状态，并返回为客户端服务的套接字和客户端地址
new_client_socket, client_addr = tcp_socket.accept()
# 创建进程， 后面传入的参数args必须是一个元组类型，因此new_client_socket后面加个 ，
p = multiprocessing.Process(target=handle_data, args=(new_client_socket,))
# 开始进程
p.start()
# 由于在调用进程后，所有的局部变量全局变量等等全部被完全复制了一遍，那么对于一个客户端就存在了两个new_client_socket，如果不关掉主进程中的new_client_socket，那么在子进程中即便调用了服务客户端套接字的close()方法也不会开始进行四次挥手，客户端会一直等待
new_client_socket.close()
# 关闭服务器套接字
tcp_socket.close()
if __name__ == "__main__":
main()
·
注：由于在调用进程后，所有的局部变量全局变量等等全部被完全复制了一遍，那么对于一个客户端就存在了两个new_client_socket，如果不关掉主进程中的new_client_socket，那么在子进程中即便调用了服务客户端套接字的close()方法也不会开始进行四次挥手，则导致客户端会一直等待
·
·
2.多线程(短连接)：
代码：
# -*- coding:utf-8 -*-
import socket
import re
import threading
def handle_data(new_client_socket):
"""处理客户端服务"""
# 接收客户端发来的请求
recv_data = new_client_socket.recv(1204*1024).decode("utf-8")
# 将请求内容按行分割保存在数组里
recv_data_list = recv_data.splitlines()
print(recv_data_list)
# 通过正则表达式，找到请求内容里面的请求页面路径
find_dire = re.match(r"[^/]+(/[^ ]*)", recv_data_list[0])
# 这个路径如果为根目录时，保存一个html界面
find_data = find_dire.group(1)
if find_data == "/":
find_data = "./1.html"
# 打开请求页面的路径文件，如果服务器中存在这个路径下的文件则发送给客户端数据内容(按照HTTP协议)
try:
f = open(find_data, "rb")
except:
print("文件没有打开")
responds = "HTTP/1.1 404 NOT FOUND\r\n"
responds += "\r\n"
responds += "file not found"
new_client_socket.send(responds.encode("gbk"))
else:
print("文件打开")
content = f.read()
f.close()
responds = "HTTP/1.1 200 OK \r\n"
responds += "\r\n"
new_client_socket.send(responds.encode("utf-8"))
new_client_socket.send(content)
# 关闭服务客户端的套接字
new_client_socket.close()
def main():
# 创建服务器套接字
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置服务器先close 即服务器端4次挥手之后资源能够立即释放，这样就保证下次运行程序前，端口资源不会被占用
tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定服务器端口
tcp_socket.bind(("", 7890))
# 将服务器套接字改主动为被动
tcp_socket.listen(128)
while True:
# 设置监听状态，并返回为客户端服务的套接字和客户端地址
new_client_socket, client_addr = tcp_socket.accept()
t = threading.Thread(target = handle_data, args=(new_client_socket,))
t.start()
# 关闭服务器套接字
tcp_socket.close()
if __name__ == "__main__":
main()
`
`
3.协程：
代码(短连接)：
# -*- coding:utf-8 -*-
import socket
import re
import gevent
from gevent import monkey
# 将所有延时操作的代码自动转化成gevent下的延时操作
monkey.patch_all()
def handle_data(new_client_socket):
"""处理客户端服务"""
# 接收客户端发来的请求
recv_data = new_client_socket.recv(1204*1024).decode("utf-8")
# 将请求内容按行分割保存在数组里
recv_data_list = recv_data.splitlines()
print(recv_data_list)
# 通过正则表达式，找到请求内容里面的请求页面路径
find_dire = re.match(r"[^/]+(/[^ ]*)", recv_data_list[0])
# 这个路径如果为根目录时，保存一个html界面
find_data = find_dire.group(1)
if find_data == "/":
find_data = "./1.html"
# 打开请求页面的路径文件，如果服务器中存在这个路径下的文件则发送给客户端数据内容(按照HTTP协议)
try:
f = open(find_data, "rb")
except:
print("文件没有打开")
responds = "HTTP/1.1 404 NOT FOUND\r\n"
responds += "\r\n"
responds += "file not found"
new_client_socket.send(responds.encode("gbk"))
else:
print("文件打开")
content = f.read()
f.close()
responds = "HTTP/1.1 200 OK \r\n"
responds += "\r\n"
new_client_socket.send(responds.encode("utf-8"))
new_client_socket.send(content)
# 关闭服务客户端的套接字
new_client_socket.close()
def main():
# 创建服务器套接字
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置服务器先close 即服务器端4次挥手之后资源能够立即释放，这样就保证下次运行程序前，端口资源不会被占用
tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定服务器端口
tcp_socket.bind(("", 7890))
# 将服务器套接字改主动为被动
tcp_socket.listen(128)
while True:
# 设置监听状态，并返回为客户端服务的套接字和客户端地址
new_client_socket, client_addr = tcp_socket.accept()
gevent.spawn(handle_data, new_client_socket)
# 关闭服务器套接字
tcp_socket.close()
if __name__ == "__main__":
main()
`
`
`
用单进程、单线程实现并发（非阻塞原理）（效率较低,资源较少）
用多任务去实现http服务器，是因为在为客户端服务的套接字调用recv()方法后，会产生阻塞 (等待客户端将数据发过来) ，为了避免服务器因为阻塞而暂时无法接收其他客户端发来的连接请求，使用多任务可以将接收客户端数据的任务交给子进程(或子线程)去做，主进程(主线程)继续等待其他客户端的连接
·
那么如何用单进程、单线程去实现并发呢？
将阻塞解开即可：
服务器套接字.setblocking(False) # 设置服务器套接字为非阻塞的方式
·
实验代码(短连接)：
import socket
import time
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcp_socket.bind(("", 7890))
tcp_socket.listen(128)
tcp_socket.setblocking(False) # 设置此套接字非堵塞
socket_list = list()
while True:
time.sleep(1)
# 当非堵塞状态下出现了堵塞会报出错误
try:
new_client_socket, client_addr = tcp_socket.accept()
except Exception as ret:
print("没有客户端连接服务器")
else:
print("接收到客户端的连接")
new_client_socket.setblocking(False)
socket_list.append(new_client_socket)
for client_socket in socket_list:
try:
recv_data = client_socket.recv(1024)
except Exception as ret:
print("服务器还没有收到客户端的信息")
else:
if recv_data:
print("客户端发来了数据", recv_data)
else:
print("客户端调用了close(),导致返回recv()")
client_socket.close()
socket_list.remove(client_socket)
·
实验结果：
·
·
·
关于长连接(HTTP/1.1)和短连接(HTTP/1.0)
·
短连接：在浏览器每次向服务器获取资源都会进行三次握手四次挥手
长连接：浏览器与服务器在第一次三次握手后连接不断开，在每次向服务器请求资源的时候，服务器不创建新的套接字，直接返回资源给浏览器，直到四次挥手结束连接
·
问题：浏览器在短连接中，当服务器新创建的套接字调用close()方法后，浏览器才知道服务器数据发送完了，才会将数据显示在界面中。那么在长连接中，浏览器如何知道服务器每次返回给浏览器的数据发送完了？
答：在服务器返回给浏览器的头文件中添加每次发送数据的长度，这样浏览器在服务器每次发送的数据到指定长度后会主动调用close()方法
responds_header = “Content-Length:%d
\r\n” % len(responds_body)
·
代码实例(单进程单线程实现长连接)（效率较低，资源较少）：
# -*- coding:utf-8 -*-
import socket
import re
def service_client(client_socket, recv_data):
request_header = recv_data.splitlines()
find_data = re.match(r"^[^/]+(/[^ ]*)", request_header[0]).group(1)
if find_data == "/":
find_data = "./1.html"
print(find_data)
try:
f = open(find_data, "rb")
except Exception as ret:
responds = "HTTP/1.1 404 NOT FOUND\r\n"
responds += "\r\n"
responds += "file not found"
client_socket.send(responds.encode("utf-8"))
else:
content = f.read()
f.close()
responds_body = content
responds_header = "HTTP/1.1 200 OK\r\n"
# 服务器返回给浏览器的头文件中添加发送数据的长度
responds_header += "Content-Length:%d\r\n" % len(responds_body)
responds_header += "\r\n"
responds = responds_header.encode("utf-8") + responds_body
client_socket.send(responds)
def main():
tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcp_socket.bind(("", 7890))
tcp_socket.listen(128)
new_client_socketList = list()
tcp_socket.setblocking(False)
while True:
try:
new_client_socket, client_addr = tcp_socket.accept()
except Exception as ret:
pass
else:
new_client_socketList.append(new_client_socket)
new_client_socket.setblocking(False)
for client_socket in new_client_socketList:
try:
recv_data = client_socket.recv(1024).decode("utf-8")
except Exception as ret:
pass
else:
if recv_data:
service_client(client_socket, recv_data)
else:
client_socket.close()
new_client_socketList.remove(client_socket)
tcp_socket.close()
if __name__ == "__main__":
main()
·
·
·
关于Linux中epoll原理
在Linux下用单进程、单线程去实现http服务器用的是epoll原理
在上面我们实现的单进程、单线程是把新创建的套接字保存在应用程序创建出的列表里，在用for循环遍历的时候，操作系统把每个套接字一个一个复制到操作系统独有的内存空间里，再一个一个查看是否有信息到来，这样一个一个查看(简称：轮询) 导致效率非常的低
而epoll原理就是在Linux中有一片特殊的内存空间，应用程序和操作系统共享的内存空间，在这片空间中，操作系统不必将套接字一个一个复制到自己的内存空间查看，直接在这片共享内存空间中，哪个套接字接收到了信息就直接处理谁(简称：事件通知)，这样的效率是最快的。
实现代码：
# -*- coding: utf-8 -*-
import socket
import re
import select
def http_sever(new_socket, recv_data):
recv_data_list = recv_data.splitlines()
file_name = re.match(r"[^/]+(/[^ ]*)",recv_data_list[0]).group(1)
http_body = ""
http_header = ""
if file_name == "/":
file_name = "./1.html"
try:
f = open(file_name, "rb")
except Exception as ret:
http_body = "<h1>Sorry not found</h1>".encode("utf-8")
http_header = "HTTP/1.1 404 NOT FOUND\r\n"
http_header += "Content-Length:%d\r\n\r\n" % len(http_body)
else:
http_body = f.read()
f.close()
http_header = "HTTP/1.1 200 OK\r\n"
http_header += "Content-Length:%d\r\n" % len(http_body)
http_header += "\r\n"
new_socket.send(http_header.encode("utf-8"))
new_socket.send(http_body)
def main():
tcp_sever_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_sever_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcp_sever_socket.bind(("",8080))
tcp_sever_socket.listen(128)
# 设置非堵塞
tcp_sever_socket.setblocking(False)
client_lists = list()
# 创建一个epoll对象
epl = select.epoll()
# 将服务器套接字对应的fd和需要os做的事件(接收或发出)注册到epoll(共享内存空间)中
epl.register(tcp_sever_socket.fileno(), select.EPOLLIN)
socket_dict = dict()
while True:
# 默认阻塞，直到os监测到数据到来，通过事件通知方式告诉这个程序，此时才会解阻塞，返回一个列表(由多个元组组成)
epl_list = epl.poll()
# 每个元组中保存着fd和需要os所做的事件(接收或发出)
for fd,event in epl_list:
if fd == tcp_sever_socket.fileno():
new_socket, new_add = tcp_sever_socket.accept()
# 将新创建的套接字的fd和os待做的事件注册到epoll中
epl.register(new_socket.fileno(), select.EPOLLIN)
# 用字典保存新创建的套接字对象
socket_dict[new_socket.fileno()] = new_socket
# 当遍历为客户端服务的的套接字
else:
recv_data = socket_dict[fd].recv(1024).decode("utf-8")
# 判断收到的信息是否为空
if recv_data:
http_sever(socket_dict[fd], recv_data)
else:
# 关闭为客户端服务的套接字
socket_dict[fd].close()
# 删除字典中该套接字信息
del socket_dict[fd]
tcp_sever_socket.close()
if __name__ == '__main__':
main()
● fd 对应操作系统低层的一个资源或文件，为数字
● select.EPOLLIN 和select.EPOLLET 操作系统检测套接字的接收还是发送
100
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
