python之MiniWeb框架

本次学习MiniWeb框架的目的并非可以完成框架的编写，而是须要学习框架编写中的思想，主要是理解路由表的定义和自动维护、视图函数的做用、先后端分离的开发思想，以及WSGI协议中的application函数的实现与调用的思想。

以往，咱们多完成的是静态web服务器，主要处理的都是一些已经‘写死’的数据，那么今天，咱们来学习一下动态数据的处理。

说到动态数据，咱们就须要了解一个东西，那就是web框架。

所谓web框架简单地说就是用来处理数据或模板的一个py程序。

那么接下，我就简单的给你们简述一下一个浏览器访问动态数据的总体流程。

WSGI服务器网管接口（Web Server Gateway Interface）是为python语言定义的一种服务器与框架进行通讯的简单接口，其接口原理就是实现application函数。
application函数格式以下：

def application(environ, func): start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) return 'Hello MiniWeb'

函数的第一个参数environ类型是一个字典，用来接收封装到字典内的请求资源路径。

函数的第二个参数func类型是一个函数，用来接收调用时传递的函数引用。

application函数在是在框架中实现，框架就是处理数据的py文件；在服务器端调用。

实现application函数而且完成数据处理的py文件咱们就能够称它是WSGI接口。

首先，咱们先看一张图片

 

这张图片完美的阐述了从浏览器到服务器到web框架的应用。

接下来我将给你们进行简单的阐述：

首先，你们须要明确一点本次开发中以.html后缀的文件为动态资源，其他均为静态资源

1.浏览器发送HTTP请求报文给服务器，

2.服务器根据HTTP请求报文的请求路径进行判断，

若是请求的是静态资源，那么服务器直接将静态资源的数据读出来而后拼接成HTTP响应报文返回给浏览器；

若是请求的是动态资源，那么服务器会将动态资源请求发送给web框架。

3.web框架接收到服务器转发的请求后，先对请求进行判断，

若是是请求模版那么web框架将会去模版中查找请求的模板，若是查询到请求的模板那就把模板数据返回给web服务器，再有服务器返回给浏览器，

若是请求的是数据那么web框架将会去数据库中进行操做，将查询等操做的数据或返回值，返回给web服务器，再有服务器返回给浏览器。

至此一个总体流程就阐述完毕了。

1.web服务器代码实现：

# 1.导入socket模块
import socket import threading import FreamWork # 建立服务器类
class HttpServerSocket(object): # 给服务器类的对象设置属性
    def __init__(self): # 2.建立Socket对象
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 3.设置端口复用
 self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True) # 4.绑定端口
        self.server_socket.bind(('', 8000)) # 5.设置监听
        self.server_socket.listen(128) def start(self): while True: # 6.等待客户端链接
            client_socket, ip_port = self.server_socket.accept() # gevent.spawn(self.task, client_socket, ip_port)
            print("上线了", ip_port) threading.Thread(target=self.task, args=(client_socket, ip_port), daemon=True).start() def task(self, client_socket, ip_port): # 7.接收数据
        recv_data = client_socket.recv(1024).decode('utf-8') print(recv_data) if not recv_data: print("客户端：%s下线了，端口号为：%s" % ip_port) return

        # 8.发送数据
        # 判断请求资源是否包含参数
        # 请求行格式：GET /index.html HTTP/1.1
        recv_path = recv_data.split()[1] # print("第一次分割",recv_path)
        # 若是有参数则以？分割
        if '?' in recv_path: real_recv_path = recv_path.split('?')[0] # print("?分割",real_recv_path)
        else: # 若是没有参数，则保持请求路径不变
            real_recv_path = recv_path # print("无？分割",real_recv_path)

        # 设置没指定资源路径，默认返回index.html
        if real_recv_path == '/': real_recv_path = '/index.html'

        # 判断请求资源是静态资源仍是动态资源
        if real_recv_path.endswith('.html'): env = {'PATH_INFO': real_recv_path} # 调用框架中的application函数 response_body = FreamWork.application(env, self.start_response) response_line = 'HTTP/1.1 %s\r\n' % self.status response_header = 'Server: PWS/1.0\r\n' # self.response_header 接收的是列表中保存的元组须要进行解包处理 response_header += '%s :%s\r\n' % self.response_header[0] send_data = (response_line + response_header + '\r\n' + response_body).encode('utf8') client_socket.send(send_data) client_socket.close() else: # 判断请求的资源路径是否存在
            try: with open(f"static{real_recv_path}", "rb") as file: response_body = file.read() except Exception as e: # 若是不存在则返回404
                response_line = 'HTTP/1.1 404 NOT FOUND\r\n' response_header = 'Server: PWS/1.0\r\n' response_body = 'sorry nor found page!\r\n'.capitalize() send_data = (response_line + response_header + '\r\n' + response_body).encode('utf-8') client_socket.send(send_data) else: # 若是存在则换回请求的页面信息
                response_line = 'HTTP/1.1 200 OK\r\n' response_header = 'Server: PWS/1.0\r\n' send_data = (response_line + response_header + '\r\n').encode('utf-8') + response_body client_socket.send(send_data) finally: # 断开与客户端链接
 client_socket.close() def start_response(self, status, response_header): self.status = status self.response_header = response_header def __del__(self): # 当服务端程序结束时中止服务器服务
 self.server_socket.close() def main(): http_socket = HttpServerSocket() http_socket.start() if __name__ == '__main__': main()

核心代码（代码段中颜色为红色并加粗的代码）解读：

1.经过分解后的请求资源路径的后缀判断请求的是不是html页面，若是是则认为请求的是动态资源；

2.将动态资源路径封装到一个字典中，并将字典和函数的引用传递给application函数，

3.web框架（application函数）根据传递的资源路径去模板中查找是否含有请求的模板，若是有则读取模版数据并返回；

4.接收到web框架（application函数）返回的数据，并拼接HTTP响应报文，而后经过浏览器套接字将HTTP响应报文发送给浏览器，最后关闭与浏览器链接。

2.MiniWeb框架代码实现：

import db import json # 定义一个路由表
router_table = {} # 编写接口函数 # environ参数用来接收请求资源路径 # start_response参数用来接收传递过来的函数
def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html;charset=utf-8')]) func = error if environ['PATH_INFO'] in router_table: func = router_table[environ['PATH_INFO']] body = func() return body # 定义一个装饰器，用来实现路由表的自动维护
def router(url): def decorator(func): def inner(*args, **kwargs): body = func(*args, **kwargs) return body router_table[url] = func return inner return decorator # 先后端不分离技术
@router('/index.html') def index(): db_data = db.db_select() with open('templates/index.html', 'r') as file: body = file.read() row_str = """ <tr> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td> <td>%s</td> <td> <input type="button" value="添加" id="toAdd" name="toAdd" systemidvaule="%s"> </td> </tr> """ body_data = ''
    for data in db_data: body_data += row_str % (data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[1]) body = body.replace('{%content%}', body_data) return body # 先后端分离技术
@router('/center.html') def center(): with open('templates/center.html', 'r', encoding='utf-8') as file: body = file.read() return body # 编写接口函数
def center_data(): result = db.db_select_interface() # 编写JSON数据
    # JSON类型数据格式：[{"key":"value"},{"key":"value"},{"key":"value"}]
    data = [] for i in result: dd = {} dd['code'] = i[0] dd['short'] = i[1] dd['chg'] = i[2] dd['turnover'] = i[3] dd['price'] = i[4] dd['highs'] = i[5] dd['info'] = i[6] data.append(dd) # 将数据装换成JSON类型数据
    # data:要转换的字符串
    # ensure_ascii设置是否用ASCII码解析，False为否，True为是
    josn_data = json.dumps(data,ensure_ascii=False) return josn_data @router('/update.html') def update(): with open('templates/update.html', 'r', encoding='utf-8') as file: body = file.read() return body def error(): return '<h1>你的页面迷路了。。。</h1>'

JSON的数据格式：

[{"key":"value"},{"key":"value"},{"key":"value"}]

在JSON数据转换时须要注意，json.dumps()会默认采用ASCII码进项解码转换，想要不使用ASCII进行转码就须要设置ensure_ascii参数，将它设置成False便可解决问题。

这里给你们简单阐述一下路由表的概念：

路由表就是一个用请求地址做为Key，装饰器内层函数的引用做为Value而造成的键值对组成的字典。

其格式为：

{ '/index.html':inner, '/error.html':inner }

对于路由表的自动维护，咱们能够经过编写带参数的装饰器来实现：

router_table = {} def router(url): def decorator(func): def inner(*args, **kwargs): func(*args, **kwargs) router_table[url] = inner return inner return decorator

经过@router('/index.html')语法糖来给路由表中添加数据。

其主要流程：

1.先执行router('/index.html')，而后将装饰器decorator函数的引用返回；

2.在经过@decorator的引用，将视图函数传递给func，将inner的引用及url组成键值对保存到路由表中；

这里再给你们扩展一个概念，视图函数是MVT开发模式中的V也就是View，其主要功能是处理数据。

3.数据库操做代码实现：

import pymysql # 定义一个数据库链接函数
def db_connect(): db = pymysql.connect(host='localhost', port=3306, user='root', password='mysql', database='stock_db', charset='utf8') # 返回数据库链接对象
    return db # 定义一个index页面查询数据的函数
def db_select(): db = db_connect() cur = db.cursor() sql = ''' select * from info; ''' cur.execute(sql) result = cur.fetchall() cur.close() db.close() return result # 定义一个接口查询数据的函数
def db_select_interface(): db = db_connect() cur = db.cursor() sql = '''select i.code, i.short, i.chg, i.turnover,i.price, i.highs, f.note_info from info i inner join focus f on i.id = f.info_id ''' cur.execute(sql) result = cur.fetchall() cur.close() db.close() return result

最后，总结一下MiniWeb开发的大概流程：

1.在原有的TCP服务端的基础上加上一个请求资源的判断，即判断是不是动态资源；

2.若是是动态资源，就将动态资源的请求路径发送给框架，

3.框架在进行判断，若是动态资源是模版那就读出模版的数据并返回给服务器，最后再由服务器拼接响应报文给客户端，

4.若是动态资源请求的是数据，那么框架就回到数据库中将数据查询出来，而且拼接成JSON数据格式的字符串，再将JSON数据格式的字符串转换成JSON数据，最后在返回给服务器，最后再由服务器拼接响应报文并发送给客户端。