开发者社区> JoanKing> 正文

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

简介: 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()


    • 服务器端


image.png

网页端: 输入 IP:端口号 就可以显示网页


image.png

三、tcp长连接和短连接



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

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



image.png

  • 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)、短连接的操作步骤是:建立连接——数据传输——关闭连接...建立连接——数据传输——关闭连接


image.png


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


image.png



  • 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的通知效率,收到请求后,交给进程池/线程池来处理逻辑。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
如何设置阿里云服务器安全组?阿里云安全组规则详细解说
阿里云安全组设置详细图文教程(收藏起来) 阿里云服务器安全组设置规则分享,阿里云服务器安全组如何放行端口设置教程。阿里云会要求客户设置安全组,如果不设置,阿里云会指定默认的安全组。那么,这个安全组是什么呢?顾名思义,就是为了服务器安全设置的。安全组其实就是一个虚拟的防火墙,可以让用户从端口、IP的维度来筛选对应服务器的访问者,从而形成一个云上的安全域。
19812 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,阿里云优惠总结大概有三种登录方式: 登录到ECS云服务器控制台 在ECS云服务器控制台用户可以更改密码、更换系.
29196 0
阿里云服务器如何登录?阿里云服务器的三种登录方法
购买阿里云ECS云服务器后如何登录?场景不同,大概有三种登录方式:
13578 0
阿里云服务器安全组设置内网互通的方法
虽然0.0.0.0/0使用非常方便,但是发现很多同学使用它来做内网互通,这是有安全风险的,实例有可能会在经典网络被内网IP访问到。下面介绍一下四种安全的内网互联设置方法。 购买前请先:领取阿里云幸运券,有很多优惠,可到下文中领取。
22540 0
阿里云服务器ECS登录用户名是什么?系统不同默认账号也不同
阿里云服务器Windows系统默认用户名administrator,Linux镜像服务器用户名root
16465 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
20710 0
腾讯云服务器 设置ngxin + fastdfs +tomcat 开机自启动
在tomcat中新建一个可以启动的 .sh 脚本文件 /usr/local/tomcat7/bin/ export JAVA_HOME=/usr/local/java/jdk7 export PATH=$JAVA_HOME/bin/:$PATH export CLASSPATH=.
14901 0
+关注
433
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
JS零基础入门教程(上册)
立即下载
性能优化方法论
立即下载
手把手学习日志服务SLS,云启实验室实战指南
立即下载