Python web服务器3: 静态服务器&并发web服

一、总体内容

• 1.1、显示固定的页面
• 1.2、tcp长连接和短连接
• 1.3、返回浏览器需要的界面分析：实现http服务器的类型

二、显示固定的页面

• 2.1、服务器端代码（TCP）

  import socket
  
  
  def server_client(new_socket):
        """为这个客户端返回数据"""
        # # 组织相应 头信息(header)
        # 1.接收浏览器发送过来的请求，即 http请求
        # GET / HTTP/1.1
        # ....
        request = new_socket.recv(1024)
        print(request)
  
        # 2.返回http格式的数据，给浏览器
        # 2.1、准备发送给浏览器的数据---header
        response = "HTTP/1.1 200 OK\r\n" # 200表示找到这个资源
        response += "\r\n" # 用一个空的行与body进行隔开
        # 2.2、准备发送给浏览器的数据 ---body
        response += "<h4>您好吗？/h4>"
        new_socket.send(response.encode("utf-8"))
  
        # 3.关闭套接字
        new_socket.close()
  
  
  def main():
       """用来完成整体的控制"""
       # 1.创建套接字
       tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
       # 2.绑定
       tcp_server_socket.bind(("192.168.3.6", 7280))
       # 3.变为监听套接字
       tcp_server_socket.listen(128)
  
       while True:
             # 4.等待客户端的链接
             new_socket, client_addr = tcp_server_socket.accept()
             # 5.为这个客户端服务
             server_client(new_socket)
  
       # 6.关闭监听的套接字
       tcp_server_socket.close()
  
  
  if __name__ == '__main__':
       main()
  

  • 服务器端

    
    服务器端
  • 网页端: 输入 IP:端口号 就可以显示网页
    网页端

三、tcp长连接和短连接
TCP在真正的读写操作之前，server与client之间必须建立一个连接，当读写操作完成后，双方不再需要这个连接时它们可以释放这个连接，连接的建立通过三次握手，释放则需要四次握手，所以说每个连接的建立都是需要资源消耗和时间消耗的。

• 3.1、TCP通信的整个过程，如下图:

  
  三次握手、四次挥手

• 3.2、TCP短连接
  模拟一种TCP短连接的情况:

  • client 向 server 发起连接请求
  • server 接到请求，双方建立连接
  • client 向 server 发送消息
  • server 回应 client
  • 一次读写完成，此时双方任何一个都可以发起 close 操作

  在步骤5中，一般都是 client 先发起 close 操作。当然也不排除有特殊的情况。
  从上面的描述看，短连接一般只会在 client/server 间传递一次读写操作！

• 3.3、TCP长连接
  再模拟一种长连接的情况:

  • client 向 server 发起连接
  • server 接到请求，双方建立连接
  • client 向 server 发送消息
  • server 回应 client
  • 一次读写完成，连接不关闭
  • 后续读写操作...
  • 长时间操作之后client发起关闭请求

• 3.4、TCP长/短连接操作过程

  • (1)、短连接的操作步骤是：建立连接——数据传输——关闭连接...建立连接——数据传输——关闭连接

    
    短连接

  • (2)、长连接的操作步骤是：建立连接——数据传输...（保持连接）...数据传输——关闭连接

    
    长连接

• 3.5、TCP长/短连接的优点和缺点

  • 长连接可以省去较多的TCP建立和关闭的操作，减少浪费，节约时间。对于频繁请求资源的客户来说，较适用长连接。
  • client与server之间的连接如果一直不关闭的话，会存在一个问题，随着客户端连接越来越多，server早晚有扛不住的时候，这时候server端需要采取一些策略，如关闭一些长时间没有读写事件发生的连接，这样可以避免一些恶意连接导致server端服务受损；
    如果条件再允许就可以以客户端机器为颗粒度，限制每个客户端的最大长连接数，这样可以完全避免某个蛋疼的客户端连累后端服务。
  • 短连接对于服务器来说管理较为简单，存在的连接都是有用的连接，不需要额外的控制手段。
  • 但如果客户请求频繁，将在TCP的建立和关闭操作上浪费时间和带宽。

• 3.6、TCP长/短连接的应用场景

  • 长连接多用于操作频繁，点对点的通讯，而且连接数不能太多情况。每个TCP连接都需要三次握手，这需要时间，如果每个操作都是先连接，再操作的话那么处理速度会降低很多，所以每个操作完后都不断开，再次处理时直接发送数据包就OK了，不用建立TCP连接。
    例如：数据库的连接用长连接，如果用短连接频繁的通信会造成socket错误，而且频繁的socket 创建也是对资源的浪费。

  • 而像WEB网站的http服务一般都用短链接，因为长连接对于服务端来说会耗费一定的资源，而像WEB网站这么频繁的成千上万甚至上亿客户端的连接用短连接会更省一些资源，如果用长连接，而且同时有成千上万的用户，如果每个用户都占用一个连接的话，那可想而知吧。所以并发量大，但每个用户无需频繁操作情况下需用短连好。

四、返回浏览器需要的界面分析 以及 并发服务器

• 4.1、服务器端代码

  import socket
  import re
  
  
  def server_client(new_socket):
        """为这个客户端返回数据"""
        # # 组织相应 头信息(header)
        # 1.接收浏览器发送过来的请求，即 http请求
        # GET / HTTP/1.1
        # ....
        request = new_socket.recv(1024).decode("utf-8")
        # print(request)
  
        request_lines = request.splitlines()
        print("")
        print(">"*20)
        print(request_lines)
  
        # GET /index.html HTTP/1.1
        # get post put del
        file_name = ""
        ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
  
        if ret:
            file_name = ret.group(1)
            print("file_name=%s" % file_name)
            print("*"*50,file_name)
            if file_name == "/":
                file_name = "/index.html"
  
        # 2.返回http格式的数据，给浏览器
        # 2.1、准备发送给浏览器的数据---header
        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_socket.send(response.encode("utf-8"))
        else:
             print("-----------OK------------")
             html_content = f.read()
             f.close()
  
             response = "HTTP/1.1 200 OK\r\n"  # 200表示找到这个资源
             response += "\r\n"  # 用一个空的行与body进行隔开
             # 2.2、准备发送给浏览器的数据 ---body
             # 将response的header发送给浏览器
             new_socket.send(response.encode("utf-8"))
             # 将response的 body 发送给浏览器
             new_socket.send(html_content)
  
       # 3.关闭套接字
       new_socket.close()
  
  
  def main():
         """用来完成整体的控制"""
         # 1.创建套接字
         tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         # 2.绑定
         tcp_server_socket.bind(("192.168.3.6", 7590))
         # 3.变为监听套接字
         tcp_server_socket.listen(128)
  
         while True:
               # 4.等待客户端的链接
               new_socket, client_addr = tcp_server_socket.accept()
               # 5.为这个客户端服务
               server_client(new_socket)
  
         # 6.关闭监听的套接字
         tcp_server_socket.close()
  
  
  if __name__ == '__main__':
         main()
  

  分析一下上面代码中的正则：ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
  ”^”这个字符是在中括号 []中被使用的话就是表示字符类的否定，如果不是的话就是表示限定开头。我这里说的是直接在[]中使用，不包括嵌套使用。
  其实也就是说 [] 代表的是一个字符集，^ 只有在字符集中才是反向字符集的意思。
  [^/]+(/[^ ]*： 意思是 : [^/]:除了 / 以外，+：至少一个字符，/[^ ]*：表示除了空格，也就是到空格就不匹配了，*：表示匹配前一个字符出现0次或者无限次，即可有可无

• 4.2、多进程实现http服务器

  import socket
  import multiprocessing
  import re
  
  
  def server_client(new_socket):
      """为这个客户端返回数据"""
      # # 组织相应 头信息(header)
      # 1.接收浏览器发送过来的请求，即 http请求
      # GET / HTTP/1.1
      # ....
      request = new_socket.recv(1024).decode("utf-8")
      # print(request)
  
      request_lines = request.splitlines()
      print("")
      print(">"*20)
      print(request_lines)
  
      # GET /index.html HTTP/1.1
      # get post put del
      file_name = ""
      ret = re.match(r"[^/]+(/[^ ]*)",request_lines[0])
  
      if ret:
  
          file_name = ret.group(1)
  
          print("file_name=%s" % file_name)
  
          print("*"*50,file_name)
          if file_name == "/":
              file_name = "/index.html"
  
      # 2.返回http格式的数据，给浏览器
      # 2.1、准备发送给浏览器的数据---header
  
      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_socket.send(response.encode("utf-8"))
      else:
  
          print("-----------OK------------")
  
          html_content = f.read()
          f.close()
  
          response = "HTTP/1.1 200 OK\r\n"  # 200表示找到这个资源
          response += "\r\n"  # 用一个空的行与body进行隔开
          # 2.2、准备发送给浏览器的数据 ---body
          # 将response的header发送给浏览器
          new_socket.send(response.encode("utf-8"))
          # 将response的 body 发送给浏览器
          new_socket.send(html_content)
  
      # 3.关闭套接字
      new_socket.close()
  
  
  def main():
      """用来完成整体的控制"""
      # 1.创建套接字
      tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     # 2.绑定
     tcp_server_socket.bind(("192.168.3.6", 7590))
     # 3.变为监听套接字
     tcp_server_socket.listen(128)
  
     while True:
         # 4.等待客户端的链接
         new_socket, client_addr = tcp_server_socket.accept()
  
         # 5.开辟一个进程为这个客户端服务
         p = multiprocessing.Process(target=server_client,args=(new_socket,))
         p.start()
  
         new_socket.close()
  
  
     # 6.关闭监听的套接字
     tcp_server_socket.close()
  
  
  if __name__ == '__main__':
      main()
  

  • 提示：上面代码在while True:里面有一个：new_socket.close(),因为进程是复制一份资源，进程里面有一个new_socket指向资源，主进程也有一份指向资源，等子进程 new_socket 调用close()的时候，资源不会被释放，所以在主进程先把指向子进程的资源释放掉
  • 缺点：每一个子进程都要复制一份资源，如果很多很多客户端，那么服务器的内存就很快用完，服务器会承受不了，那么我们就需要用 多线程 了

• 4.3、多线程实现http服务器
  把上面代码在while True:改为如下

  import threading
  
  while True:
  
        # 4.等待客户端的链接
        new_socket, client_addr = tcp_server_socket.accept()
  
        # 5.开辟一个进程为这个t客户端服务
        t = threading.Thread(target=server_client,args=(new_socket,))
        t.start()
  

  • 提示：上面代码在while True:里面没有一个：new_socket.close(),因为多线程没有复制一份资源，子线程 new_socket 调用close()的时候，资源被释放
  • 缺点：每一个子线程都要开辟一条线程，如果很多很多客户端，那么服务器也会受不了的，并不是子线程越多越好

• 4.3、协程gevent实现http服务器

  import gevent
  from gevent import monkey
  
  
  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块
  monkey.patch_all()
  
  
  while True:
        # 4.等待客户端的链接
        new_socket, client_addr = tcp_server_socket.accept()
  
        # 5.开辟一个协程为这个t客户端服务
        gevent.spawn(server_client,new_socket)
  

• 4.4、单进程非堵塞 模型

  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()
  

• 4.5、epoll

  • IO 多路复用

    • 就是我们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。
    • select/epoll的好处就在于单个process就可以同时处理多个网络连接的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(128)
    
    # 创建一个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]
    

    说明
    - EPOLLIN （可读）
    - EPOLLOUT （可写）
    - EPOLLET （ET模式）
    epoll 对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下：

    • LT模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll时，会再次响应应用程序并通知此事件。
    • ET模式：当epoll检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll时，不会再次响应应用程序并通知此事件。

  • web静态服务器-epool:以下代码，支持http的长连接，即使用了Content-Length(也就是返回内容的长度)

    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"
                    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()
    

  • 总结：I/O 多路复用的特点：‘

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

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