http协议及服务器搭建
HTTP协议
HTTP 即超文本传输协议,是在网络上传输HTML的协议,用于浏览器和服务器之间的通信
搭建简单的tcp服务器并发送数据给浏览器
例:
import socket
def service_client(new_soket):
'''为这个客户端返回数据'''
# 1.接收浏览器发送过来的请求,即HTTP请求
# GET / HTTP/101
request = new_soket.recv(1024)
print(request)
# 2.返回http格式的数据给浏览器
# 2.1 准备发送给浏览器的数据—— header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据——body
response += "<h1>hahaha<h1>"
new_soket.send(response.encode("utf-8"))
# 关闭套接字
new_soket.close()
def mian():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待新客户端的链接
new_soket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
service_client(new_soket)
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
mian()
tcp的3次握手、4次挥手
3次握手
第一次握手:建立连接时,客户端发送syn包(syn=j)到服务器,并进入SYN_SENT状态,等待服务器确认;SYN:同步序列编号(Synchronize Sequence Numbers)。
第二次握手:服务器收到syn包,必须确认客户的SYN(ack=j+1),同时自己也发送一个SYN包(syn=k),即SYN+ACK包,此时服务器进入SYN_RECV状态;
第三次握手:客户端收到服务器的SYN+ACK包,向服务器发送确认包ACK(ack=k+1),此包发送完毕,客户端和服务器进入ESTABLISHED(TCP连接成功)状态,完成三次握手。
4次挥手
1)客户端进程发出连接释放报文,并且停止发送数据。释放数据报文首部,FIN=1,其序列号为seq=u(等于前面已经传送过来的数据的最后一个字节的序号加1),此时,客户端进入FIN-WAIT-1(终止等待1)状态。 TCP规定,FIN报文段即使不携带数据,也要消耗一个序号。
2)服务器收到连接释放报文,发出确认报文,ACK=1,ack=u+1,并且带上自己的序列号seq=v,此时,服务端就进入了CLOSE-WAIT(关闭等待)状态。TCP服务器通知高层的应用进程,客户端向服务器的方向就释放了,这时候处于半关闭状态,即客户端已经没有数据要发送了,但是服务器若发送数据,客户端依然要接受。这个状态还要持续一段时间,也就是整个CLOSE-WAIT状态持续的时间。
3)客户端收到服务器的确认请求后,此时,客户端就进入FIN-WAIT-2(终止等待2)状态,等待服务器发送连接释放报文(在这之前还需要接受服务器发送的最后的数据)。
4)服务器将最后的数据发送完毕后,就向客户端发送连接释放报文,FIN=1,ack=u+1,由于在半关闭状态,服务器很可能又发送了一些数据,假定此时的序列号为seq=w,此时,服务器就进入了LAST-ACK(最后确认)状态,等待客户端的确认。
5)客户端收到服务器的连接释放报文后,必须发出确认,ACK=1,ack=w+1,而自己的序列号是seq=u+1,此时,客户端就进入了TIME-WAIT(时间等待)状态。注意此时TCP连接还没有释放,必须经过2∗∗MSL(最长报文段寿命)的时间后,当客户端撤销相应的TCB后,才进入CLOSED状态。
6)服务器只要收到了客户端发出的确认,立即进入CLOSED状态。同样,撤销TCB后,就结束了这次的TCP连接。可以看到,服务器结束TCP连接的时间要比客户端早一些。
注:本小节握手挥手内容转载自青柚_
原文:https://blog.csdn.net/qq_38950316/article/details/81087809
根据输入调整展示网页
例:
import socket
import re
def service_client(new_soket):
'''为这个客户端返回数据'''
# 1.接收浏览器发送过来的请求,即HTTP请求
# GET / HTTP/101
request = new_soket.recv(1024).decode('utf-8') # 对请求进行解码
request_lines = request.splitlines()
print('>>>'*50)
print(request_lines) # 对请求分拆成列表
# 'GET /index.htm HTTP/1.1'
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
file_name = ""
if ret:
file_name = ret.group(1)
print('*'*50, file_name)
if file_name == '/':
file_name = '/index.htm'
# 读取一个网页的数据,准备返回
try:
f = open('./html' + file_name, 'rb')
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------File not found------"
new_soket.send(response.encode('utf-8'))
else:
html_content = f.read()
# 2.返回http格式的数据给浏览器
# 2.1 准备发送给浏览器的数据—— header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据——header
# response += "<h1>hahaha<h1>"
new_soket.send(response.encode("utf-8"))
# 将网页html_content的数据发送过去,不能使用response+=来发送,需要直接再次send
new_soket.send(html_content)
# 关闭套接字
new_soket.close()
def main():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
'''设置当服务器先close 即服务器端挥手4次之后资源能够立即释放,这样就保证了,下次运行程序时,可以重复利用资源'''
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待新客户端的链接
new_soket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
service_client(new_soket)
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()
多任务和单任务的区别
多个浏览器和服务器建立连接时,由于都需要3次握手,如果访问的浏览器过多,服务器可能来不及accept
多进程实现http服务器
import socket
import re
import multiprocessing
def service_client(new_soket):
'''为这个客户端返回数据'''
# 1.接收浏览器发送过来的请求,即HTTP请求
# GET / HTTP/101
request = new_soket.recv(1024).decode('utf-8') # 对请求进行解码
request_lines = request.splitlines()
print('>>>'*50)
print(request_lines) # 对请求分拆成列表
# 'GET /index.htm HTTP/1.1'
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
file_name = ""
if ret:
file_name = ret.group(1)
print('*'*50, file_name)
if file_name == '/':
file_name = '/index.htm'
# 读取一个网页的数据,准备返回
try:
f = open('./html' + file_name, 'rb')
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------File not found------"
new_soket.send(response.encode('utf-8'))
else:
html_content = f.read()
# 2.返回http格式的数据给浏览器
# 2.1 准备发送给浏览器的数据—— header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据——header
# response += "<h1>hahaha<h1>"
new_soket.send(response.encode("utf-8"))
# 将网页html_content的数据发送过去,不能使用response+=来发送,需要直接再次send
new_soket.send(html_content)
# 关闭套接字
new_soket.close()
def main():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
'''设置当服务器先close 即服务器端挥手4次之后资源能够立即释放,这样就保证了,下次运行程序时,可以重复利用资源'''
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待新客户端的链接
new_soket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
p = multiprocessing.Process(target=service_client, args=(new_soket,))
p.start()
new_soket.close()
'''子进程中已经有close()了,为什么还要在这里调用呢?
因为进程实现多任务相当于复制了多份资源,如果不把原先主进程的new_socket关闭
则子进程的new_socket会指向同一个文件标识符,只有关闭后
才能开始正常的tcp4次挥手'''
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()
多线程实现http服务器
import socket
import re
import threading
def service_client(new_soket):
'''为这个客户端返回数据'''
# 1.接收浏览器发送过来的请求,即HTTP请求
# GET / HTTP/101
request = new_soket.recv(1024).decode('utf-8') # 对请求进行解码
request_lines = request.splitlines()
print('>>>'*50)
print(request_lines) # 对请求分拆成列表
# 'GET /index.htm HTTP/1.1'
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
file_name = ""
if ret:
file_name = ret.group(1)
print('*'*50, file_name)
if file_name == '/':
file_name = '/index.htm'
# 读取一个网页的数据,准备返回
try:
f = open('./html' + file_name, 'rb')
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------File not found------"
new_soket.send(response.encode('utf-8'))
else:
html_content = f.read()
# 2.返回http格式的数据给浏览器
# 2.1 准备发送给浏览器的数据—— header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据——header
# response += "<h1>hahaha<h1>"
new_soket.send(response.encode("utf-8"))
# 将网页html_content的数据发送过去,不能使用response+=来发送,需要直接再次send
new_soket.send(html_content)
# 关闭套接字
new_soket.close()
def main():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
'''设置当服务器先close 即服务器端挥手4次之后资源能够立即释放,这样就保证了,下次运行程序时,可以重复利用资源'''
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待新客户端的链接
new_soket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
p = threading.Thread(target=service_client, args=(new_soket,))
p.start()
# new_soket.close()
'''线程就不需要关闭了,共用资源'''
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()
协程实现http服务器
import socket
import re
import gevent
from gevent import monkey
monkey.patch_all()
def service_client(new_soket):
'''为这个客户端返回数据'''
# 1.接收浏览器发送过来的请求,即HTTP请求
# GET / HTTP/101
request = new_soket.recv(1024).decode('utf-8') # 对请求进行解码
request_lines = request.splitlines()
print('>>>'*50)
print(request_lines) # 对请求分拆成列表
# 'GET /index.htm HTTP/1.1'
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
file_name = ""
if ret:
file_name = ret.group(1)
print('*'*50, file_name)
if file_name == '/':
file_name = '/index.htm'
# 读取一个网页的数据,准备返回
try:
f = open('./html' + file_name, 'rb')
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------File not found------"
new_soket.send(response.encode('utf-8'))
else:
html_content = f.read()
# 2.返回http格式的数据给浏览器
# 2.1 准备发送给浏览器的数据—— header
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
# 2.2 准备发送给浏览器的数据——header
# response += "<h1>hahaha<h1>"
new_soket.send(response.encode("utf-8"))
# 将网页html_content的数据发送过去,不能使用response+=来发送,需要直接再次send
new_soket.send(html_content)
# 关闭套接字
new_soket.close()
def main():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
'''设置当服务器先close 即服务器端挥手4次之后资源能够立即释放,这样就保证了,下次运行程序时,可以重复利用资源'''
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
while True:
# 4.等待新客户端的链接
new_soket, client_addr = tcp_server_socket.accept()
# 5.为这个客户端服务
gevent.spawn(service_client, new_soket)
# new_soket.close()
# '''子进程中已经有close()了,为什么还要在这里调用呢?
# 因为进程实现多任务相当于复制了多份资源,如果不把原先主进程的new_socket关闭
# 则子进程的new_socket会指向同一个文件标识符,只有关闭后
# 才能开始正常的tcp4次挥手'''
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()
gevent实现过程剖析
原理类似于用单进程单线程接收多个socket,如下
import socket
def main():
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_server_socket.bind(("", 7890))
tcp_server_socket.listen(128)
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcp_server_socket.setblocking(False)
# 设置套接字为非堵塞,即在接收等待的过程中还可以接收新的套接字
client_socket_list = list() # 列表为空不影响程序运行,可以使用for循环
while True:
try:
new_socket, new_addr = tcp_server_socket.accept()
except Exception as ret:
print("----没有新的客户端到来----")
else:
print("----只要没有产生异常,那就意味着有一个新的客户端到来----")
client_socket_list.append(new_socket)
for client_socket in client_socket_list:
try:
recv_data = client_socket.recv(1024)
except Exception as ret:
print("---这个客户端没有发送数据---")
else:
if recv_data:
# 对方发送过来数据
print("----这个客户端发送了数据----")
else:
# 对方调用了close 导致了 recv返回
client_socket_list.remove(client_socket)
client_socket.close()
print("----客户端已经关闭----")
if __name__ == '__main__':
main()
长连接与短连接
http协议1.0版本是短连接,1.1是长连接
## 实现单进程-单线程-长连接
例:
import socket
import re
from gevent import monkey
monkey.patch_all()
def service_client(new_soket, request):
request_lines = request.splitlines()
print('>>>'*50)
print(request_lines) # 对请求分拆成列表
# 'GET /index.htm HTTP/1.1'
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
file_name = ""
if ret:
file_name = ret.group(1)
print('*'*50, file_name)
if file_name == '/':
file_name = '/index.htm'
# 读取一个网页的数据,准备返回
try:
f = open('./html' + file_name, 'rb')
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------File not found------"
new_soket.send(response.encode('utf-8'))
else:
html_content = f.read()
f.close()
response_body = html_content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length:%d\r\n" % len(response_body)
response_header += "\r\n"
response = response_header.encode("utf-8") + response_body
# 2.2 准备发送给浏览器的数据
new_soket.send(response)
# 关闭套接字
'''长连接是保持连接状态的,不需要close套接字'''
# new_soket.close()
def main():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
'''设置当服务器先close 即服务器端挥手4次之后资源能够立即释放,这样就保证了,下次运行程序时,可以重复利用资源'''
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
tcp_server_socket.setblocking(False) # 将套接字变为非堵塞
client_socket_list = list()
while True:
# 4.等待新客户端的链接
try:
new_soket, client_addr = tcp_server_socket.accept()
except Exception as ret:
pass
else:
new_soket.setblocking(False)
client_socket_list.append(new_soket)
for client_socket in client_socket_list:
try:
recv_data = client_socket.recv(1024).decode('utf-8')
except Exception as ret:
pass
else:
if recv_data:
service_client(new_soket, recv_data)
else:
client_socket.close()
client_socket_list.remove(client_socket)
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()
web静态服务器——epoll
epoll是当今LInux服务器里采用的方式,gevent在底层其实就是用epoll实现
即使用单进程单线程来实现高并发
epoll简单来说就是操作系统中有一部分内存是应用程序和kernel(即Linux核心系统,正常不给任何外部应用使用),在这部分内存内添加的所有需要判断、监听的套接字,在检测时不是采用轮询(即挨个遍历询问)的方式,而是事件通知(收到数据主动反馈是哪个套接字收到了)
例:本例只能在Linux下运行,因为win下的select没有epoll方法
import socket
import re
from gevent import monkey
import select
monkey.patch_all()
def service_client(new_soket, request):
request_lines = request.splitlines()
print('>>>'*50)
print(request_lines) # 对请求分拆成列表
# 'GET /index.htm HTTP/1.1'
ret = re.match(r"[^/]+(/[^ ]*)", request_lines[0])
file_name = ""
if ret:
file_name = ret.group(1)
print('*'*50, file_name)
if file_name == '/':
file_name = '/index.htm'
# 读取一个网页的数据,准备返回
try:
f = open('./html' + file_name, 'rb')
except:
response = "HTTP/1.1 404 NOT FOUND\r\n"
response += "\r\n"
response += "------File not found------"
new_soket.send(response.encode('utf-8'))
else:
html_content = f.read()
f.close()
response_body = html_content
response_header = "HTTP/1.1 200 OK\r\n"
response_header += "Content-Length:%d\r\n" % len(response_body)
response_header += "\r\n"
response = response_header.encode("utf-8") + response_body
# 2.2 准备发送给浏览器的数据——header
print('*>'*10, response)
new_soket.send(response)
# 关闭套接字
'''长连接是保持连接状态的,不需要close套接字'''
# new_soket.close()
def main():
'''用来完成整体的控制'''
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
'''设置当服务器先close 即服务器端挥手4次之后资源能够立即释放,这样就保证了,下次运行程序时,可以重复利用资源'''
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 2.绑定
tcp_server_socket.bind(("", 7890))
# 3.变为监听套接字
tcp_server_socket.listen(128)
tcp_server_socket.setblocking(False) # 将套接字变为非堵塞
client_socket_list = list()
# 创建一个epoll对象,相当于之前提及的共享的那部分内存
epl = select.epoll()
# 将监听套接字对应的fd注册到epoll
epl.register(tcp_server_socket.fileno(), select.EPOLLIN) # EPOLLIN用于检测套接字是否有输入
fd_event_dic = dict()
while True:
fd_event_list = epl.poll()
'''默认会堵塞,知道os检测到数据到来,通过事件通知方式告诉这个程序,此时才会解堵塞'''
# 上面返回的表格格式为:[(fd, event), (套接字对应的文件描述符, 这个文件描述符到底是什么事件 例如 可以调用recv接收等)]
for fd, event in fd_event_list:
# 4.等待新客户端的链接
if fd == tcp_server_socket.fileno():
# ↑这里用来判断是不是监听套接字,有产生新的套接字,再次循环的时候,判断到新的套接字时,九徽跳过这里
new_soket, client_addr = tcp_server_socket.accept()
epl.register(new_soket.fileno(), select.EPOLLIN) # 把新生产的套接字也注册到epoll
fd_event_dic[new_soket.fileno()] = new_soket
elif event == select.EPOLLIN:
# 判断已经链接的客户端是否有数据发送过来
recv_data = fd_event_dic[fd].recv(1024).decode("utf-8")
if recv_data:
service_client(fd_event_dic[fd], recv_data)
else: # 如果返回值为空,则需要关闭套接字,同时从epoll和之前建立的字典中移除它
fd_event_dic[fd].close()
epl.unregister(fd)
del fd_event_dic[fd]
# 关闭监听套接字
tcp_server_socket.close()
if __name__ == "__main__":
main()