了解http协议

http请求头

GET / HTTP/1.1

Host: www.baidu.com

Connection: keep-alive

Pragma: no-cache

Cache-Control: no-cache

Upgrade-Insecure-Requests: 1

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36

Sec-Fetch-Mode: navigate

Sec-Fetch-User: ?1

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3

Sec-Fetch-Site: none

Accept-Encoding: gzip, deflate, br

Accept-Language: zh-CN,zh;q=0.9,en;q=0.8

最主要的头两行分析如下：

  • 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来区分浏览器请求的是哪个网站。

http响应头

HTTP/1.1 200 OK

Bdpagetype: 2

Bdqid: 0x8ef7ae5901149cf7

Cache-Control: private

Connection: Keep-Alive

Content-Encoding: gzip

Content-Type: text/html;charset=utf-8

Date: Wed, 28 Aug 2019 01:59:49 GMT

Expires: Wed, 28 Aug 2019 01:59:48 GMT

Server: BWS/1.1

Set-Cookie: BDSVRTM=249; path=/

Set-Cookie: BD_HOME=1; path=/

Set-Cookie: H_PS_PSSID=1426_21111_20697_29522_29518_29099_29568_29220_26350; path=/; domain=.baidu.com

Strict-Transport-Security: max-age=172800

X-Ua-Compatible: IE=Edge,chrome=1

Transfer-Encoding: chunked

说明：

  • 200表示一个成功的响应，后面的OK是说明。
  • Content-Type指示响应的内容，这里是text/html表示HTML网页。
  • 请求头和响应头通过\r\n来换行。
  • 响应头和body响应体中也通过\r\n来分隔。

简单的http服务器

有多简单呢？运行程序后打开浏览器，只能显示hello world。

import socket

def service_client(new_socket):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    request = new_socket.recv(1024)

    print(request)

    # 返回http响应

    resposne = "HTTP/1.1 200 OK\r\n"

    resposne += "\r\n"

    resposne += "<h1>hello world</h1>"

    new_socket.send(resposne.encode("utf-8"))

    # 关闭套接字

    new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    while True:

        # 等在新客户端连接

        client, info = http_server.accept()

        # 为这个客户端服务

        service_client(client)

if __name__ == "__main__":

    main()

单进程http服务器

它上之前有一个升级就是可以返回静态的html页面。

import socket

import re

def service_client(new_socket):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    request = new_socket.recv(1024).decode("utf-8")

    # print(request)

    request_lines = request.splitlines()

    req = re.match(r"[^/]+(/\S*)", request_lines[0])

    file_name: str = ""

    if req:

        file_name = req.group(1)

        if file_name == "/":

            file_name = "/index.html"

        print(file_name)

    # print(request_lines)

    # 返回http响应

    try:

    	# 打开要请求的html文件，并返回给客户端。网页在当前路径的html文件夹里面。

        with open("./html" + file_name, "r", encoding="utf-8") as f:

            resposne = "HTTP/1.1 200 OK\r\n"

            resposne += "\r\n"

            # resposne += "<h1>hello world</h1>"

            resposne += f.read()

    except Exception as e:

        resposne = "HTTP/1.1 400 NOT FOUND\r\n"

        resposne += "\r\n"

        resposne += "--file not found--"

    new_socket.send(resposne.encode("utf-8"))

    # 关闭套接字

    new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    while True:

        # 等在新客户端连接

        client, info = http_server.accept()

        # 为这个客户端服务

        service_client(client)

if __name__ == "__main__":

    main()

多进程服务器

http服务器是完成了，但是如果同时有好多人访问的话它反应就会非常慢，所有又在之前的基础上做了升级，增加服务器的并发能力。

import socket

import re

from multiprocessing import Process

def service_client(new_socket):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    request = new_socket.recv(1024).decode("utf-8")

    # print(request)

    request_lines = request.splitlines()

    req = re.match(r"[^/]+(/\S*)", request_lines[0])

    file_name: str = ""

    if req:

        file_name = req.group(1)

        if file_name == "/":

            file_name = "/index.html"

        print(file_name)

    # print(request_lines)

    # 返回http响应

    try:

        with open("./html" + file_name, "r", encoding="utf-8") as f:

            resposne = "HTTP/1.1 200 OK\r\n"

            resposne += "\r\n"

            # resposne += "<h1>hello world</h1>"

            resposne += f.read()

    except Exception as e:

        resposne = "HTTP/1.1 400 NOT FOUND\r\n"

        resposne += "\r\n"

        resposne += "--file not found--"

    new_socket.send(resposne.encode("utf-8"))

    # new_socket.send(body)

    # 关闭套接字

    new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    while True:

        # 等在新客户端连接

        client, info = http_server.accept()

        # 开启一个子进程为这个客户端服务

        p = Process(target=service_client,args=(client,))

        p.start()

        # 子进程会复制主进程发的资源，故把主进程的socket关闭。

        client.close()

if __name__ == "__main__":

    main()

多线程服务器

我们知道进程耗费资源是非常大的，所以这次使用了耗费资源小的线程来实现多任务。

import socket

import re

from threading import Thread

def service_client(new_socket):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    request = new_socket.recv(1024).decode("utf-8")

    # print(request)

    request_lines = request.splitlines()

    req = re.match(r"[^/]+(/\S*)", request_lines[0])

    file_name: str = ""

    if req:

        file_name = req.group(1)

        if file_name == "/":

            file_name = "/index.html"

        print(file_name)

    # print(request_lines)

    # 返回http响应

    try:

        with open("./html" + file_name, "r", encoding="utf-8") as f:

            resposne = "HTTP/1.1 200 OK\r\n"

            resposne += "\r\n"

            # resposne += "<h1>hello world</h1>"

            resposne += f.read()

    except Exception as e:

        resposne = "HTTP/1.1 400 NOT FOUND\r\n"

        resposne += "\r\n"

        resposne += "--file not found--"

    new_socket.send(resposne.encode("utf-8"))

    # new_socket.send(body)

    # 关闭套接字

    new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    while True:

        # 等在新客户端连接

        client, info = http_server.accept()

        # 开启一个子线程为这个客户端服务

        p = Thread(target=service_client, args=(client,))

        p.start()

if __name__ == "__main__":

    main()

gevent协程版的服务器

协程在一个线程中执行，减少了线程之间的切换，多线程的升级版，拥有更好的处理能力。

import socket

import re

import gevent

from gevent import monkey

monkey.patch_all()

def service_client(new_socket):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    request = new_socket.recv(1024).decode("utf-8")

    # print(request)

    request_lines = request.splitlines()

    req = re.match(r"[^/]+(/\S*)", request_lines[0])

    file_name: str = ""

    if req:

        file_name = req.group(1)

        if file_name == "/":

            file_name = "/index.html"

        print(file_name)

    # print(request_lines)

    # 返回http响应

    try:

        with open("./html" + file_name, "r", encoding="utf-8") as f:

            resposne = "HTTP/1.1 200 OK\r\n"

            resposne += "\r\n"

            # resposne += "<h1>hello world</h1>"

            resposne += f.read()

    except Exception as e:

        resposne = "HTTP/1.1 400 NOT FOUND\r\n"

        resposne += "\r\n"

        resposne += "--file not found--"

    new_socket.send(resposne.encode("utf-8"))

    # new_socket.send(body)

    # 关闭套接字

    new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    while True:

        # 等在新客户端连接

        client, info = http_server.accept()

        # 为这个客户端服务

        gevent.spawn(service_client, client)

if __name__ == "__main__":

    main()

单进程非堵塞版长连接的服务器

从这个例子中来引入epoll版，它的性能应该要比协程的好，与之前所有服务器的不同之处就是采用了长连接，通过响应头中的Content-Length来指定响应体的长度，从而让浏览器知道页面数据传输完成以后自动在同一个套接字连接中继续发送其他资源文件的请求，效率较高。之前的都是短连接，只要传输完当前文件就关闭这个套接字。

import socket

import re

def service_client(new_socket: object, request: str):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    # request = new_socket.recv(1024).decode("utf-8")

    # print(request)

    request_lines = request.splitlines()

    req = re.match(r"[^/]+(/\S*)", request_lines[0])

    file_name: str = ""

    if req:

        file_name = req.group(1)

        if file_name == "/":

            file_name = "/index.html"

        print(file_name)

    # print(request_lines)

    # 返回http响应

    try:

        with open("./html" + file_name, "r", encoding="utf-8") as f:

            resposne_body: str = f.read()

            resposne_header: str = "HTTP/1.1 200 OK\r\n"

            resposne_header += "Content-Length:%d\r\n" % len(resposne_body)

            resposne_header += "\r\n"

            # resposne += "<h1>hello world</h1>"

            resposne = resposne_header + resposne_body

    except Exception as e:

        resposne = "HTTP/1.1 400 NOT FOUND\r\n"

        resposne += "\r\n"

        resposne += "--file not found--"

    new_socket.send(resposne.encode("utf-8"))

    # new_socket.send(body)

    # 关闭套接字

    # new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    # 设置套接字为非堵塞方式

    http_server.setblocking(False)

    socket_list: list = []

    while True:

        try:

            # 等在新客户端连接

            client, info = http_server.accept()

            # 为这个客户端服务

            # gevent.spawn(service_client, client)

        except Exception as e:

            # print(e)

            pass

        else:

            client.setblocking(False)

            socket_list.append(client)

        for socket_client in socket_list:

            try:

                recv_data: str = socket_client.recv(1024).decode("utf-8")

            except Exception as e:

                # print(e)

                pass

            else:

                if recv_data:

                    service_client(socket_client, recv_data)

                else:

                    socket_list.remove(socket_client)

                    socket_client.close()

if __name__ == "__main__":

    main()

eopll版的服务器

这个版本是性能最高的服务器。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。

import socket

import re

import select

def service_client(new_socket: object, request: str):

    # 接受浏览器发过来的http请求

    # GET / HTTP/1.1

    # request = new_socket.recv(1024).decode("utf-8")

    # print(request)

    request_lines = request.splitlines()

    req = re.match(r"[^/]+(/\S*)", request_lines[0])

    file_name: str = ""

    if req:

        file_name = req.group(1)

        if file_name == "/":

            file_name = "/index.html"

        print(file_name)

    # print(request_lines)

    # 返回http响应

    try:

        with open("./html" + file_name, "r", encoding="utf-8") as f:

            resposne_body: str = f.read()

            resposne_header: str = "HTTP/1.1 200 OK\r\n"

            resposne_header += "Content-Length:%d\r\n" % len(resposne_body)

            resposne_header += "\r\n"

            # resposne += "<h1>hello world</h1>"

            resposne = resposne_header + resposne_body

    except Exception as e:

        resposne = "HTTP/1.1 400 NOT FOUND\r\n"

        resposne += "\r\n"

        resposne += "--file not found--"

    new_socket.send(resposne.encode("utf-8"))

    # new_socket.send(body)

    # 关闭套接字

    # new_socket.close()

def main():

    # 创建套接字

    http_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 防止端口被占用无法启动程序

    http_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

    # 绑定端口

    http_server.bind(("", 80))

    # 变为监听套接字

    http_server.listen(128)

    # 设置套接字为非堵塞方式

    http_server.setblocking(False)

    # 创建一个epoll对象

    epl = select.epoll()

    # 将监听套接字对应的fd(文件描述符)注册到epoll中

    epl.register(http_server.fileno(), select.EPOLLIN)

    # 存储fd文件描述符和套接字的对应关系

    fd_event_dict: dict = {}

    while True:

        # 默认会堵塞，知道os检测到数据到来，通过事件通知方式告诉这个程序，此时才会解堵塞

        fd_event_list: list = epl.poll()  # [(套接字对应的文件描述符，这个文件描述符是什么事件),...]

        for fd, event in fd_event_list:

            # 如果是监听套接字有数据过来，即等待新的客户端连接

            if fd == http_server.fileno():

                client, info = http_server.accept()

                # 将新的套接字注册到epoll中

                epl.register(client.fileno(), select.EPOLLIN)

                # 把文件描述符和套接字的对应关系存入字典

                fd_event_dict[client.fileno()] = client

            elif event == select.EPOLLIN:

                # 判断已连接的套接字是否有数据发过来

                recv_data: str = fd_event_dict[fd].recv(1024).decode("utf-8")

                if recv_data:

                    service_client(fd_event_dict[fd], recv_data)

                else:

                    fd_event_dict[fd].close()

                    epl.unregister(fd)

                    del fd_event_dict[fd]

if __name__ == '__main__':

    main()

I/O 多路复用的特点：

通过一种机制使一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，epoll()函数就可以返回。 所以, IO多路复用，本质上不会有并发的功能，因为任何时候还是只有一个进程或线程进行工作，它之所以能提高效率是因为select\epoll 把进来的socket放到他们的 '监视' 列表里面，当任何socket有可读可写数据立马处理，那如果select\epoll 手里同时检测着很多socket， 一有动静马上返回给进程处理，总比一个一个socket过来,阻塞等待,处理高效率。

用python实现自己的http服务器——多进程、多线程、协程、单进程非堵塞版、epoll版的更多相关文章

  1. 进击的Python【第十章】：Python的socket高级应用（多进程，协程与异步）

    Python的socket高级应用(多进程,协程与异步)

  2. python采用 多进程/多线程/协程 写爬虫以及性能对比，牛逼的分分钟就将一个网站爬下来!

    首先我们来了解下python中的进程,线程以及协程! 从计算机硬件角度: 计算机的核心是CPU,承担了所有的计算任务.一个CPU,在一个时间切片里只能运行一个程序. 从操作系统的角度: 进程和线程,都 ...

  3. Python 多进程 多线程 协程 I/O多路复用

    引言 在学习Python多进程.多线程之前,先脑补一下如下场景: 说有这么一道题:小红烧水需要10分钟,拖地需要5分钟,洗菜需要5分钟,如果一样一样去干,就是简单的加法,全部做完,需要20分钟:但是, ...

  4. python 多进程/多线程/协程 同步异步

    这篇主要是对概念的理解: 1.异步和多线程区别:二者不是一个同等关系,异步是最终目的,多线程只是我们实现异步的一种手段.异步是当一个调用请求发送给被调用者,而调用者不用等待其结果的返回而可以做其它的事 ...

  5. Python自动化 【第十篇】：Python进阶-多进程/协程/事件驱动与Select\Poll\Epoll异步IO

    本节内容: 多进程 协程 事件驱动与Select\Poll\Epoll异步IO   1.  多进程 启动多个进程 进程中启进程 父进程与子进程 进程间通信 不同进程间内存是不共享的,要想实现两个进程间 ...

  6. web服务-2、四种方法实现并发服务器-多线程，多进程，协程，（单进程-单线程-非堵塞）

    知识点:1.使用多线程,多进程,协程完成web并发服务器 2.单进程-单线程-非堵塞也可以实现并发服务器 1.多进程和协程的代码在下面注释掉的部分,我把三种写在一起了 import socket im ...

  7. Python多线程、多进程和协程的实例讲解

    线程.进程和协程是什么 线程.进程和协程的详细概念解释和原理剖析不是本文的重点,本文重点讲述在Python中怎样实际使用这三种东西 参考: 进程.线程.协程之概念理解 进程(Process)是计算机中 ...

  8. python爬虫——多线程+协程（threading+gevent）

    上一篇博客中我介绍了如何将爬虫改造为多进程爬虫,但是这种方法对爬虫效率的提升不是非常明显,而且占用电脑cpu较高,不是非常适用于爬虫.这篇博客中,我将介绍在爬虫中广泛运用的多线程+协程的解决方案,亲测 ...

  9. python并发编程之进程、线程、协程的调度原理(六)

    进程.线程和协程的调度和运行原理总结. 系列文章 python并发编程之threading线程(一) python并发编程之multiprocessing进程(二) python并发编程之asynci ...

随机推荐

  1. python 绘制sinx

    code import turtle import math turtle.speed() turtle.penup() turtle., * math.sin((-/) * * math.pi)) ...

  2. HDFS 特殊权限位

    HDFS 特殊权限位 标签(空格分隔): Hadoop 之前对HDFS更或者说是对Linux中文件的权限没有进行一个完整的学习,只是知道有所有者.所属组和其它权限,具体到某个人的权限有读(r).写(w ...

  3. python能用来做什么？这3大主要用途你一定要知道！（实用）

    导读:如果你想学Python,或者你刚开始学习Python,那么你可能会问:“我能用Python做什么?” 这个问题不好回答,因为Python有很多用途. 但是随着时间,我发现有Python主要有以下 ...

  4. SpringMVC 请求映射注解

    @GetMapping: 处理get请求,传统的RequestMapping来编写应该是@RequestMapping(value = “/get/{id}”, method = RequestMet ...

  5. MySQL优化相关参数--先做个记录，以后可能用得到

    innodb_io_capacity:可设置的磁盘IO性能参数,越高代表当前mysql的IO性能更好,可用做决策刷脏页速度的参数: innodb_flush_neighbors:刷脏页是否开启连坐机制 ...

  6. DataFactory生产手机号码

    表中的数据类型是CHAR()类型的,才会出现,如右图的“Build a composite field”的这个功能: 固定部分设置 剩余变化部分设置 操作成功 数据库查询的结果

  7. linux的dos开关机命令

    常用:halt.reboot CentOS关机命令: 重启命令 reboot shutdown -r now 立刻重启 shutdown -r 10 过10分钟自动重启 shutdown -r 20: ...

  8. 九十一：CMS系统之cms用户模型定义

    数据库信息 DEBUG = TrueSQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:123456@127.0.0.1:3306/test'SQLALCH ...

  9. python同时执行两个函数

    使用两个线程同时执行两个函数, def fun1(): while True: time.sleep(2) print("fun1") def fun2(): while True ...

  10. SpringMVC,SpringBoot上传文件简洁代码

    @RequestMapping("/updateAvatar.html") public String updateHeadUrl(MultipartFile avatar, Mo ...