• python socket 制作http服务器 （面向对象封装）

    目录

     一、面向对象封装

    二、给服务器加上命令行参数

    三、植物大战僵尸小游戏服务器 

     一、面向对象封装

            在上一篇博客（使用 python socket 向http服务器发送请求并制作http服务器）
    基础上进行面向对象封装。

    代码：

    1. import socket
    2. from threading import Thread
    3.  
    4. class WebServer(object):
    5.  
    6.     # 初始化方法
    7.     def __init__(self):
    8.         # 创建套接字
    9.         self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    10.  
    11.         # 设置地址重用  SOL_SOCKET表示当前套接字，SO_REUSEADDR表示设置地址重用
    12.         self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    13.  
    14.         # 绑定端口
    15.         self.tcp_server_socket.bind(("", 8080))
    16.  
    17.         # 设置监听，让套接字由主动变为被动接收
    18.         self.tcp_server_socket.listen(128)
    19.  
    20.     def start(self):
    21.         """ 启动Web服务器 """
    22.         while True:
    23.             # 接收客户端连接  定义函数
    24.             new_client_socket, ip_port = self.tcp_server_socket.accept()
    25.             print("新的客户端%s已连接！" % str(ip_port))
    26.  
    27.             # 接收请求并作出响应
    28.             t1 = Thread(target=self.request_handler, args=(new_client_socket, ip_port))
    29.             t1.start()
    30.  
    31.     def request_handler(self, new_client_socket, ip_port):
    32.         """接收信息，并且做出响应"""
    33.  
    34.         # 接收客户端浏览器发送的请求协议
    35.         request_data = new_client_socket.recv(1024)  # 接收请求报文
    36.         # print(request_data)
    37.  
    38.         # 判断协议是否为空
    39.         if not request_data:
    40.             print("%s客户端已下线！" % str(ip_port))
    41.             new_client_socket.close()
    42.         else:
    43.             # 根据客户端浏览器请求的资源路径，返回请求资源
    44.             # 1.把请求协议解码，得到请求报文的字符串
    45.             request_text = request_data.decode()
    46.  
    47.             # 2.得到请求行
    48.             # 2.1 查找 第一个\r\n出现的位置
    49.             loc = request_text.find("\r\n")
    50.  
    51.             # 2.2 截取字符串，从开头截取到 第一个\r\n出现的位置
    52.             request_line = request_text[:loc]
    53.             # print(request_line)
    54.  
    55.             # 2.3 把请求行按照空格拆分，得到列表
    56.             request_line_list = request_line.split(" ")
    57.  
    58.             # 2.4 得到请求资源路径
    59.             file_path = request_line_list[1]
    60.             print("%s 正在请求：%s" % (str(ip_port), file_path))
    61.  
    62.             # 响应行
    63.             response_line = "HTTP/1.1 200 OK\r\n"
    64.  
    65.             # 响应头
    66.             response_header = "Server:Python20WS/2.1\r\n"
    67.  
    68.             # 响应空行
    69.             response_blank = "\r\n"
    70.  
    71.             # 响应主体
    72.             # 返回字符串内容
    73.             # response_body = "Hello World"
    74.  
    75.             # 返回固定页面
    76.             try:
    77.                 with open("static" + file_path, "rb") as file:
    78.                     response_body = file.read()
    79.             except Exception as e:
    80.                 # 重新修改响应行为 404
    81.                 response_line = "HTTP/1.1 404 Not Found\r\n"
    82.                 response_body = "Error! %s " % str(e)
    83.                 response_body = response_body.encode()
    84.  
    85.             # 拼接响应报文
    86.             response_data = (response_line + response_header + response_blank).encode() + response_body
    87.  
    88.             # 发送响应报文
    89.             new_client_socket.send((response_data))
    90.  
    91.             # 关闭连接
    92.             new_client_socket.close()
    93.  
    94. if __name__ == '__main__':
    95.     WS = WebServer()
    96.     WS.start()

    二、给服务器加上命令行参数

    1. import socket,sys
    2. from threading import Thread
    3.  
    4. class WebServer(object):
    5.  
    6.     # 初始化方法
    7.     def __init__(self, port):
    8.         # 创建套接字
    9.         self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    10.  
    11.         # 设置地址重用  SOL_SOCKET表示当前套接字，SO_REUSEADDR表示设置地址重用
    12.         self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    13.  
    14.         # 绑定端口
    15.         self.tcp_server_socket.bind(("", port))
    16.  
    17.         # 设置监听，让套接字由主动变为被动接收
    18.         self.tcp_server_socket.listen(128)
    19.  
    20.     def start(self):
    21.         """ 启动Web服务器 """
    22.         while True:
    23.             # 接收客户端连接  定义函数
    24.             new_client_socket, ip_port = self.tcp_server_socket.accept()
    25.             print("新的客户端%s已连接！" % str(ip_port))
    26.  
    27.             # 接收请求并作出响应
    28.             t1 = Thread(target=self.request_handler, args=(new_client_socket, ip_port))
    29.             t1.start()
    30.  
    31.     def request_handler(self, new_client_socket, ip_port):
    32.         """接收信息，并且做出响应"""
    33.  
    34.         # 接收客户端浏览器发送的请求协议
    35.         request_data = new_client_socket.recv(1024)  # 接收请求报文
    36.         # print(request_data)
    37.  
    38.         # 判断协议是否为空
    39.         if not request_data:
    40.             print("%s客户端已下线！" % str(ip_port))
    41.             new_client_socket.close()
    42.         else:
    43.             # 根据客户端浏览器请求的资源路径，返回请求资源
    44.             # 1.把请求协议解码，得到请求报文的字符串
    45.             request_text = request_data.decode()
    46.  
    47.             # 2.得到请求行
    48.             # 2.1 查找 第一个\r\n出现的位置
    49.             loc = request_text.find("\r\n")
    50.  
    51.             # 2.2 截取字符串，从开头截取到 第一个\r\n出现的位置
    52.             request_line = request_text[:loc]
    53.             # print(request_line)
    54.  
    55.             # 2.3 把请求行按照空格拆分，得到列表
    56.             request_line_list = request_line.split(" ")
    57.  
    58.             # 2.4 得到请求资源路径
    59.             file_path = request_line_list[1]
    60.             print("%s 正在请求：%s" % (str(ip_port), file_path))
    61.  
    62.             # 响应行
    63.             response_line = "HTTP/1.1 200 OK\r\n"
    64.  
    65.             # 响应头
    66.             response_header = "Server:Python20WS/2.1\r\n"
    67.  
    68.             # 响应空行
    69.             response_blank = "\r\n"
    70.  
    71.             # 响应主体
    72.             # 返回字符串内容
    73.             # response_body = "Hello World"
    74.  
    75.             # 返回固定页面
    76.             try:
    77.                 with open("static" + file_path, "rb") as file:
    78.                     response_body = file.read()
    79.             except Exception as e:
    80.                 # 重新修改响应行为 404
    81.                 response_line = "HTTP/1.1 404 Not Found\r\n"
    82.                 response_body = "Error! %s " % str(e)
    83.                 response_body = response_body.encode()
    84.  
    85.             # 拼接响应报文
    86.             response_data = (response_line + response_header + response_blank).encode() + response_body
    87.  
    88.             # 发送响应报文
    89.             new_client_socket.send((response_data))
    90.  
    91.             # 关闭连接
    92.             new_client_socket.close()
    93.  
    94. def main():
    95.     # 获取系统传递到程序的参数
    96.     params_list = sys.argv
    97.     # print(params_list)
    98.  
    99.     # 判断参数个数
    100.     if len(params_list) != 2:
    101.         print("启动失败，正确启动格式：python xxx.py port")
    102.  
    103.     # 判断端口号是否为纯数字
    104.     if not params_list[1].isdigit():
    105.         print("启动失败，端口号应为纯数字")
    106.  
    107.     port = int(params_list[1])
    108.  
    109.     WS = WebServer(port)
    110.     WS.start()
    111.  
    112. if __name__ == '__main__':
    113.     main()

    结果：

     

     

    三、植物大战僵尸小游戏服务器 

    项目结构：

     

     服务端代码：

    1. import socket,sys
    2.  
    3.  
    4. class WebServer(object):
    5.  
    6.     # 初始化方法
    7.     def __init__(self, port):
    8.         # 创建套接字
    9.         self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    10.  
    11.         # 设置地址重用  SOL_SOCKET表示当前套接字，SO_REUSEADDR表示设置地址重用
    12.         self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
    13.  
    14.         # 绑定端口
    15.         self.tcp_server_socket.bind(("", port))
    16.  
    17.         # 设置监听，让套接字由主动变为被动接收
    18.         self.tcp_server_socket.listen(128)
    19.  
    20.         self.project_dict = {}
    21.         self.project_dict["足球大战僵尸"] = "h5-game-footballVSzombies"
    22.         self.project_dict["植物大战僵尸"] = "h5-game-plantsVSzombies"
    23.  
    24.         self.current_dir = ""
    25.  
    26.         self.init_projects()
    27.  
    28.     def init_projects(self):
    29.         # 显示所有的游戏名称
    30.         key_list = list(self.project_dict.keys())  # 取出字典的key并且转换成列表
    31.         for index, gameName in enumerate(key_list):
    32.             print("%d.%s" % (index, gameName))
    33.  
    34.         # 接收用户的选择
    35.         sel_no = int(input("请选择游戏序号：\n"))
    36.  
    37.         # 根据用户的选择来运行指定游戏
    38.         key = key_list[sel_no]
    39.  
    40.         # 根据key得到项目路径
    41.         self.current_dir = self.project_dict[key]
    42.         print(key, self.current_dir)
    43.  
    44.     def start(self):
    45.         """ 启动Web服务器 """
    46.         print("网游服务器已启动！")
    47.         while True:
    48.             # 接收客户端连接  定义函数
    49.             new_client_socket, ip_port = self.tcp_server_socket.accept()
    50.             print("新的客户端%s已连接！" % str(ip_port))
    51.  
    52.             # 接收请求并作出响应
    53.             self.request_handler(new_client_socket, ip_port)
    54.  
    55.     def request_handler(self, new_client_socket, ip_port):
    56.         """接收信息，并且做出响应"""
    57.  
    58.         # 接收客户端浏览器发送的请求协议
    59.         request_data = new_client_socket.recv(1024)  # 接收请求报文
    60.         # print(request_data)
    61.  
    62.         # 判断协议是否为空
    63.         if not request_data:
    64.             print("%s客户端已下线！" % str(ip_port))
    65.             new_client_socket.close()
    66.         else:
    67.             # 根据客户端浏览器请求的资源路径，返回请求资源
    68.             # 1.把请求协议解码，得到请求报文的字符串
    69.             request_text = request_data.decode()
    70.  
    71.             # 2.得到请求行
    72.             # 2.1 查找 第一个\r\n出现的位置
    73.             loc = request_text.find("\r\n")
    74.  
    75.             # 2.2 截取字符串，从开头截取到 第一个\r\n出现的位置
    76.             request_line = request_text[:loc]
    77.             # print(request_line)
    78.  
    79.             # 2.3 把请求行按照空格拆分，得到列表
    80.             request_line_list = request_line.split(" ")
    81.  
    82.             # 2.4 得到请求资源路径
    83.             file_path = request_line_list[1]
    84.             print("%s 正在请求：%s" % (str(ip_port), file_path))
    85.  
    86.             if file_path == "/":
    87.                 file_path = "/index.html"
    88.  
    89.             # 响应行
    90.             response_line = "HTTP/1.1 200 OK\r\n"
    91.  
    92.             # 响应头
    93.             response_header = "Server:Python20WS/2.1\r\n"
    94.             # response_header = response_header + "Content-Type: text/html\r\n"
    95.  
    96.             # 响应空行
    97.             response_blank = "\r\n"
    98.  
    99.             # 响应主体
    100.             # 返回字符串内容
    101.             # response_body = "Hello World"
    102.  
    103.             # 返回固定页面
    104.             try:
    105.                 with open(self.current_dir + file_path, "rb") as file:
    106.                     response_body = file.read()
    107.             except Exception as e:
    108.                 # 重新修改响应行为 404
    109.                 response_line = "HTTP/1.1 404 Not Found\r\n"
    110.                 response_body = "Error! %s " % str(e)
    111.                 response_body = response_body.encode()
    112.  
    113.             # 拼接响应报文
    114.             response_data = (response_line + response_header + response_blank).encode() + response_body
    115.  
    116.             # 发送响应报文
    117.             new_client_socket.send((response_data))
    118.  
    119.             # 关闭连接
    120.             new_client_socket.close()
    121.  
    122. def main():
    123.     # 获取系统传递到程序的参数
    124.     params_list = sys.argv
    125.     # print(params_list)
    126.  
    127.     # 判断参数个数
    128.     if len(params_list) != 2:
    129.         print("启动失败，正确启动格式：python xxx.py port")
    130.  
    131.     # 判断端口号是否为纯数字
    132.     if not params_list[1].isdigit():
    133.         print("启动失败，端口号应为纯数字")
    134.  
    135.     port = int(params_list[1])
    136.  
    137.     WS = WebServer(port)
    138.     WS.start()
    139.  
    140. if __name__ == '__main__':
    141.     main()

    效果：

     

     前端代码下载地址：

    原生JS实现的h5小游戏-植物大战僵尸

  • 相关阅读:
    Java学习之super关键字
    c语言难点
    使用【时间差】调整时间datetime.timedelta()
    【BLE】蓝牙抓包器 Ellisys 使用说明
    WebGPU的计算着色器实现冒泡排序
    Java NIO ByteBuffer原理使用图文详解
    Rust vs C++ 深度比较
    青少年python系列 42.面向对象-继承
    支持CAN FD的Kvaser PCIEcan 4xCAN v2编码: 73-30130-01414-5如何应用？
    初中级前端程序员面试中小型公司会问哪些问题
  • 原文地址：https://blog.csdn.net/ChaoChao66666/article/details/126798296