多进程的面向对象的web服务器¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 | import socket import re import multiprocessing class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) #服务器挂了也不会等几分钟才能使用这个端口 # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response body发送给浏览器 new_socket.send(html_content) # 关闭套接 new_socket.close() def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() #多进程版本需要关闭,线程不需要,线程是资源共享的 # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
1.静态资源和动态资源的概念¶
简单来说：
静态资源：一般客户端发送请求到web服务器，web服务器从内存在取到相应的文件，返回给客户端，客户端解析并渲染显示出来。
动态资源：一般客户端请求的动态资源，先将请求交于web服务器，web服务器连接数据库，数据库处理数据之后，将内容交给web服务器，web服务器返回给客户端解析渲染处理。
2.静态资源和动态资源的区别
a.静态资源一般都是设计好的html页面，而动态资源依靠设计好的程序来实现按照需求的动态响应；
b.静态资源的交互性差，动态资源可以根据需求自由实现；
c.在服务器的运行状态不同，静态资源不需要与数据库参于程序处理，动态可能需要多个数据库的参与运算。
02-web服务器里集成了解析动态请求的功能¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | import socket import re import multiprocessing import time class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response body发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 header = "HTTP/1.1 200 OK\r\n" header += "\r\n" body = "hahahah %s " % time.ctime() #ctime是当前时间 response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
03-将web服务器和逻辑处理的代码分开¶
服务器代码 web_server.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | import socket import re import multiprocessing import time import mini_frame #导入我们动态资源加载的包 class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response body发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 header = "HTTP/1.1 200 OK\r\n" header += "\r\n" # body = "hahahah %s " % time.ctime() if file_name == "/login.py": body = mini_frame.login() #这里的body就是调用函数进行生成了 elif file_name == "/register.py": body = mini_frame.register() response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
web框架代码 mini_frame.py
1 2 3 4 5 | import time def login(): return "welcome hahahh to our website.......time:%s" % time.ctime() |
04-将web服务器和逻辑处理的代码分开-升级版本¶
web_server.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | import socket import re import multiprocessing import time import mini_frame class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response body发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 header = "HTTP/1.1 200 OK\r\n" header += "\r\n" # body = "hahahah %s " % time.ctime() # if file_name == "/login.py": # body = mini_frame.login() # elif file_name == "/register.py": # body = mini_frame.register() body = mini_frame.application(file_name) #这里就只调用一个函数传递函数名即可 response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
mini_frame.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import time def login(): return "i----login--welcome hahahh to our website.......time:%s" % time.ctime() def register(): return "-----register---welcome hahahh to our website.......time:%s" % time.ctime() def profile(): return "-----profile----welcome hahahh to our website.......time:%s" % time.ctime() def application(file_name): if file_name == "/login.py": return login() #返回请求 elif file_name == "/register.py": return register() else: return "not found you page...." |
上面的只是用来理解,实际上怎么会用自己写的这些玩意做开发呢
18.1. 服务器动态资源请求¶
服务器动态资源请求¶
1. 浏览器请求动态页面过程¶
2. WSGI¶
怎么在你刚建立的Web服务器上运行一个Django应用和Flask应用，如何不做任何改变而适应不同的web架构呢？
在以前，选择 Python web 架构会受制于可用的web服务器，反之亦然。如果架构和服务器可以协同工作，那就好了：
但有可能面对（或者曾有过）下面的问题，当要把一个服务器和一个架构结合起来时，却发现他们不是被设计成协同工作的：
那么，怎么可以不修改服务器和架构代码而确保可以在多个架构下运行web服务器呢？答案就是 Python Web Server Gateway Interface (或简称 WSGI，读作“wizgy”)。
WSGI允许开发者将选择web框架和web服务器分开。可以混合匹配web服务器和web框架，选择一个适合的配对。比如,可以在Gunicorn 或者 Nginx/uWSGI 或者 Waitress上运行 Django, Flask, 或 Pyramid。真正的混合匹配，得益于WSGI同时支持服务器和架构：
web服务器必须具备WSGI接口，所有的现代Python Web框架都已具备WSGI接口，它让你不对代码作修改就能使服务器和特点的web框架协同工作。
WSGI由web服务器支持，而web框架允许你选择适合自己的配对，但它同样对于服务器和框架开发者提供便利使他们可以专注于自己偏爱的领域和专长而不至于相互牵制。其他语言也有类似接口：java有Servlet API，Ruby 有 Rack。
3.定义WSGI接口¶
WSGI接口定义非常简单，它只要求Web开发者实现一个函数，就可以响应HTTP请求。我们来看一个最简单的Web版本的“Hello World!”：
1 2 3 | def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return 'Hello World!' |
上面的application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：
- environ：一个包含所有HTTP请求信息的dict对象；
- start_response：一个发送HTTP响应的函数。
整个application()函数本身没有涉及到任何解析HTTP的部分，也就是说，把底层web服务器解析部分和应用程序逻辑部分进行了分离，这样开发者就可以专心做一个领域了
不过，等等，这个application()函数怎么调用？如果我们自己调用，两个参数environ和start_response我们没法提供，返回的str也没法发给浏览器。
所以application()函数必须由WSGI服务器来调用。有很多符合WSGI规范的服务器。而我们此时的web服务器项目的目的就是做一个既能解析静态网页还可以解析动态网页的服务器
4. web服务器-----WSGI协议---->web框架 传递的字典¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | { 'HTTP_ACCEPT_LANGUAGE': 'zh-cn', 'wsgi.file_wrapper': <built-infunctionuwsgi_sendfile>, 'HTTP_UPGRADE_INSECURE_REQUESTS': '1', 'uwsgi.version': b'2.0.15', 'REMOTE_ADDR': '172.16.7.1', 'wsgi.errors': <_io.TextIOWrappername=2mode='w'encoding='UTF-8'>, 'wsgi.version': (1,0), 'REMOTE_PORT': '40432', 'REQUEST_URI': '/', 'SERVER_PORT': '8000', 'wsgi.multithread': False, 'HTTP_ACCEPT': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'HTTP_HOST': '172.16.7.152: 8000', 'wsgi.run_once': False, 'wsgi.input': <uwsgi._Inputobjectat0x7f7faecdc9c0>, 'SERVER_PROTOCOL': 'HTTP/1.1', 'REQUEST_METHOD': 'GET', 'HTTP_ACCEPT_ENCODING': 'gzip,deflate', 'HTTP_CONNECTION': 'keep-alive', 'uwsgi.node': b'ubuntu', 'HTTP_DNT': '1', 'UWSGI_ROUTER': 'http', 'SCRIPT_NAME': '', 'wsgi.multiprocess': False, 'QUERY_STRING': '', 'PATH_INFO': '/index.html', 'wsgi.url_scheme': 'http', 'HTTP_USER_AGENT': 'Mozilla/5.0(Macintosh;IntelMacOSX10_12_5)AppleWebKit/603.2.4(KHTML,likeGecko)Version/10.1.1Safari/603.2.4', 'SERVER_NAME': 'ubuntu' } |
18.2. 应用程序示例¶
应用程序示例
1 2 3 4 5 6 7 | import time def application(environ, start_response): status = '200 OK' response_headers = [('Content-Type', 'text/html')] start_response(status, response_headers) return str(environ) + '==Hello world from a simple WSGI application!--->%s\n' % time.ctime() |
web_server.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | import socket import re import multiprocessing import time import mini_frame class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response body发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 env = dict() body = mini_frame.application(env, self.set_response_header) header = "HTTP/1.1 %s\r\n" % self.status for temp in self.headers: header += "%s:%s\r\n" % (temp[0], temp[1]) header += "\r\n" response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def set_response_header(self, status, headers): self.status = status self.headers = [("server", "mini_web v8.8")] self.headers += headers def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
mini_frame.py
1 2 3 | def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) return 'Hello World! 我爱你中国....' |
06-通过传递字典实现浏览器请求的资源不一样相应的不一样¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | import socket import re import multiprocessing import time import mini_frame class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response body发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 env = dict() # 这个字典中存放的是web服务器要传递给 web框架的数据信息 env['PATH_INFO'] = file_name # {"PATH_INFO": "/index.py"} body = mini_frame.application(env, self.set_response_header) header = "HTTP/1.1 %s\r\n" % self.status #将状态信息写到头上 for temp in self.headers: #将其他的框架返回的元组通过for循环给变成 .. : ..的形式,一个元组占一行 header += "%s:%s\r\n" % (temp[0], temp[1]) header += "\r\n" response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() #把服务器的信息跟框架的信息返回 def set_response_header(self, status, headers): self.status = status self.headers = [("server", "mini_web v8.8")] #服务器版本的信息写在服务器代码中 self.headers += headers def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
mini_frame
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | def index(): return "这是主页" def login(): return "这是登录页面" def application(env, start_response): #charset=utf-8设置浏览器编码 start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) #这样也是可以直接对变量进行 赋值的,厉害了 file_name = env['PATH_INFO'] # file_name = "/index.py" if file_name == "/index.py": return index() elif file_name == "/login.py": return login() else: return 'Hello World! 我爱你中国....' |
07-实现模板文件¶
web_server.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | import socket import re import multiprocessing import time import dynamic.mini_frame class WSGIServer(object): def __init__(self): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", 7890)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): try: f = open("./static" + 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response ic.mini_frame.applicationbody发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 env = dict() # 这个字典中存放的是web服务器要传递给 web框架的数据信息 env['PATH_INFO'] = file_name # {"PATH_INFO": "/index.py"} body = dynamic.mini_frame.application(env, self.set_response_header) header = "HTTP/1.1 %s\r\n" % self.status for temp in self.headers: header += "%s:%s\r\n" % (temp[0], temp[1]) header += "\r\n" response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def set_response_header(self, status, headers): self.status = status self.headers = [("server", "mini_web v8.8")] self.headers += headers def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" wsgi_server = WSGIServer() wsgi_server.run_forever() if __name__ == "__main__": main() |
mini_frame.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | def index(): with open("./templates/index.html",encoding="utf-8") as f: #注意编码的格式 content = f.read() return content def center(): with open("./templates/center.html",encoding="utf-8") as f: return f.read() def application(env, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) file_name = env['PATH_INFO'] # file_name = "/index.py" if file_name == "/index.py": return index() elif file_name == "/center.py": return center() else: return 'Hello World! 我爱你中国....' |
09-运行web服务器时指定端口以及框架¶
mini_frame.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | import re def index(): with open("./templates/index.html") as f: content = f.read() my_stock_info = "哈哈哈哈 这是你的本月名称....." content = re.sub(r"\{%content%\}", my_stock_info, content) return content def center(): with open("./templates/center.html") as f: content = f.read() my_stock_info = "这里是从mysql查询出来的数据。。。" content = re.sub(r"\{%content%\}", my_stock_info, content) return content def application(env, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) file_name = env['PATH_INFO'] # file_name = "/index.py" if file_name == "/index.py": return index() elif file_name == "/center.py": return center() else: return 'Hello World! 我爱你中国....' |
web_server.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | import socket import re import multiprocessing import time # import dynamic.mini_frame import sys class WSGIServer(object): def __init__(self, port, app): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", port)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) self.application = app def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): try: f = open("./static" + 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response ic.mini_frame.applicationbody发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 env = dict() # 这个字典中存放的是web服务器要传递给 web框架的数据信息 env['PATH_INFO'] = file_name # {"PATH_INFO": "/index.py"} # body = dynamic.mini_frame.application(env, self.set_response_header) body = self.application(env, self.set_response_header) header = "HTTP/1.1 %s\r\n" % self.status for temp in self.headers: header += "%s:%s\r\n" % (temp[0], temp[1]) header += "\r\n" response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def set_response_header(self, status, headers): self.status = status self.headers = [("server", "mini_web v8.8")] self.headers += headers def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" if len(sys.argv) == 3: try: port = int(sys.argv[1]) # 7890 frame_app_name = sys.argv[2] # mini_frame:application except Exception as ret: print("端口输入错误。。。。。") return else: print("请按照以下方式运行:") print("python3 xxxx.py 7890 mini_frame:application") return # mini_frame:application ret = re.match(r"([^:]+):(.*)", frame_app_name) if ret: frame_name = ret.group(1) # mini_frame app_name = ret.group(2) # application else: print("请按照以下方式运行:") print("python3 xxxx.py 7890 mini_frame:application") return sys.path.append("./dynamic") #添加这个路径.下面导模块的时候才知道有这么个路径可以使用 # import frame_name --->找frame_name.py frame = __import__(frame_name) # 返回值标记这 导入的这个模块(不能直接使用import,就会认为使用的是frame_name包而不是变量代表的意思) #上面是导包,下面是找函数(使用的是getattr函数) app = getattr(frame, app_name) # 此时app就指向了 dynamic/mini_frame模块中的application这个函数 # print(app) wsgi_server = WSGIServer(port, app) #将这个函数传递进去 wsgi_server.run_forever() if __name__ == "__main__": main() |
10-让web服务器支持配置文件¶
run.sh 运行脚本
1 | python3 web_server.py 7890 mini_frame:application
|
web_server.conf 路径配置文件
1 2 3 4 | { "static_path":"./static", "dynamic_path":"./dynamic" } |
web_server.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 | import socket import re import multiprocessing import time # import dynamic.mini_frame import sys class WSGIServer(object): def __init__(self, port, app, static_path): # 1. 创建套接字 self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 2. 绑定 self.tcp_server_socket.bind(("", port)) # 3. 变为监听套接字 self.tcp_server_socket.listen(128) self.application = app self.static_path = static_path #静态资源的路径 def service_client(self, new_socket): """为这个客户端返回数据""" # 1. 接收浏览器发送过来的请求 ，即http请求 # GET / HTTP/1.1 # ..... request = new_socket.recv(1024).decode("utf-8") # print(">>>"*50) # 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("*"*50, file_name) if file_name == "/": file_name = "/index.html" # 2. 返回http格式的数据，给浏览器 # 2.1 如果请求的资源不是以.py结尾，那么就认为是静态资源（html/css/js/png，jpg等） if not file_name.endswith(".py"): try: f = open(self.static_path + 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: html_content = f.read() f.close() # 2.1 准备发送给浏览器的数据---header response = "HTTP/1.1 200 OK\r\n" response += "\r\n" # 2.2 准备发送给浏览器的数据---boy # response += "hahahhah" # 将response header发送给浏览器 new_socket.send(response.encode("utf-8")) # 将response ic.mini_frame.applicationbody发送给浏览器 new_socket.send(html_content) else: # 2.2 如果是以.py结尾，那么就认为是动态资源的请求 env = dict() # 这个字典中存放的是web服务器要传递给 web框架的数据信息 env['PATH_INFO'] = file_name # {"PATH_INFO": "/index.py"} # body = dynamic.mini_frame.application(env, self.set_response_header) body = self.application(env, self.set_response_header) header = "HTTP/1.1 %s\r\n" % self.status for temp in self.headers: header += "%s:%s\r\n" % (temp[0], temp[1]) header += "\r\n" response = header+body # 发送response给浏览器 new_socket.send(response.encode("utf-8")) # 关闭套接 new_socket.close() def set_response_header(self, status, headers): self.status = status self.headers = [("server", "mini_web v8.8")] self.headers += headers def run_forever(self): """用来完成整体的控制""" while True: # 4. 等待新客户端的链接 new_socket, client_addr = self.tcp_server_socket.accept() # 5. 为这个客户端服务 p = multiprocessing.Process(target=self.service_client, args=(new_socket,)) p.start() new_socket.close() # 关闭监听套接字 self.tcp_server_socket.close() def main(): """控制整体，创建一个web 服务器对象，然后调用这个对象的run_forever方法运行""" if len(sys.argv) == 3: try: port = int(sys.argv[1]) # 7890 frame_app_name = sys.argv[2] # mini_frame:application except Exception as ret: print("端口输入错误。。。。。") return else: print("请按照以下方式运行:") print("python3 xxxx.py 7890 mini_frame:application") return # mini_frame:application ret = re.match(r"([^:]+):(.*)", frame_app_name) if ret: frame_name = ret.group(1) # mini_frame app_name = ret.group(2) # application else: print("请按照以下方式运行:") print("python3 xxxx.py 7890 mini_frame:application") return with open("./web_server.conf") as f: conf_info = eval(f.read()) #使用eval变成我们想要的字典,后面看python中eval函数 # 此时 conf_info是一个字典里面的数据为： # { # "static_path":"./static", # "dynamic_path":"./dynamic" # } sys.path.append(conf_info['dynamic_path']) #路径配置文件中的路径 # import frame_name --->找frame_name.py frame = __import__(frame_name) # 返回值标记这 导入的这个模板 app = getattr(frame, app_name) # 此时app就指向了 dynamic/mini_frame模块中的application这个函数 # print(app) wsgi_server = WSGIServer(port, app, conf_info['static_path']) #从字典中得到静态资源的路径 wsgi_server.run_forever() if __name__ == "__main__": main() |
mini_frame.py
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | import re def index(): with open("./templates/index.html") as f: content = f.read() my_stock_info = "哈哈哈哈 这是你的本月名称....." content = re.sub(r"\{%content%\}", my_stock_info, content) return content def center(): with open("./templates/center.html") as f: content = f.read() my_stock_info = "这里是从mysql查询出来的数据。。。" content = re.sub(r"\{%content%\}", my_stock_info, content) return content def application(env, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) file_name = env['PATH_INFO'] # file_name = "/index.py" if file_name == "/index.py": return index() elif file_name == "/center.py": return center() else: return 'Hello World! 我爱你中国....' |
18.3. Web动态服务器-基本实现¶
python高级¶
Web动态服务器-基本实现¶
文件结构¶
1 2 3 4 5 6 | ├── web_server.py
├── web
│ └── my_web.py
└── html
└── index.html
.....
|
web/my_web.py¶
1 2 3 4 5 6 7 | import time
def application(environ, start_response):
status = '200 OK'
response_headers = [('Content-Type', 'text/html')]
start_response(status, response_headers)
return str(environ) + '==Hello world from a simple WSGI application!--->%s\n' % time.ctime()
|
web_server.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | import select
import time
import socket
import sys
import re
import multiprocessing
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root, app):
# 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
# 设定web框架可以调用的函数(对象)
self.app = app
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
new_socket, new_addr = self.server_socket.accept()
# 创建一个新的进程来完成这个客户端的请求任务
new_socket.settimeout(3) # 3s
new_process = multiprocessing.Process(target=self.deal_with_request, args=(new_socket,))
new_process.start()
new_socket.close()
def deal_with_request(self, client_socket):
"""以长链接的方式，为这个浏览器服务器"""
while True:
try:
request = client_socket.recv(1024).decode("utf-8")
except Exception as ret:
print("========>", ret)
client_socket.close()
return
# 判断浏览器是否关闭
if not request:
client_socket.close()
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"
# 如果不是以py结尾的文件，认为是普通的文件
if not file_name.endswith(".py"):
# 读取文件数据
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"
response = response_header + response_body
# 将header返回给浏览器
client_socket.send(response.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"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8') + response_body)
# 以.py结尾的文件，就认为是浏览需要动态的页面
else:
# 准备一个字典，里面存放需要传递给web框架的数据
env = {}
# 存web返回的数据
response_body = self.app(env, self.set_response_headers)
# 合并header和body
response_header = "HTTP/1.1 {status}\r\n".format(status=self.headers[0])
response_header += "Content-Type: text/html; charset=utf-8\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
for temp_head in self.headers[1]:
response_header += "{0}:{1}\r\n".format(*temp_head)
response = response_header + "\r\n"
response += response_body
client_socket.send(response.encode('utf-8'))
def set_response_headers(self, status, headers):
"""这个方法，会在 web框架中被默认调用"""
response_header_default = [
("Data", time.ctime()),
("Server", "ItCast-python mini web server")
]
# 将状态码/相应头信息存储起来
# [字符串, [xxxxx, xxx2]]
self.headers = [status, response_header_default + headers]
# 设置静态资源访问的路径
g_static_document_root = "./html"
# 设置动态资源访问的路径
g_dynamic_document_root = "./web"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 3:
# 获取web服务器的port
port = sys.argv[1]
if port.isdigit():
port = int(port)
# 获取web服务器需要动态资源时，访问的web框架名字
web_frame_module_app_name = sys.argv[2]
else:
print("运行方式如: python3 xxx.py 7890 my_web_frame_name:application")
return
print("http服务器使用的port:%s" % port)
# 将动态路径即存放py文件的路径，添加到path中，这样python就能够找到这个路径了
sys.path.append(g_dynamic_document_root)
ret = re.match(r"([^:]*):(.*)", web_frame_module_app_name)
if ret:
# 获取模块名
web_frame_module_name = ret.group(1)
# 获取可以调用web框架的应用名称
app_name = ret.group(2)
# 导入web框架的主模块
web_frame_module = __import__(web_frame_module_name)
# 获取那个可以直接调用的函数(对象)
app = getattr(web_frame_module, app_name)
# print(app) # for test
# 启动http服务器
http_server = WSGIServer(port, g_static_document_root, app)
# 运行http服务器
http_server.run_forever()
if __name__ == "__main__":
main()
|
运行¶
1. 打开终端，输入以下命令开始服务器¶
1 | python3 web_server.py my_web:application |
2. 打开浏览器¶
18.4. mini-web框架-1-文件结构¶
python高级¶
mini web框架-1-文件结构¶
文件结构¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ├── dynamic ---存放py模块 │ └── my_web.py ├── templates ---存放模板文件 │ ├── center.html │ ├── index.html │ ├── location.html │ └── update.html ├── static ---存放静态的资源文件 │ ├── css │ │ ├── bootstrap.min.css │ │ ├── main.css │ │ └── swiper.min.css │ └── js │ ├── a.js │ ├── bootstrap.min.js │ ├── jquery-1.12.4.js │ ├── jquery-1.12.4.min.js │ ├── jquery.animate-colors.js │ ├── jquery.animate-colors-min.js │ ├── jquery.cookie.js │ ├── jquery-ui.min.js │ ├── server.js │ ├── swiper.jquery.min.js │ ├── swiper.min.js │ └── zepto.min.js └── web_server.py ---mini web服务器 |
my_web.py¶
1 2 3 4 5 6 7 | import time
def application(environ, start_response):
status = '200 OK'
response_headers = [('Content-Type', 'text/html')]
start_response(status, response_headers)
return str(environ) + '==Hello world from a simple WSGI application!--->%s\n' % time.ctime()
|
web_server.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 | import select
import time
import socket
import sys
import re
import multiprocessing
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root, app):
# 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
# 设定web框架可以调用的函数(对象)
self.app = app
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
new_socket, new_addr = self.server_socket.accept()
# 创建一个新的进程来完成这个客户端的请求任务
new_socket.settimeout(3) # 3s
new_process = multiprocessing.Process(target=self.deal_with_request, args=(new_socket,))
new_process.start()
new_socket.close()
def deal_with_request(self, client_socket):
"""以长链接的方式，为这个浏览器服务器"""
while True:
try:
request = client_socket.recv(1024).decode("utf-8")
except Exception as ret:
print("========>", ret)
client_socket.close()
return
# 判断浏览器是否关闭
if not request:
client_socket.close()
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"
# 如果不是以py结尾的文件，认为是普通的文件
if not file_name.endswith(".py"):
# 读取文件数据
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"
response = response_header + response_body
# 将header返回给浏览器
client_socket.send(response.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"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8') + response_body)
# 以.py结尾的文件，就认为是浏览需要动态的页面
else:
# 准备一个字典，里面存放需要传递给web框架的数据
env = dict()
# 存web返回的数据
response_body = self.app(env, self.set_response_headers)
# 合并header和body
response_header = "HTTP/1.1 {status}\r\n".format(status=self.headers[0])
response_header += "Content-Type: text/html; charset=utf-8\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body)
for temp_head in self.headers[1]:
response_header += "{0}:{1}\r\n".format(*temp_head)
response = response_header + "\r\n"
response += response_body
client_socket.send(response.encode('utf-8'))
def set_response_headers(self, status, headers):
"""这个方法，会在 web框架中被默认调用"""
response_header_default = [
("Data", time.time()),
("Server", "ItCast-python mini web server")
]
# 将状态码/相应头信息存储起来
# [字符串, [xxxxx, xxx2]]
self.headers = [status, response_header_default + headers]
# 设置静态资源访问的路径
g_static_document_root = "./static"
# 设置动态资源访问的路径
g_dynamic_document_root = "./dynamic"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 3:
# 获取web服务器的port
port = sys.argv[1]
if port.isdigit():
port = int(port)
# 获取web服务器需要动态资源时，访问的web框架名字
web_frame_module_app_name = sys.argv[2]
else:
print("运行方式如: python3 xxx.py 7890 my_web_frame_name:application")
return
print("http服务器使用的port:%s" % port)
# 将动态路径即存放py文件的路径，添加到path中，这样python就能够找到这个路径了
sys.path.append(g_dynamic_document_root)
ret = re.match(r"([^:]*):(.*)", web_frame_module_app_name)
if ret:
# 获取模块名
web_frame_module_name = ret.group(1)
# 获取可以调用web框架的应用名称
app_name = ret.group(2)
# 导入web框架的主模块
web_frame_module = __import__(web_frame_module_name)
# 获取那个可以直接调用的函数(对象)
app = getattr(web_frame_module, app_name)
# print(app) # for test
# 启动http服务器
http_server = WSGIServer(port, g_static_document_root, app)
# 运行http服务器
http_server.run_forever()
if __name__ == "__main__":
main()
|
18.5. mini-web框架-2-显示页面¶
mini web框架-2-显示页面¶
dynamic/my_web.py (更新)¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | import time
import os
template_root = "./templates"
def index(file_name):
"""返回index.py需要的页面内容"""
# return "hahha" + os.getcwd() # for test 路径问题
try:
file_name = file_name.replace(".py", ".html")
f = open(template_root + file_name)
except Exception as ret:
return "%s" % ret
else:
content = f.read()
f.close()
return content
def center(file_name):
"""返回center.py需要的页面内容"""
# return "hahha" + os.getcwd() # for test 路径问题
try:
file_name = file_name.replace(".py", ".html")
f = open(template_root + file_name)
except Exception as ret:
return "%s" % ret
else:
content = f.read()
f.close()
return content
def application(environ, start_response):
status = '200 OK'
response_headers = [('Content-Type', 'text/html')]
start_response(status, response_headers)
file_name = environ['PATH_INFO']
if file_name == "/index.py":
return index(file_name)
elif file_name == "/center.py":
return center(file_name)
else:
return str(environ) + '==Hello world from a simple WSGI application!--->%s\n' % time.ctime()
|
web_server.py (更新)¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | import select
import time
import socket
import sys
import re
import multiprocessing
class WSGIServer(object):
"""定义一个WSGI服务器的类"""
def __init__(self, port, documents_root, app):
# 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
# 设定web框架可以调用的函数(对象)
self.app = app
def run_forever(self):
"""运行服务器"""
# 等待对方链接
while True:
new_socket, new_addr = self.server_socket.accept()
# 创建一个新的进程来完成这个客户端的请求任务
new_socket.settimeout(3) # 3s
new_process = multiprocessing.Process(target=self.deal_with_request, args=(new_socket,))
new_process.start()
new_socket.close()
def deal_with_request(self, client_socket):
"""以长链接的方式，为这个浏览器服务器"""
while True:
try:
request = client_socket.recv(1024).decode("utf-8")
except Exception as ret:
print("========>", ret)
client_socket.close()
return
# 判断浏览器是否关闭
if not request:
client_socket.close()
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"
# 如果不是以py结尾的文件，认为是普通的文件
if not file_name.endswith(".py"):
# 读取文件数据
try:
print(self.documents_root+file_name)
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"
response = response_header + response_body
# 将header返回给浏览器
client_socket.send(response.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"
# 将header返回给浏览器
client_socket.send(response_header.encode('utf-8') + response_body)
# 以.py结尾的文件，就认为是浏览需要动态的页面
else:
# 准备一个字典，里面存放需要传递给web框架的数据
env = dict()
# ----------更新---------
env['PATH_INFO'] = file_name # 例如 index.py
# 存web返回的数据
response_body = self.app(env, self.set_response_headers)
# 合并header和body
response_header = "HTTP/1.1 {status}\r\n".format(status=self.headers[0])
response_header += "Content-Type: text/html; charset=utf-8\r\n"
response_header += "Content-Length: %d\r\n" % len(response_body.encode("utf-8"))
for temp_head in self.headers[1]:
response_header += "{0}:{1}\r\n".format(*temp_head)
response = response_header + "\r\n"
response += response_body
client_socket.send(response.encode('utf-8'))
def set_response_headers(self, status, headers):
"""这个方法，会在 web框架中被默认调用"""
response_header_default = [
("Data", time.time()),
("Server", "ItCast-python mini web server")
]
# 将状态码/相应头信息存储起来
# [字符串, [xxxxx, xxx2]]
self.headers = [status, response_header_default + headers]
# 设置静态资源访问的路径
g_static_document_root = "./static"
# 设置动态资源访问的路径
g_dynamic_document_root = "./dynamic"
def main():
"""控制web服务器整体"""
# python3 xxxx.py 7890
if len(sys.argv) == 3:
# 获取web服务器的port
port = sys.argv[1]
if port.isdigit():
port = int(port)
# 获取web服务器需要动态资源时，访问的web框架名字
web_frame_module_app_name = sys.argv[2]
else:
print("运行方式如: python3 xxx.py 7890 my_web_frame_name:app")
return
print("http服务器使用的port:%s" % port)
# 将动态路径即存放py文件的路径，添加到path中，这样python就能够找到这个路径了
sys.path.append(g_dynamic_document_root)
ret = re.match(r"([^:]*):(.*)", web_frame_module_app_name)
if ret:
# 获取模块名
web_frame_module_name = ret.group(1)
# 获取可以调用web框架的应用名称
app_name = ret.group(2)
# 导入web框架的主模块
web_frame_module = __import__(web_frame_module_name)
# 获取那个可以直接调用的函数(对象)
app = getattr(web_frame_module, app_name)
# print(app) # for test
# 启动http服务器
http_server = WSGIServer(port, g_static_document_root, app)
# 运行http服务器
http_server.run_forever()
if __name__ == "__main__":
main()
|
浏览器打开看效果¶
18.6. mini-web框架-3-替换模板¶
mini web框架-3-替换模板¶
dynamic/my_web.py¶
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | import time
import os
import re
template_root = "./templates"
def index(file_name):
"""返回index.py需要的页面内容"""
# return "hahha" + os.getcwd() # for test 路径问题
try:
file_name = file_name.replace(".py", ".html")
f = open(template_root + file_name)
except Exception as ret:
return "%s" % ret
else:
content = f.read()
f.close()
# --------更新-------
data_from_mysql = "数据还没有敬请期待...."
content = re.sub(r"\{%content%\}", data_from_mysql, content)
return content
def center(file_name):
"""返回center.py需要的页面内容"""
# return "hahha" + os.getcwd() # for test 路径问题
try:
file_name = file_name.replace(".py", ".html")
f = open(template_root + file_name)
except Exception as ret:
return "%s" % ret
else:
content = f.read()
f.close()
# --------更新-------
data_from_mysql = "暂时没有数据,,,,~~~~(>_<)~~~~ "
content = re.sub(r"\{%content%\}", data_from_mysql, content)
return content
def application(environ, start_response):
status = '200 OK'
response_headers = [('Content-Type', 'text/html')]
start_response(status, response_headers)
file_name = environ['PATH_INFO']
if file_name == "/index.py":
return index(file_name)
elif file_name == "/center.py":
return center(file_name)
else:
return str(environ) + '==Hello world from a simple WSGI application!--->%s\n' % time.ctime()
|
浏览器打开看效果¶
