黑马程序员---miniweb框架的完整迭代过程

た入场券 2022-11-30 04:16 150阅读 0赞

1：搭建静态web服务器页面—返回固定页面

# 过程分析：1:初始化web服务器 2：循环接受客户端请求  3：读取指定页面   4：构造响应报文，发送回浏览器
    import socket
    
    def main():
    
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("",7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
    
            client_request = new_socket.recv(1024).decode('utf-8')
            print(client_request)
    
            # 3；读取指定页面
            with open("static/index.html","rb") as file:
                file_data = file.read()
    
            # 4:构建响应报文
            response_line = "HTTP/1.1 200 ok\r\n"
            # 这里面存的是键值对，但是都不加引号
            response_head = "server:NB/1.0\r\n"
            response_body = file_data
    
            response_data = (response_line + response_head + "\r\n").encode('utf-8')+response_body
            # 5:返回给浏览器
            new_socket.send(response_data)
    
            new_socket.close()
    
    
    
    
    if __name__ == '__main__':
        main()

2：搭建静态web服务器页面—返回指定页面

# 请求信息
    # GET /index.html HTTP/1.1
    # Host: 127.0.0.1:7788
    # Connection: keep-alive
    # Cache-Control: max-age=0
    # Upgrade-Insecure-Requests: 1
    # User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36
    # Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
    # Accept-Encoding: gzip, deflate, br
    # Accept-Language: zh-CN,zh;q=0.9
    
    
    # 过程分析：
    # 由于客户端请求的地址在请求行的第二部分，
    # 所以可以通过拆分字符串来拿到地址列表，
    # 然后在列表中获取地址,最后拼接字符串构造请求地址
    
    
    import socket
    
    def main():
    
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("",7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
    
            client_request = new_socket.recv(1024).decode('utf-8')
            print(client_request)
    
            address_list = client_request.split(" ",maxsplit=2)
    
            address = address_list[1]
    
            # 3；读取指定页面
            with open("static"+ address,"rb") as file:
                file_data = file.read()
    
            # 4:构建响应报文
            response_line = "HTTP/1.1 200 ok\r\n"
            # 这里面存的是键值对，但是都不加引号
            response_head = "server:NB/1.0\r\n"
            response_body = file_data
    
            response_data = (response_line + response_head + "\r\n").encode('utf-8')+response_body
            # 5:返回给浏览器
            new_socket.send(response_data)
    
            new_socket.close()
    
    
    
    
    if __name__ == '__main__':
        main()

3：搭建静态web服务器页面—增加默认页面

# 分析：判断我的地址是不是/  如果是换成/index.html就好了
    
    
    import socket
    
    def main():
    
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("",7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
    
            client_request = new_socket.recv(1024).decode('utf-8')
            print(client_request)
    
            address_list = client_request.split(" ",maxsplit=2)
    
            address = address_list[1]
            if address == "/":
                address = "/index.html"
    
            # 3；读取指定页面
            with open("static"+ address,"rb") as file:
                file_data = file.read()
    
            # 4:构建响应报文
            response_line = "HTTP/1.1 200 ok\r\n"
            # 这里面存的是键值对，但是都不加引号
            response_head = "server:NB/1.0\r\n"
            response_body = file_data
    
            response_data = (response_line + response_head + "\r\n").encode('utf-8')+response_body
            # 5:返回给浏览器
            new_socket.send(response_data)
    
            new_socket.close()
    
    
    
    
    if __name__ == '__main__':
        main()

4：搭建静态web服务器页面—报错页面

# 分析：如果找不到地址，服务器会因为报错而挂掉，
    # 所以可以 try  except  捕获异常，
    # 如果异常则返回报错页面
    
    
    # 分析：判断我的地址是不是/  如果是换成/index.html就好了
    
    
    import socket
    
    def main():
    
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("",7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
    
            client_request = new_socket.recv(1024).decode('utf-8')
            print(client_request)
    
            address_list = client_request.split(" ",maxsplit=2)
    
            address = address_list[1]
            if address == "/":
                address = "/index.html"
            
            try:
    
                # 3；读取指定页面
                with open("static"+ address,"rb") as file:
                    file_data = file.read()
                    # 4:构建响应报文
                    response_line = "HTTP/1.1 200 ok\r\n"
                    # 这里面存的是键值对，但是都不加引号
                    response_head = "server:NB/1.0\r\n"
                    response_body = file_data
                    response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                    new_socket.send(response_data)
            except Exception as e:
    
    
                print("报错信息：",e)
                # 4:构建响应报文
                response_line = "HTTP/1.1 404 not found!\r\n"
                # 这里面存的是键值对，但是都不加引号
                response_head = "server:NB/1.0\r\n"
                with open("static/error.html","rb") as file:
                    file_data = file.read()
    
                response_body = file_data
    
                response_data = (response_line + response_head + "\r\n").encode('utf-8')+response_body
                new_socket.send(response_data)
            # 5:返回给浏览器
            finally:
                new_socket.close()
    
    
    
    
    if __name__ == '__main__':
        main()

5：搭建静态web服务器页面—客户端异常断开处理

# Traceback (most recent call last):
    #   File "/home/ubuntu/Desktop/终极复习/05-找不到返回报错页面.py", line 69, in <module>
    #     main()
    #   File "/home/ubuntu/Desktop/终极复习/05-找不到返回报错页面.py", line 30, in main
    #     address = address_list[1]
    # IndexError: list index out of range
    
    # 分析：如果客户端突然关闭，会导致recv_data = new_socket.recv(1024).decode("utf-8")这个地方解阻塞，
    # 此时服务器会收到来自客户端的空数据，
    # 此时request_addr = request_list[1]这里就会拿不到数据，导致下标越界。
    
    # 分析：判断是不是空数据，如果是空数据，则关闭套接字，然后退出。
    # 为什么使用contiinue??
    # 如果break 退出后，其他的客户端将无法访问。
    
    
    import socket
    
    
    def main():
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("", 7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
    
            client_request = new_socket.recv(1024).decode('utf-8')
    
            if len(client_request) == 0:
                new_socket.close()
                continue
    
            print(client_request)
    
            address_list = client_request.split(" ", maxsplit=2)
    
            address = address_list[1]
            if address == "/":
                address = "/index.html"
    
            try:
    
                # 3；读取指定页面
                with open("static" + address, "rb") as file:
                    file_data = file.read()
                    # 4:构建响应报文
                    response_line = "HTTP/1.1 200 ok\r\n"
                    # 这里面存的是键值对，但是都不加引号
                    response_head = "server:NB/1.0\r\n"
                    response_body = file_data
                    response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                    new_socket.send(response_data)
            except Exception as e:
    
                print("报错信息：", e)
                # 4:构建响应报文
                response_line = "HTTP/1.1 404 not found!\r\n"
                # 这里面存的是键值对，但是都不加引号
                response_head = "server:NB/1.0\r\n"
                with open("static/error.html", "rb") as file:
                    file_data = file.read()
    
                response_body = file_data
    
                response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                new_socket.send(response_data)
            # 5:返回给浏览器
            finally:
                new_socket.close()
    
    
    if __name__ == '__main__':
        main()

6：函数版本的静态web服务器

import socket
    
    def service_client(new_socket):
        client_request = new_socket.recv(1024).decode('utf-8')
    
        if len(client_request) == 0:
            new_socket.close()
            return
    
        print(client_request)
    
        address_list = client_request.split(" ", maxsplit=2)
    
        address = address_list[1]
        if address == "/":
            address = "/index.html"
    
        try:
    
            # 3；读取指定页面
            with open("static" + address, "rb") as file:
                file_data = file.read()
                # 4:构建响应报文
                response_line = "HTTP/1.1 200 ok\r\n"
                # 这里面存的是键值对，但是都不加引号
                response_head = "server:NB/1.0\r\n"
                response_body = file_data
                response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                new_socket.send(response_data)
        except Exception as e:
    
            print("报错信息：", e)
            # 4:构建响应报文
            response_line = "HTTP/1.1 404 not found!\r\n"
            # 这里面存的是键值对，但是都不加引号
            response_head = "server:NB/1.0\r\n"
            with open("static/error.html", "rb") as file:
                file_data = file.read()
    
            response_body = file_data
    
            response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
            new_socket.send(response_data)
        # 5:返回给浏览器
        finally:
            new_socket.close()
    
    
    
    def main():
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("", 7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
            service_client(new_socket)
    
    if __name__ == '__main__':
        main()

7：多任务版本的静态web服务器：

# 创建子线程，让子线程服务客户端，并且设置守护主线程
    
    import  threading
    import socket
    
    def service_client(new_socket):
        client_request = new_socket.recv(1024).decode('utf-8')
    
        if len(client_request) == 0:
            new_socket.close()
            return
    
        print(client_request)
    
        address_list = client_request.split(" ", maxsplit=2)
    
        address = address_list[1]
        if address == "/":
            address = "/index.html"
    
        try:
    
            # 3；读取指定页面
            with open("static" + address, "rb") as file:
                file_data = file.read()
                # 4:构建响应报文
                response_line = "HTTP/1.1 200 ok\r\n"
                # 这里面存的是键值对，但是都不加引号
                response_head = "server:NB/1.0\r\n"
                response_body = file_data
                response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                new_socket.send(response_data)
        except Exception as e:
    
            print("报错信息：", e)
            # 4:构建响应报文
            response_line = "HTTP/1.1 404 not found!\r\n"
            # 这里面存的是键值对，但是都不加引号
            response_head = "server:NB/1.0\r\n"
            with open("static/error.html", "rb") as file:
                file_data = file.read()
    
            response_body = file_data
    
            response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
            new_socket.send(response_data)
        # 5:返回给浏览器
        finally:
            new_socket.close()
    
    
    
    def main():
        # 1:初始化web服务器,采用IPV4和TCP连接通信
        tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        # 注意bind函数必须要一个数组
        tcp_socket.bind(("", 7788))
        tcp_socket.listen(128)
    
        # 2:循环接受客户端请求
        while True:
            new_socket, client_addr = tcp_socket.accept()
            print("客户端的地址信息是：", client_addr)
    
            # 注意这里的参数必须是元祖格式：
            t1 = threading.Thread(target=service_client,args=(new_socket,))
            t1.setDaemon(True)
            t1.start()
    
    
    
    if __name__ == '__main__':
        main()

8：面向对象版本的静态web服务器：

# 面向对象开发
    # 抽象：初始化的可以放在init 方法里面，另外可以创建一个启动的start方法，然后就是处理客户端的handle_client方法
    
    # 类名Create_Web_Service
    import socket
    import threading
    
    class Create_Web_Service():
    
    
        def __init__(self):
    
            self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
            # 注意bind函数必须要一个数组
            self.tcp_socket.bind(("", 7788))
            self.tcp_socket.listen(128)
    
        def start(self):
            while True:
                new_socket, client_addr = self.tcp_socket.accept()
                print("客户端的地址信息是：", client_addr)
    
                # 注意这里的参数必须是元祖格式：
                t1 = threading.Thread(target=self.handle_client, args=(new_socket,))
                t1.setDaemon(True)
                t1.start()
    
        def handle_client(self,new_socket):
            client_request = new_socket.recv(1024).decode('utf-8')
    
            if len(client_request) == 0:
                new_socket.close()
                return
    
            print(client_request)
    
            address_list = client_request.split(" ", maxsplit=2)
    
            address = address_list[1]
            if address == "/":
                address = "/index.html"
    
            try:
    
                # 3；读取指定页面
                with open("static" + address, "rb") as file:
                    file_data = file.read()
                    # 4:构建响应报文
                    response_line = "HTTP/1.1 200 ok\r\n"
                    # 这里面存的是键值对，但是都不加引号
                    response_head = "server:NB/1.0\r\n"
                    response_body = file_data
                    response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                    new_socket.send(response_data)
            except Exception as e:
    
                print("报错信息：", e)
                # 4:构建响应报文
                response_line = "HTTP/1.1 404 not found!\r\n"
                # 这里面存的是键值对，但是都不加引号
                response_head = "server:NB/1.0\r\n"
                with open("static/error.html", "rb") as file:
                    file_data = file.read()
    
                response_body = file_data
    
                response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                new_socket.send(response_data)
            # 5:返回给浏览器
            finally:
                new_socket.close()
    
    
    def main():
        cws = Create_Web_Service()
        cws.start()
    
    
    if __name__ == '__main__':
        main()

9：web框架处理动态请求：

# 思路：假设请求资源以.html结尾的，我们默认是动态资源。
    # 思路：判断address是不是以.html结尾的，如果是交给框架处理，如果不是web服务器自己处理。
    # 服务器端要处理哪些事？？
    # 1：将地址打包成字典（方便按照键获取值）2：将地址字典交给框架处理，让框架返回状态码，响应头，响应体。
    # 3：自己再组装成相应报文，发送给浏览器
    
    
    import socket
    import threading
    import framework_centerport
    class Create_Web_Service():
    
    
        def __init__(self):
    
            self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.tcp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
            # 注意bind函数必须要一个数组
            self.tcp_socket.bind(("", 7788))
            self.tcp_socket.listen(128)
    
        def start(self):
            while True:
                new_socket, client_addr = self.tcp_socket.accept()
                print("客户端的地址信息是：", client_addr)
    
                # 注意这里的参数必须是元祖格式：
                t1 = threading.Thread(target=self.handle_client, args=(new_socket,))
                t1.setDaemon(True)
                t1.start()
    
        def handle_client(self,new_socket):
            client_request = new_socket.recv(1024).decode('utf-8')
    
            if len(client_request) == 0:
                new_socket.close()
                return
    
            print(client_request)
    
            address_list = client_request.split(" ", maxsplit=2)
    
            address = address_list[1]
            if address == "/":
                address = "/index.html"
    
            if address.endswith(".html"):
                env = {
        "address":address}
                status, heads,response_body = framework_centerport.handle_request(env)
    
                response_line = "HTTP/1.1 %s\r\n" % status
                response_head = ""
                for head in heads:
                    response_head += "%s:%s\r\n" % head
    
                response_data = (response_line+response_head+"\r\n"+response_body).encode("utf-8")
    
                new_socket.send(response_data)
    
                new_socket.close()
    
            else:
    
                try:
                    # 3；读取指定页面
                    with open("static" + address, "rb") as file:
                        file_data = file.read()
                        # 4:构建响应报文
                        response_line = "HTTP/1.1 200 ok\r\n"
                        # 这里面存的是键值对，但是都不加引号
                        response_head = "server:NB/1.0\r\n"
                        response_body = file_data
                        response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                        new_socket.send(response_data)
                except Exception as e:
    
                    print("报错信息：", e)
                    # 4:构建响应报文
                    response_line = "HTTP/1.1 404 not found!\r\n"
                    # 这里面存的是键值对，但是都不加引号
                    response_head = "server:NB/1.0\r\n"
                    with open("static/error.html", "rb") as file:
                        file_data = file.read()
    
                    response_body = file_data
    
                    response_data = (response_line + response_head + "\r\n").encode('utf-8') + response_body
                    new_socket.send(response_data)
                # 5:返回给浏览器
                finally:
                    new_socket.close()
    
    
    def main():
        cws = Create_Web_Service()
        cws.start()
    
    
    if __name__ == '__main__':
        main()

10：web框架—基本框架

# 框架的开发思路：
    # 我的handle_request来接受用户发来的请求，在字典中获取地址，如果地址和我存在的匹配，
    # 交给我的同名方法去执行，如果不存在则读取错误页面，返回错误页面。
    import time
    
    
    # 方法内部怎么做？？
    # 构造状态码，响应头，响应体 ,时间模拟内容
    
    
    
    def index():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
        response_body = time.ctime()
        return status, heads, response_body
    
    def not_found():
        status = "404 not found"
        heads = [("server","NB/1.0")]
        response_body = "not found"
        return status, heads, response_body
    
    def handle_request(env):
    
        address = env["address"]
        if address == "/index.html":
            result = index()
            return result
    
        else:
            result = not_found()
            return result

11：web框架—返回模板页面

# 框架的开发思路：
    # 我的handle_request来接受用户发来的请求，在字典中获取地址，如果地址和我存在的匹配，
    # 交给我的同名方法去执行，如果不存在则读取错误页面，返回错误页面。
    import time
    # 方法内部怎么做？？
    # 构造状态码，响应头，响应体 ,时间模拟内容
    
    def index():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/index.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}",time.ctime())
    
        return status, heads, response_body
    
    def not_found():
        status = "404 not found"
        heads = [("server","NB/1.0")]
        response_body = "not found"
        return status, heads, response_body
    
    def handle_request(env):
    
        address = env["address"]
        if address == "/index.html":
            result = index()
            return result
    
        else:
            result = not_found()
            return result

12：web框架—路由列表：

# 现在我们想再增加请求：那么就需要在web框架增加一个函数单独处理。
    # 例如增加一个center页面的处理过程。如果页面再次增多，
    # 比如100个页面就需要100if else判断，能不能简化代码呢？
    
    # 解决思路：创建一个路由列表，列表里面用元祖存储地址和对应的方法名（本质是地址），每次都循环遍历。
    
    
    import time
    
    
    def index():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/index.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}",time.ctime())
    
        return status, heads, response_body
    
    def center():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/center.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}",time.ctime())
    
        return status, heads, response_body
    
    
    def not_found():
        status = "404 not found"
        heads = [("server","NB/1.0")]
        response_body = "not found"
        return status, heads, response_body
    
    rote_list = [("/index.html",index),("/center.html",center)]
    
    def handle_request(env):
    
        address = env["address"]
        for path, func in rote_list:
    
            if address == path:
                result = func()
                return result
    
        else:
            result = not_found()
            return result

13：装饰器替代路由列表：

# 问题：如果需要添加网页，每次都需要手动添加到路由表中，很费事。
    
    # 解决：创建带参装饰器,每次运行程序，自动向列表中添加。
    
    import time
    
    # 注：列表和装饰器必须放在最前面
    rote_list = []
    def decorator(address):
        def out_fun(fun):
            rote_list.append((address, fun))
    
            def inner_fun():
                fun()
    
            return inner_fun
    
        return out_fun
    
    @decorator("/index.html")
    def index():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/index.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}",time.ctime())
    
        return status, heads, response_body
    
    
    
    @decorator("/center.html")
    def center():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/center.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}",time.ctime())
    
        return status, heads, response_body
    
    
    def not_found():
        status = "404 not found"
        heads = [("server","NB/1.0")]
        response_body = "not found"
        return status, heads, response_body
    
    
    def handle_request(env):
    
        address = env["address"]
        for path, func in rote_list:
    
            if address == path:
                result = func()
                return result
    
        else:
            result = not_found()
            return result

14：返回主页内容：

# 显示股票信息页面的开发。
    
    # 在数据库中查询数据： 1:连接数据库  2：创建游标对象  3：执行sql语句，返回结果集  4：构造前端页面  5：返回响应体数据
    import pymysql
    import time
    
    # 注：列表和装饰器必须放在最前面
    rote_list = []
    def decorator(address):
        def out_fun(fun):
            rote_list.append((address, fun))
    
            def inner_fun():
                fun()
    
            return inner_fun
    
        return out_fun
    
    @decorator("/index.html")
    def index():
    
        conn = pymysql.connect(host="localhost",port=3306,user="root",password="123456",database="stock_db",charset="utf8")
        cur = conn.cursor()
        sql_str = "select * from info"
        cur.execute(sql_str)
        # 拿到的数据是元祖套元祖的形式
        sql_data = cur.fetchall()
        # 因为后面web服务器有编码的处理，所以这里不用转码
        cur.close()
        conn.close()
    
        with open("template/index.html","r")as file:
            datas = file.read()
        data_sum = ""
        for data in sql_data:
            data_sum += '''<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="000007"></td>
                       </tr>''' % data
    
    
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
    
        response_body = datas.replace("{%content%}",data_sum)
    
        return status, heads, response_body
    
    
    
    @decorator("/center.html")
    def center():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/center.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}",time.ctime())
    
        return status, heads, response_body
    
    
    def not_found():
        status = "404 not found"
        heads = [("server","NB/1.0")]
        response_body = "not found"
        return status, heads, response_body
    
    
    def handle_request(env):
    
        address = env["address"]
        for path, func in rote_list:
    
            if address == path:
                result = func()
                return result
    
        else:
            result = not_found()
            return result

15：中心页面接口:

# 个人中心接口的开发：
    
    # 思路：当浏览器第一次请求center.html的时候，web框架先返回一个空模板文件center.html,
    # 然后center.html中的js部分利用ajax，向服务器请求center_data页面，
    # 然后web框架将数据库中查询到的数据以json的格式返回给浏览器。
    
    
    # 注意：Python中json.dump()函数可以转化数据成json格式，里面参数第一个必须是列表套字典的格式
    # 第二个参数是ensure_ascii=False，是将中文不转化成asci。
    
    # 在数据库中查询数据： 1:连接数据库  2：创建游标对象  3：执行sql语句，返回结果集  4：构造前端页面  5：返回响应体数据
    import pymysql
    import json
    
    
    
    
    # 注：列表和装饰器必须放在最前面
    rote_list = []
    def decorator(address):
        def out_fun(fun):
            rote_list.append((address, fun))
    
            def inner_fun():
                fun()
    
            return inner_fun
    
        return out_fun
    
    @decorator("/index.html")
    def index():
    
        conn = pymysql.connect(host="localhost",port=3306,user="root",password="123456",database="stock_db",charset="utf8")
        cur = conn.cursor()
        sql_str = "select * from info"
        cur.execute(sql_str)
        # 拿到的数据是元祖套元祖的形式
        sql_data = cur.fetchall()
        cur.close()
        conn.close()
    
        # 因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/index.html","r")as file:
            datas = file.read()
        data_sum = ""
        for data in sql_data:
            data_sum += '''<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="000007"></td>
                       </tr>''' % data
    
    
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0")]
    
    
        response_body = datas.replace("{%content%}",data_sum)
    
        return status, heads, response_body
    
    
    
    @decorator("/center.html")
    def center():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server","NB/1.0"),("Content-Type", "text/html;charset=utf-8")]
    
        #因为后面web服务器有编码的处理，所以这里不用转码
        with open("template/center.html","r")as file:
            data = file.read()
    
        response_body = data.replace("{%content%}","")
    
        return status, heads, response_body
    
    @decorator("/center_data.html")
    def center_data():
        status = "200 ok"
        # 注意这个地方用列表套元祖的格式,因为不一定有有个响应头
        heads = [("server", "NB/1.0"),("Content-Type", "text/html;charset=utf-8")]
    
        conn = pymysql.connect(host="localhost", port=3306, user="root", password="123456", database="stock_db",
                               charset="utf8")
        cur = conn.cursor()
        sql_str = '''select i.code, i.short, i.chg, 
                 i.turnover, i.price, i.highs, f.note_info 
                 from info as i inner join focus as f on i.id = f.info_id;'''
    
        cur.execute(sql_str)
        # 拿到的数据是元祖套元祖的形式
        sql_data = cur.fetchall()
        cur.close()
        conn.close()
    
        center_data_list = list()
        for row in sql_data:
            # 正确的创建字典的格式
            center_dict = dict()
            center_dict["code"] = row[0]
            center_dict["short"] = row[1]
            center_dict["chg"] = row[2]
            center_dict["turnover"] = row[3]
            center_dict["price"] = str(row[4])
            center_dict["highs"] = str(row[5])
            center_dict["note_info"] = row[6]
    
            center_data_list.append(center_dict)
    
        print(center_data_list)
    
        response_body = json.dumps(center_data_list, ensure_ascii=False)
    
        return  status,heads,response_body
    
    
    
    def not_found():
        status = "404 not found"
        heads = [("server","NB/1.0")]
        response_body = "not found"
        return status, heads, response_body
    
    
    def handle_request(env):
    
        address = env["address"]
        for path, func in rote_list:
    
            if address == path:
                result = func()
                return result
    
        else:
            result = not_found()
            return result

16:前端页面ajax的处理：

<!DOCTYPE html>
    <html lang="zh-CN">
    <head>
        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>个人中心 - 个人选股系统 V5.87</title>
        <link href="/css/bootstrap.min.css" rel="stylesheet">
        <script src="/js/jquery-1.12.4.min.js"></script>
        <script src="/js/bootstrap.min.js"></script>
        <script>
            $(document).ready(function(){
        
                    $("input[name='toDel']").each(function(){
          
                        var currentAdd = $(this);  
                        currentAdd.click(function(){
          
                            code = $(this).attr("systemIdVaule"); 
                            alert("/del/" + code + ".html"); 
                            $.get("/del/" + code + ".html", function(data, status){
        
                                alert("数据: " + data + "\n状态: " + status);
                            });
                            window.location.reload()
                        });  
                    });
    
                // 2.在个人中心模板文件添加ajax请求获取个人中心数据
                //  data: 是接收到web服务器发送回来的json数据 转换 js对象
       $.get("center_data.html", function (data) {
        
    
        var data_array = data;
    
        // 获取table标签对象
        var $table = $(".table")
        for(var i = 0; i < data_array.length; i++){
        
            // 获取每一条对象
            var center_obj = data_array[i];
            var row_html = '<tr>' +
                '<td>'+ center_obj.code +'</td>' +
                '<td>'+ center_obj.short +'</td>' +
                '<td>'+ center_obj.chg +'</td>' +
                '<td>'+ center_obj.turnover +'</td>' +
                '<td>'+ center_obj.price +'</td>' +
                '<td>'+ center_obj.highs +'</td>' +
                '<td>'+ center_obj.note_info +'</td>' +
                '<td><a type="button" class="btn btn-default btn-xs" href="/update/000007.html"> <span class="glyphicon glyphicon-star" aria-hidden="true"></span> 修改 </a></td><td><input type="button" value="删除" id="toDel" name="toDel" systemidvaule="000007"></td></tr>';
            // 为table标签添加每一行组装的html数据
            $table.append(row_html);
        }
    
    }, "json");
    
    
            });
        </script>
    </head>
    
    <body>
    <div class="navbar navbar-inverse navbar-static-top ">
            <div class="container">
            <div class="navbar-header">
                    <button class="navbar-toggle" data-toggle="collapse" data-target="#mymenu">
                            <span class="icon-bar"></span>
                            <span class="icon-bar"></span>
                            <span class="icon-bar"></span>
                     </button>
                     <a href="#" class="navbar-brand">选股系统</a>
            </div>
            <div class="collapse navbar-collapse" id="mymenu">
                    <ul class="nav navbar-nav">
                            <li ><a href="/index.html">股票信息</a></li>
                            <li class="active"><a href="">个人中心</a></li>
                    </ul>
    
            </div>
            </div>
    </div>
    <div class="container">
    
        <div class="container-fluid">
    
            <table class="table table-hover">
                <tr>
                        <th>股票代码</th>
                        <th>股票简称</th>
                        <th>涨跌幅</th>
                        <th>换手率</th>
                        <th>最新价(元)</th>
                        <th>前期高点</th>
                        <th style="color:red">备注信息</th>
                        <th>修改备注</th>
                        <th>del</th>
                </tr>
                {
        %content%}
            </table>
        </div>
    </div>
    </body>
    </html>