三、http协议、web服务器

1、HTTP协议、HTML

　　在web应用中，服务器把网页传给浏览器，实际上就是把网页的HTML代码发送给浏览器，让浏览器显示出来。

　　HTTP是在网络上传输HTML的协议，用于浏览器和服务器的通信。

　　HTML是一种用来定义网页的文本，可以编写网页。

2、google浏览器的调试工具

　　快捷键：ctrl+shift+I打开

 　　说明：（1）Elements显示网页的结构。

　　　　　 （2）Network显示浏览器和服务器的通信。

　　　　　　　　在network页面，左上角出现红点，chrome就会记录所有浏览器和服务器之间的通信。

　　　　　　　　

 3、http协议的分析

　　通过Network的记录，我们能知道浏览器都做了些什么

　　

 　　3.1 浏览器请求

　　当找到www.baidu.com这条记录时，点击，右侧将显示General、Response Headers、Request Headers，点击Request Headers右侧的view source，能够看到浏览器发送给百度服务器的请求。

　　 

　　这些数据是有格式的，即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，显示服务器返回的原始响应数据。

　　　　

　　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一行一个，换行符是 。

　　　　4.2.2 HTTP POST请求的格式

POST /path HTTP/1.1
Header1: Value1
Header2: Value2
Header3: Value3

body data goes here...

　　　　　　当遇到连续两个 时，Header部分结束，后面的数据全部是Body。

　　　　4.2.3 HTTP响应的格式

HTTP/1.1 200 OK
Header1: Value1
Header2: Value2
Header3: Value3

body data goes here...

　　　　　　HTTP响应如果包含body，也是通过 来分隔的。　　　　

　　　　　　请再次注意，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
"
    response += '
'
    #   发送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
"
    response += '
'
    
    #   发送body
    # response += "哈哈哈哈哈"
    
    # 读取html页面
    try:
        with open('./html/'+file_name,'rb') as f:
            html_content = f.read()
    except:
        response = "HTTP/1.1 404 NOT FOUND
"
        response += "
"
        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
"
    response += '
'
    
    #   发送body
    # response += "哈哈哈哈哈"
    
    # 读取html页面
    try:
        with open('./html/'+file_name,'rb') as f:
            html_content = f.read()
    except:
        response = "HTTP/1.1 404 NOT FOUND
"
        response += "
"
        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
"
    response += '
'
    
    #   发送body
    # response += "哈哈哈哈哈"
    
    # 读取html页面
    try:
        with open('./html/'+file_name,'rb') as f:
            html_content = f.read()
    except:
        response = "HTTP/1.1 404 NOT FOUND
"
        response += "
"
        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
"
    response += '
'
    
    #   发送body
    # response += "哈哈哈哈哈"
    
    # 读取html页面
    try:
        with open('./html/'+file_name,'rb') as f:
            html_content = f.read()
    except:
        response = "HTTP/1.1 404 NOT FOUND
"
        response += "
"
        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
"
            response_header += "Content-Type: text/html; charset=utf-8
"
            response_header += "Content-Length: %d
" % (len(response_body))
            response_header += "
"

            # 将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
"
            response_header += "Content-Length: %d
" % (len(response_body))
            response_header += "
"

            # 将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
"
            response_header += "Content-Type: text/html; charset=utf-8
"
            # 使用Content-Length，实现http的长连接
            response_header += "Content-Length: %d
" % len(response_body)
            response_header += "
"

            # 将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
"
            response_header += "Content-Length: %d
" % len(response_body)
            response_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.3 总结

　　　　I/O多路复用的特点：　

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

　　　　当然也可以多线程/多进程方式，一个连接过来开一个进程/线程处理，这样消耗的内存和进程切换页会耗掉更多的系统资源。 所以我们可以结合IO多路复用和多进程/多线程 来高性能并发，IO复用负责提高接受socket的通知效率，收到请求后，交给进程池/线程池来处理逻辑。

　　11.4 epoll参考资料

　　　　https://blog.csdn.net/xiajun07061225/article/details/9250579