3、Web服务器

1. 静态web服务器 - 多任务

1. 示例

   import socket
   import threading
   
   # 处理客户端请求
   def handle_request_client(new_socket):
       # 接收客户端的请求信息
       recv_data = new_socket.recv(4096)
       # 请求数据为空，直接返回
       if len(recv_data) == 0:
           new_socket.close()
           return
       # 对数据按照空格进行分割
       recv_content = recv_data.decode("utf-8")
       request_list = recv_content.split(" ", maxsplit=2)
       # 获取请求的资源路径
       request_path = request_list[1]
       # 判断请求的是否为根目录，若为根目录返回首页
       if request_path == "/" :
           request_path = "/index.html"
       try:
           # 打开文件，读取文件中的数据
           # with open 由系统关闭文件，无需手动关闭，使用rb模式，默认兼容二进制文件
           with open("Ccblogs" + request_path, "rb") as file:
               file_data = file.read()
       except Exception as e:
           # 响应行
           response_line = "HTTP/1.1 404 Not Found\r\n"
           # 响应头
           response_header = "Server: ccblogs/1.0\r\n"
           # 打开文件，读取文件中的数据
           # with open 由系统关闭文件，无需手动关闭，使用rb模式，默认兼容二进制文件
           with open("Ccblogs/error.html", "rb") as file:
               file_data = file.read()
   
           # 响应体
           response_body = file_data
   
           # 把数据封装成http响应报文格式的数据, 把字符串编码成二进制
           response = (response_line + response_header + "\r\n").encode("utf-8") + response_body
           # 发送给浏览器的响应报文数据
           new_socket.send(response)
       else:
           # 响应行
           response_line = "HTTP/1.1 200 OK\r\n"
           # 响应头
           response_header = "Server: ccblogs/1.0\r\n"
           # 响应体
           response_body = file_data
   
           # 把数据封装成http响应报文格式的数据, 把字符串编码成二进制
           response = (response_line + response_header + "\r\n").encode("utf-8") + response_body
           # 发送给浏览器的响应报文数据
           new_socket.send(response)
   
       finally:
           # 关闭服务于客户端的套接字
           new_socket.close()
   
   def recv():
   	# 创建tcp服务端套接字
       tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
       # 设置端口号复用，程序退出端口号立即释放
       tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
       # 绑定端口号
       tcp_server_socket.bind(("", 8000))
       # 设置监听
       tcp_server_socket.listen(128)
   
       while True:
       	# 等待接受客户端的连接请求
           new_socket, ip_port = tcp_server_socket.accept()
           sub_thread = threading.Thread(target=handle_request_client, args=(new_socket, ))
           sub_thread.setDaemon(True)
           sub_thread.start()
   
   
   # 判断是否为主模块
   if __name__ == '__main__':
       recv()
   

2. 静态web服务器 - 面向对象

1. 示例

   import socket
   import threading
   
   
   # http协议的web服务器类
   class HttpWebServer(object):
       def __init__(self):
           # 创建tcp服务端套接字
           tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
           # 设置端口号复用，程序退出端口号立即释放
           tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
           # 绑定端口号
           tcp_server_socket.bind(("", 8000))
           # 设置监听
           tcp_server_socket.listen(128)
   
           self.tcp_server_socket = tcp_server_socket
   
   
       def start(self):
           while True:
               # 等待接受客户端的连接请求
               new_socket, ip_port = self.tcp_server_socket.accept()
               sub_thread = threading.Thread(target=self.handle_request_client, args=(new_socket, ))
               sub_thread.setDaemon(True)
               sub_thread.start()
   
   
       # 处理客户端请求
       @staticmethod
       def handle_request_client(new_socket):
           # 接收客户端的请求信息
           recv_data = new_socket.recv(4096)
           # 请求数据为空，直接返回
           if len(recv_data) == 0:
               new_socket.close()
               return
           # 对数据按照空格进行分割
           recv_content = recv_data.decode("utf-8")
           request_list = recv_content.split(" ", maxsplit=2)
           # 获取请求的资源路径
           request_path = request_list[1]
           # 判断请求的是否为根目录，若为根目录返回首页
           if request_path == "/" :
               request_path = "/index.html"
           try:
               # 打开文件，读取文件中的数据
               # with open 由系统关闭文件，无需手动关闭，使用rb模式，默认兼容二进制文件
               with open("Ccblogs" + request_path, "rb") as file:
                   file_data = file.read()
           except Exception as e:
               # 响应行
               response_line = "HTTP/1.1 404 Not Found\r\n"
               # 响应头
               response_header = "Server: ccblogs/1.0\r\n"
               # 打开文件，读取文件中的数据
               # with open 由系统关闭文件，无需手动关闭，使用rb模式，默认兼容二进制文件
               with open("Ccblogs/error.html", "rb") as file:
                   file_data = file.read()
   
               # 响应体
               response_body = file_data
   
               # 把数据封装成http响应报文格式的数据, 把字符串编码成二进制
               response = (response_line + response_header + "\r\n").encode("utf-8") + response_body
               # 发送给浏览器的响应报文数据
               new_socket.send(response)
           else:
               # 响应行
               response_line = "HTTP/1.1 200 OK\r\n"
               # 响应头
               response_header = "Server: ccblogs/1.0\r\n"
               # 响应体
               response_body = file_data
   
               # 把数据封装成http响应报文格式的数据, 把字符串编码成二进制
               response = (response_line + response_header + "\r\n").encode("utf-8") + response_body
               # 发送给浏览器的响应报文数据
               new_socket.send(response)
   
           finally:
               # 关闭服务于客户端的套接字
               new_socket.close()
   
   
   def recv():
       # 创建web服务器
       webServer = HttpWebServer()
       webServer.start()
   
   
   # 判断是否为主模块
   if __name__ == '__main__':
       recv()
   

3. 获取终端命令行参数

1. 示例

   import sys
   
   # sys.argv返回一个列表，第一个参数为程序文件绝对路径
   print(sys.argv, type(sys.argv))
   

4. 静态web服务器 - 命令行启动动态绑定端口号

1. 示例

   import socket
   import threading
   
   
   # http协议的web服务器类
   class HttpWebServer(object):
       def __init__(self, port):
           # 创建tcp服务端套接字
           tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
           # 设置端口号复用，程序退出端口号立即释放
           tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
           # 绑定端口号
           tcp_server_socket.bind(("", port))
           # 设置监听
           tcp_server_socket.listen(128)
   
           self.tcp_server_socket = tcp_server_socket
   
   
       def start(self):
           while True:
               # 等待接受客户端的连接请求
               new_socket, ip_port = self.tcp_server_socket.accept()
               sub_thread = threading.Thread(target=self.handle_request_client, args=(new_socket, ))
               sub_thread.setDaemon(True)
               sub_thread.start()
   
   
       # 处理客户端请求
       @staticmethod
       def handle_request_client(new_socket):
           # 接收客户端的请求信息
           recv_data = new_socket.recv(4096)
           # 请求数据为空，直接返回
           if len(recv_data) == 0:
               new_socket.close()
               return
           # 对数据按照空格进行分割
           recv_content = recv_data.decode("utf-8")
           request_list = recv_content.split(" ", maxsplit=2)
           # 获取请求的资源路径
           request_path = request_list[1]
           # 判断请求的是否为根目录，若为根目录返回首页
           if request_path == "/" :
               request_path = "/index.html"
           try:
               # 打开文件，读取文件中的数据
               # with open 由系统关闭文件，无需手动关闭，使用rb模式，默认兼容二进制文件
               with open("Ccblogs" + request_path, "rb") as file:
                   file_data = file.read()
           except Exception as e:
               # 响应行
               response_line = "HTTP/1.1 404 Not Found\r\n"
               # 响应头
               response_header = "Server: ccblogs/1.0\r\n"
               # 打开文件，读取文件中的数据
               # with open 由系统关闭文件，无需手动关闭，使用rb模式，默认兼容二进制文件
               with open("Ccblogs/error.html", "rb") as file:
                   file_data = file.read()
   
               # 响应体
               response_body = file_data
   
               # 把数据封装成http响应报文格式的数据, 把字符串编码成二进制
               response = (response_line + response_header + "\r\n").encode("utf-8") + response_body
               # 发送给浏览器的响应报文数据
               new_socket.send(response)
           else:
               # 响应行
               response_line = "HTTP/1.1 200 OK\r\n"
               # 响应头
               response_header = "Server: ccblogs/1.0\r\n"
               # 响应体
               response_body = file_data
   
               # 把数据封装成http响应报文格式的数据, 把字符串编码成二进制
               response = (response_line + response_header + "\r\n").encode("utf-8") + response_body
               # 发送给浏览器的响应报文数据
               new_socket.send(response)
   
           finally:
               # 关闭服务于客户端的套接字
               new_socket.close()
   
   
   def recv():
       # 获取命令行参数
       params = sys.argv
   
       if len(params) != 2:
           print("Command Error")
           return
   
       if not params[1].isdigit():
           print("Command Error")
           return
   
       port = int(params[1])
   
       # 创建web服务器
       webServer = HttpWebServer(port)
       webServer.start()
   
   
   # 判断是否为主模块
   if __name__ == '__main__':
       recv()