HTTP协议
一、HTTP协议的介绍
HTTP协议就是超文本传输协议；
超文本是指超越文本限制或者超链接，比如：图片、音乐、视频、超链接等；
HTTP协议现在允许传输任意类型的数据；
传输HTTP协议格式的数据是基于TCP传输协议的，发送数据之前需要先建立连接；
二、HTTP协议的作用
**规定了**浏览器和Web服务器通信数据的格式，也就是说浏览器和web服务器通信需要使用http协议
三、浏览器访问web服务器的通信过程
通信效果图：
四、URL
4.1、URL的概念
URL表达的意思是同意资源定位符，通俗理解就是网络资源地址，也就是网址。
4.1、URL的组成
-
URL的样子：
http://news.163.com/18/1122/10/E178J2O4000189FH.html -
URL的组成部分：
1、协议部分：https://（端口号：443）、http://（端口号：80）、ftp://
2、域名部分：news.163.com
3、资源路径部分：/18/1122/10/E178J2O4000189FH.html -
域名：
域名就是IP地址的别名，它是用点进行分割使用英文字母和数字组成的名字。 -
URL的扩展：
https://news.163.com/hello.html?page=1&count=10
查询参数部分：?page=1&count=10 -
参数说明：
？后面的 page 表示第一个参数，后面的参数都使用 & 进行连接
五、HTTP协议的通信过程
5.1、开发者工具
Google Chrome按F12调出开发者工具
效果图：
开发者工具的标签选项说明：
- 元素（Elements）：用于查看或修改HTML标签
- 控制台（Console）：执行js代码
- 源代码（Sources）：查看静态资源文件，断电调试JS代码
- 网络（Network）：查看http协议的通信过程
六、HTTP请求报文
请求报文是浏览器发送个web服务器程序的http协议数据
6.1、请求报文介绍
HTTP最常见的请求报文有两种：
- GET:获取文本服务器数据
- POST:向web服务器提交数据
6.11、HTTP GET 请求报文
6.12、HTTP POST请求报文
6.2 HTTP响应报文
web服务器程序发送给浏览器的http协议的数据
6.21 HTTP响应报文分析
七、搭建Python自带静态Web服务器
可以为发出请求的浏览器提供静态文档的程序
如何搭建Python自带的静态Web服务器？
搭建Python自带的静态Web服务器使用 python3 -m http.server 端口号
- -m选项说明：
-m表示运行包里面的模块，进入自己指定静态文件的目录，通过浏览器访问对应的 html 文件
7.1、静态Web服务器-返回固定页面数据
7.11、开发自己的静态Web服务器
实现步骤：
1、编写一个TCP服务端程序
2、获取浏览器发送的http请求报文数据
3、读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器
4、HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字
static/1.html代码
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<meta http-equiv="X-UA_Compatible" content="ie=edge">
<title>Document</title>
<!-- 2.内嵌式的js -->
<!-- <script>-->
<!-- // alert('沙漠骆驼');-->
<!-- </script>-->
<!-- 3.外部js script 双标签 -->
<!-- <script src="my.js"></script>-->
</head>
<body>
1.行内式的js 直接写到元素的内部
<!-- <input type="button" value="唐伯虎" onclick="alert('秋香姐')">-->
</body>
</html>
import socket
if __name__ == '__main__':
#创建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(("",9000))
#设置监听
tcp_server_socket.listen(128)
#循环等待接受客户端的请求
while True:
#等待接收客户端的连接请求
new_socket,ip_port = tcp_server_socket.accept()
#代码执行到此，说明连接建立成功
#接收客户端的请求信息
recv_data = new_socket.recv(4096)
print(recv_data)
#打开文件读取文件中的数据
with open("static/1.html","r",encoding='utf-8') as file: #file表示打开文件的对象
file_data = file.read()
#with open 关闭文件这步操作不用程序员来完成，系统帮我们来完成
#响应行
response_line = "HTTP/1.1 200 OK\r\n"
#响应头
response_header = "Server:PWS/1.0\r\n"
#空行
#响应体
response_body = file_data
#把数据封装成http 响应报文格式的数据
response = response_line + response_header + "\r\n" + response_body
#把字符串编码成二进制
response_data = response.encode("utf-8")
#发送给浏览器的响应报文数据
new_socket.send(response_data)
# 关闭服务于客户端的套接字
new_socket.close()
7.2、静态Web服务器-返回指定页面数据
static/2.html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<meta http-equiv="X-UA_Compatible" content="ie=edge">
<title>Document</title>
<!-- <script>-->
<!-- //这是一个输入框-->
<!-- prompt('请输入您的年龄');-->
<!-- //alert 弹出警示框 输出的 展示给用户的-->
<!-- alert('计算结果是');-->
<!-- //console控制输出 给程序员测试用的-->
<!-- console.log('我是程序员能看到的')-->
<!-- </script>-->
</head>
<body>
实现步骤:
编写一个TCP服务端程序
获取浏览器发送的http请求报文数据
读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器。
HTTP响应报文数据发送完成以后，关闭服务于客户端的套接字。
</body>
</html>
import socket
def main():
# 创建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(("", 9000))
# 设置监听
tcp_server_socket.listen(128)
# 循环等待接受客户端的请求
while True:
# 等待接收客户端的连接请求
new_socket, ip_port = tcp_server_socket.accept()
print(ip_port)
# 代码执行到此，说明连接建立成功
# 接收客户端的请求信息
recv_data = new_socket.recv(4096)
# 判断接收的数据长度是否为0
if len(recv_data) == 0:
new_socket.close()
return
# 对二进制数据进行解码
recv_content = recv_data.decode("utf-8")
print(recv_content)
# 对数据按照空格进行分割
# maxsplit=2 分割两次
request_list = recv_content.split(" ", maxsplit=2)
# 获取请求的资源
request_path = request_list[1]
print(request_path)
# 判断是否请求的根目录，如果是则设置返回的根目录信息
if request_path == "/":
request_path = "/1.html"
# 打开文件读取文件中的数据
with open("static" + request_path, "rb") as file: # file表示打开文件的对象
file_data = file.read()
# with open 关闭文件这步操作不用程序员来完成，系统帮我们来完成
# 响应行
response_line = "HTTP/1.1 200 OK\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 空行
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
# 关闭服务于客户端的套接字
new_socket.close()
if __name__ == '__main__':
main()
7.3、静态Web服务器-返回404页面
static/error.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>not found</title>
</head>
<body>
<h1>请求资源未找到</h1>
</body>
</html>
import socket,os
def main():
# 创建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(("", 9000))
# 设置监听
tcp_server_socket.listen(128)
# 循环等待接受客户端的请求
while True:
# 等待接收客户端的连接请求
new_socket, ip_port = tcp_server_socket.accept()
print(ip_port)
# 代码执行到此，说明连接建立成功
# 接收客户端的请求信息
recv_data = new_socket.recv(4096)
# 判断接收的数据长度是否为0
if len(recv_data) == 0:
new_socket.close()
return
# 对二进制数据进行解码
recv_content = recv_data.decode("utf-8")
print(recv_content)
# 对数据按照空格进行分割
# maxsplit=2 分割两次
request_list = recv_content.split(" ", maxsplit=2)
# 获取请求的资源
request_path = request_list[1]
print(request_path)
# 判断是否请求的根目录，如果是则设置返回的根目录信息
if request_path == "/":
request_path = "/1.html"
# 判断是否文件存在
# 1、os.path.exits
# os.path.exits("static/" + request_path)
# 2、try-except
try:
# 打开文件读取文件中的数据
with open("static" + request_path, "rb") as file: # file表示打开文件的对象
file_data = file.read()
# with open 关闭文件这步操作不用程序员来完成，系统帮我们来完成
except Exception as e:
#代码执行到此，说明没有请求的该文件，返回404状态信息
# 响应行
response_line = "HTTP/1.1 404 Not Found\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 读取404页面数据
with open("static/error.html","rb") as file:
# rb 封装为二进制数据
file_data = file.read()
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
else:
# 响应行
response_line = "HTTP/1.1 200 OK\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 空行
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
finally:
# 关闭服务于客户端的套接字
new_socket.close()
if __name__ == '__main__':
main()
7.4、静态Web服务器-多任务版
运行时出现问题：TypeError: handle_cliend_request() argument after * must be an iterable, not socket
报错原因：在使用多线程时，会调用多线程类中的 handle_cliend_request() 函数，这个函数需要传入一个可迭代对象，当我们的参数只有一个整数时，单独的整数不可迭代，所以报错；
解决办法：在整数后面加一个逗号(,) 使其变成元组，元组可迭代。
如下：从sub_thread = threading.Thread(target=handle_cliend_request,args=(new_socket))变为sub_thread = threading.Thread(target=handle_cliend_request,args=(new_socket,))
import socket,os,threading
# 处理客户端请求
def handle_cliend_request(new_socket):
# print(ip_port)
# 代码执行到此，说明连接建立成功
# 接收客户端的请求信息
recv_data = new_socket.recv(4096)
# 判断接收的数据长度是否为0
if len(recv_data) == 0:
new_socket.close()
return
# 对二进制数据进行解码
recv_content = recv_data.decode("utf-8")
print(recv_content)
# 对数据按照空格进行分割
# maxsplit=2 分割两次
request_list = recv_content.split(" ", maxsplit=2)
# 获取请求的资源
request_path = request_list[1]
print(request_path)
# 判断是否请求的根目录，如果是则设置返回的根目录信息
if request_path == "/":
request_path = "/1.html"
# 判断是否文件存在
# 1、os.path.exits
# os.path.exits("static/" + request_path)
# 2、try-except
try:
# 打开文件读取文件中的数据
with open("static" + request_path, "rb") as file: # file表示打开文件的对象
file_data = file.read()
# with open 关闭文件这步操作不用程序员来完成，系统帮我们来完成
except Exception as e:
# 代码执行到此，说明没有请求的该文件，返回404状态信息
# 响应行
response_line = "HTTP/1.1 404 Not Found\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 读取404页面数据
with open("static/error.html", "rb") as file:
# rb 封装为二进制数据
file_data = file.read()
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
else:
# 响应行
response_line = "HTTP/1.1 200 OK\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 空行
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
finally:
# 关闭服务于客户端的套接字
new_socket.close()
def main():
# 创建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(("", 9000))
# 设置监听
tcp_server_socket.listen(128)
# 循环等待接受客户端的请求
while True:
# 等待接收客户端的连接请求
new_socket, ip_port = tcp_server_socket.accept()
sub_thread = threading.Thread(target=handle_cliend_request,args=(new_socket,))
# 设置成为守护主线程(子线程不结束主线程也能结束)
sub_thread.setDaemon(True)
#启动子线程
sub_thread.start()
if __name__ == '__main__':
main()
7.5、静态Web服务器-面向对象开发
实现步骤：
- 把提供服务的Web服务器抽象成一个类(HTTPWebServer)
- 提供Web服务器的初始化方法，在初始化方法里面创建socket对象
- 提供一个开启Web服务器的方法，让Web服务器处理客户端请求操作
代码：
import socket,os,threading
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(("", 9000))
# 设置监听
tcp_server_socket.listen(128)
# 把tcp服务器的套接字作为web服务器的对象的属性
self.tcp_server_socket = tcp_server_socket
# 处理客户端请求
# @staticmethod:即用不到当前对象 也用不到当前类
@staticmethod
def handle_cliend_request(new_socket):
# print(ip_port)
# 代码执行到此，说明连接建立成功
# 接收客户端的请求信息
recv_data = new_socket.recv(4096)
# 判断接收的数据长度是否为0
if len(recv_data) == 0:
new_socket.close()
return
# 对二进制数据进行解码
recv_content = recv_data.decode("utf-8")
print(recv_content)
# 对数据按照空格进行分割
# maxsplit=2 分割两次
request_list = recv_content.split(" ", maxsplit=2)
# 获取请求的资源
request_path = request_list[1]
print(request_path)
# 判断是否请求的根目录，如果是则设置返回的根目录信息
if request_path == "/":
request_path = "/1.html"
# 判断是否文件存在
# 1、os.path.exits
# os.path.exits("static/" + request_path)
# 2、try-except
try:
# 打开文件读取文件中的数据
with open("static" + request_path, "rb") as file: # file表示打开文件的对象
file_data = file.read()
# with open 关闭文件这步操作不用程序员来完成，系统帮我们来完成
except Exception as e:
# 代码执行到此，说明没有请求的该文件，返回404状态信息
# 响应行
response_line = "HTTP/1.1 404 Not Found\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 读取404页面数据
with open("static/error.html", "rb") as file:
# rb 封装为二进制数据
file_data = file.read()
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
else:
# 响应行
response_line = "HTTP/1.1 200 OK\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 空行
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
finally:
# 关闭服务于客户端的套接字
new_socket.close()
# 启动服务器的方法
def start(self):
# 循环等待接受客户端的请求
while True:
# 等待接收客户端的连接请求
new_socket, ip_port = self.tcp_server_socket.accept()
sub_thread = threading.Thread(target=self.handle_cliend_request, args=(new_socket,))
# 设置成为守护主线程(子线程不结束主线程也能结束)
sub_thread.setDaemon(True)
# 启动子线程
sub_thread.start()
def main():
#创建Web服务器
web_server = HttpWebServer()
#启动服务器
web_server.start()
if __name__ == '__main__':
main()
7.6、获取终端命令行参数
通过终端打开：
import sys
#获取终端命令行参数
params = sys.argv
# 列表里面的每项数据都是字符串类型
print(params,type(params))
7.7、静态Web服务器-命令行启动动态绑定端口号
步骤：
- 获取执行python程序的终端命令行参数
- 判断参数的类型，设置端口号必须是整型
- 给Web服务器类的初始化方法添加一个端口号参数，用于绑定端口号
代码：
import socket,os,threading,sys
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)
# 把tcp服务器的套接字作为web服务器的对象的属性
self.tcp_server_socket = tcp_server_socket
# 处理客户端请求
# @staticmethod:即用不到当前对象 也用不到当前类
@staticmethod
def handle_cliend_request(new_socket):
# print(ip_port)
# 代码执行到此，说明连接建立成功
# 接收客户端的请求信息
recv_data = new_socket.recv(4096)
# 判断接收的数据长度是否为0
if len(recv_data) == 0:
new_socket.close()
return
# 对二进制数据进行解码
recv_content = recv_data.decode("utf-8")
print(recv_content)
# 对数据按照空格进行分割
# maxsplit=2 分割两次
request_list = recv_content.split(" ", maxsplit=2)
# 获取请求的资源
request_path = request_list[1]
print(request_path)
# 判断是否请求的根目录，如果是则设置返回的根目录信息
if request_path == "/":
request_path = "/1.html"
# 判断是否文件存在
# 1、os.path.exits
# os.path.exits("static/" + request_path)
# 2、try-except
try:
# 打开文件读取文件中的数据
with open("static" + request_path, "rb") as file: # file表示打开文件的对象
file_data = file.read()
# with open 关闭文件这步操作不用程序员来完成，系统帮我们来完成
except Exception as e:
# 代码执行到此，说明没有请求的该文件，返回404状态信息
# 响应行
response_line = "HTTP/1.1 404 Not Found\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 读取404页面数据
with open("static/error.html", "rb") as file:
# rb 封装为二进制数据
file_data = file.read()
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
else:
# 响应行
response_line = "HTTP/1.1 200 OK\r\n"
# 响应头
response_header = "Server:PWS/1.0\r\n"
# 空行
# 响应体
response_body = file_data
# 把数据封装成http 响应报文格式的数据
# response_body是二进制数据 不能和字符串进行拼接 需要将字符串转换成二进制
response = (response_line + response_header + "\r\n").encode('utf-8') + response_body
# 把字符串编码成二进制
# response_data = response.encode("utf-8")
# 发送给浏览器的响应报文数据
new_socket.send(response)
finally:
# 关闭服务于客户端的套接字
new_socket.close()
# 启动服务器的方法
def start(self):
# 循环等待接受客户端的请求
while True:
# 等待接收客户端的连接请求
new_socket, ip_port = self.tcp_server_socket.accept()
sub_thread = threading.Thread(target=self.handle_cliend_request, args=(new_socket,))
# 设置成为守护主线程(子线程不结束主线程也能结束)
sub_thread.setDaemon(True)
# 启动子线程
sub_thread.start()
def main():
#获取终端命令行参数
params = sys.argv
if len(params) != 2:
print("执行的命令格式如下：python xxx.py 9000")
return
#判断第二个参数是否都是由数字组成的字符串
if not params[1].isdigit():
print("执行的命令格式如下：python xxx.py 9000")
return
# 代码执行到此，说明命令行参数的个数一定2个,并且第二个参数是由数字组成的字符串
port = int(params[1])
# print(params)
#创建Web服务器
web_server = HttpWebServer(port)
#启动服务器
web_server.start()
if __name__ == '__main__':
main()
扫一扫
12万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
