2024-10-03 07:00:34 +00:00
---
title: 超文本传输协议（ ）
tags:
2024-10-04 06:09:28 +00:00
- 网络协议
- HTTP
2024-10-04 06:18:55 +00:00
date: 2024-10-04 14:00:00
2024-10-03 07:00:34 +00:00
---
2024-10-04 06:09:28 +00:00
- [请求一个页面 ](#请求一个页面 )
- [用词约定 ](#用词约定 )
- [从零开始的HTTP服务器生涯 ](#从零开始的HTTP服务器生涯 )
- [GET和POST ](#GET和POST )
- [参考资料和扩展阅读 ](#参考资料和扩展阅读 )
2024-10-03 07:00:34 +00:00
<!-- more -->
## 请求一个页面
这篇文章会用到[Curl](https://curl.dev/)， （ ， ， ） ，
在大多数Linux发行版中， ， ：
````
$ curl --version
curl 7.85.0 (x86_64-redhat-linux-gnu) libcurl/7.85.0 OpenSSL/3.0.8 zlib/1.2.12 brotli/1.0.9 libidn2/2.3.4 libpsl/0.21.1 (+libidn2/2.3.3) libssh/0.10.4/openssl/zlib nghttp2/1.51.0
Release-Date: 2022-08-31
Protocols: dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt pop3 pop3s rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: alt-svc AsynchDNS brotli GSS-API HSTS HTTP2 HTTPS-proxy IDN IPv6 Kerberos Largefile libz NTLM NTLM_WB PSL SPNEGO SSL threadsafe TLS-SRP UnixSockets
````
如果你的系统已经安装了Curl， ，
如果你使用Windows， ， ， （ ： ， ）
你可以在命令行窗口中尝试`curl --version`：
````
> curl.exe --version
curl 7.79.1 (Windows) libcurl/7.79.1 Schannel
Release-Date: 2021-09-22
Protocols: dict file ftp ftps http https imap imaps pop3 pop3s smtp smtps telnet tftp
Features: AsynchDNS HSTS IPv6 Kerberos Largefile NTLM SPNEGO SSL SSPI UnixSockets
````
如果你正在使用没有预装Curl的Windows， curl.se/windows/ ](https://curl.se/windows/ ) 下载。
确认Curl可以使用，
````
$ curl --http1.1 http://example.com -v
* Trying 93.184.216.34:80...
* Trying 2606:2800:220:1:248:1893:25c8:1946:80...
* Immediate connect fail for 2606:2800:220:1:248:1893:25c8:1946: 网络不可达
* Connected to example.com (93.184.216.34) port 80 (#0)
> GET / HTTP/1.1
> Host: example.com
> User-Agent: curl/7.85.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP / 1 . 1 200 OK
< Age: 106060
< Cache-Control: max-age = 604800
< Content-Type: text / html ; charset = UTF-8
< Date: Sat , 18 Mar 2023 06:39:37 GMT
< Etag: " 3147526947 + ident "
< Expires: Sat , 25 Mar 2023 06:39:37 GMT
< Last-Modified: Thu , 17 Oct 2019 07:18:26 GMT
< Server: ECS ( sab / 5707 )
< Vary: Accept-Encoding
< X-Cache: HIT
< Content-Length: 1256
<
<!doctype html>
< html >
< head >
< title > Example Domain< / title >
< meta charset = "utf-8" / >
< meta http-equiv = "Content-type" content = "text/html; charset=utf-8" / >
< meta name = "viewport" content = "width=device-width, initial-scale=1" / >
< style type = "text/css" >
body {
background-color: #f0f0f2 ;
margin: 0;
padding: 0;
font-family: -apple-system, system-ui, BlinkMacSystemFont, "Segoe UI", "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
}
div {
width: 600px;
margin: 5em auto;
padding: 2em;
background-color: #fdfdff ;
border-radius: 0.5em;
box-shadow: 2px 3px 7px 2px rgba(0,0,0,0.02);
}
a:link, a:visited {
color: #38488f ;
text-decoration: none;
}
@media (max-width: 700px) {
div {
margin: 0 auto;
width: auto;
}
}
< / style >
< / head >
< body >
< div >
< h1 > Example Domain< / h1 >
< p > This domain is for use in illustrative examples in documents. You may use this
domain in literature without prior coordination or asking for permission.< / p >
< p > < a href = "https://www.iana.org/domains/example" > More information...< / a > < / p >
< / div >
< / body >
< / html >
* Connection #0 to host example.com left intact
````
在我们使用curl时， ， ， ， ； ，
让我们来关注`<!doctype html> `之前以`< `或`>`开头的行：
````
> GET / HTTP/1.1
> Host: example.com
> User-Agent: curl/7.85.0
> Accept: */*
>
< HTTP / 1 . 1 200 OK
< Age: 106060
< Cache-Control: max-age = 604800
< Content-Type: text / html ; charset = UTF-8
< Date: Sat , 18 Mar 2023 06:39:37 GMT
< Etag: " 3147526947 + ident "
< Expires: Sat , 25 Mar 2023 06:39:37 GMT
< Last-Modified: Thu , 17 Oct 2019 07:18:26 GMT
< Server: ECS ( sab / 5707 )
< Vary: Accept-Encoding
< X-Cache: HIT
< Content-Length: 1256
<
````
在这里，`>`的意思是发送到服务器，`< `是从服务器接收。我们向服务器发送的是“请求”（ ） ， （ ） ， （ ）
````
GET / HTTP/1.1
^^^ ~~~~~~~~~~~~ 请求方法 （ ）
^ ~~~~~~~~~~ 路径（ ）
^^^^^^^^ ~ 协议（ ）
````
这一行可以很容易用大白话说明： （ ） ‘
接下来这一段通常被叫作“HTTP头”：
````
Host: example.com
User-Agent: curl/7.85.0
Accept: */*
````
每一行意味着一个键值对，用`Key: Value`的格式。`Host: example.com`告诉服务器我们想请求的域名是`example.com`，其它两个头我们留到稍后再了解。
这些“HTTP头”跟第一行加起来组成了“HTTP请求头部”的数据。但是还没完， ：
````
````
它标志着“HTTP请求头部”的结束。
另外， ： ， ，
我们接着来看看服务器发回给我们的数据，它跟请求有两点不同，第一个是：
````
HTTP/1.1 200 OK
^^^^^^^^ ~~~~~~~~~~ 协议
^^^ ~~~~~~ 状态码（ ）
^^ ~~~ 状态信息
````
通常，状态码和状态信息一一对应，或者说，状态信息只是在解释状态码。在这里，`200`可以说是“成功”的意思。
第二个是， ， ， ：
````
<!doctype html>
< html >
...
````
如果你的电脑上有[telnet](https://en.wikipedia.org/wiki/Telnet)， ！
````
$ telnet example.com 80
Trying 93.184.216.34...
Connected to example.com.
Escape character is '^]'.
````
输入以下内容。就是上面HTTP请求的简化版，
````
GET / HTTP/1.1
Host: example.com
````
别忘了空行！ ， ，
## 用词约定
### 套接字和Socket
Socket是一种对于网络逻辑接口的抽象，
### HTTP头部、头
为了尊重使用习惯， ， ：
````
GET /path/to/page HTTP/1.1
Host: example.com
User-Agent: sample-client/1
````
HTTP头部指的是结束标志（ ） ，
### TCP
本文中的TCP是Transmission Control Protocol的缩写，
## 从零开始的HTTP服务器生涯
我们已经了解HTTP请求和响应的结构， ， ，
2024-10-04 06:09:28 +00:00
另外提一句， ， ，
2024-10-03 07:00:34 +00:00
你可能没有从零开始写HTTP服务器的经验， ：
1. 监听网络端口，等待连接
2. 从连接读取HTTP请求
3. 生成HTTP响应并返回
````python
def main():
pass
if __name__ == "__main__":
main()
````
### 等待客户端连接
HTTP运行在TCP之上， ，
我们将使用Python标准库里的[socket](https://docs.python.org/zh-cn/3/library/socket.html)， ， ， ：
1. 创建一个Socket（ ） ， （ ）
2. 把一个端口bind到这个Socket上（
3. 将这个Socket设置为监听（
完成这些工作后，
在main里添加代码之后：
````python
from socket import socket, AF_INET, SOCK_STREAM # 导入我们需要的值
def main():
# SOCK_STREAM配合AF_INET就是在IPv4上使用TCP的意思，
with socket(AF_INET, SOCK_STREAM) as server_port: # with会在运行离开这块代码之后关闭这个Socket
server_port.bind(("127.0.0.1", 8989)) # 将127.0.0.1:8989这个地址绑定到这个Socket上
server_port.listen() # 设置监听
conn, addr = server_port.accept() # conn是相应连接的Socket，
````
要实验我们的代码是否有效， ， ，
````python
from socket import socket, AF_INET, SOCK_STREAM
def main():
with socket(AF_INET, SOCK_STREAM) as server_port:
server_port.bind(("127.0.0.1", 8989))
server_port.listen()
conn, addr = server_port.accept()
with conn: # 运行离开这个with代码块时，
print(f"Accepted {addr}")
conn.settimeout(8)
while True:
data = conn.recv(4096) # 接收最多4096 bytes的数据
if data != b"\r\n": # 如果是一个空行（ ） ，
conn.send(data)
else:
break
if __name__ == "__main__":
main()
````
假设这个Python脚本的名字叫作`server.py`，我们执行`python server.py`（ ，
````
python server.py
````
现在我们可以使用`telnet localhost 8989`连接到我们的Echo服务器。输入一些内容、换行，
````
$ telnet localhost 8989
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Hello!
Hello!
Connection closed by foreign host.
````
### 读取HTTP请求
先让我们来总结一下我们之前了解到的内容： ， （ ）
一个信息包括两部分： ， ，
让我们新添加两个函数， ：
````python
def read_http_request(conn):
pass
def handle_http_request(conn):
pass
````
> HTTP在TCP连接上传输， ， ： ， ， ， （ ， ） ，
为了简化代码， ， ： ， （ ） ， ，
读取HTTP请求时， ，
````python
def read_http_request_header_string(conn: socket):
buffer = bytearray()
while True:
buffer.extend(conn.recv(4096))
header_length = buffer.find(b"\r\n\r\n") # 两个连在一起的CRLF，
if header_length != -1:
return buffer[:header_length]
````
这样我们就可以在`read_http_request`里使用它了，你可以先试着写一写这个`read_http_request`再看完整代码。
逻辑很简单，将读到的字符串按照`\r\n`分开，再分别处理第一行和剩余的行。需要注意的是，我们的` read_http_request_header_string`返回`bytes`（可以简单理解为一块内存），你需要用`decode`方法将其转换为字符串，该方法需要指定一个编码，你可以使用`"ascii"`。
````python
def read_http_request(conn: socket):
s = read_http_request_header_string(conn).decode("ascii")
lines = s.split("\r\n") # 按CRLF切开
# 解析第一行
fstline = lines[0]
method, path, protocol = fstline.split(" ") # 按空格切开第一行
if protocol != "HTTP/1.1":
raise RuntimeError("unknown protocol", protocol)
method = method.lower() # 把方法转换成小写
# 解析头
header = {}
if len(lines) > 1:
for line in lines[1:]:
key, value = line.split(": ")
header[key] = value
return method, path, header
````
### 生成HTTP响应头部
相对于读取请求，生成响应要简单多了，只需要按照格式拼装信息：
````python
STATUS_MESSAGES = {
200: "OK",
400: "Bad Request",
404: "Not Found",
500: "Server Error",
}
def build_http_response_header(status_code, headers):
lines = [
f"HTTP/1.1 {status_code} {STATUS_MESSAGES[status_code]}"
]
for key, value in headers:
lines.append(f"{key}: {value}")
lines.append("") # 别忘了加空行
lines.append("")
return '\r\n'.join(lines).encode('ascii')
````
请注意，这里为了增加空行，使用两次`lines.append("")`增加了两个空字符串。因为`'\r\n'.join`只在两个字符串中间增加分隔符`"\r\n"`。
举个例子：我们有`"A"`、`"B"`两个字符串，每个字符串一行。如果我们不增加空字符串，`'\r\n'.join`只会在A和B之间插入一个换行，
如果我们只在列表末尾增加一个空字符串，那么最后就只会是
````
"A\r\nB\r\n"
^ 新增加的空字符串
````
， ； ， ， ，
### 处理HTTP请求
接下来我们正式在`handle_http_request`中处理HTTP请求。首先我们读取HTTP请求， ，
````python
def handle_http_request(conn: socket):
try:
method, path, headers = read_http_request(conn)
except Exception as e:
conn.send(build_http_response_header(400, []))
print(f"- - 400 {STATUS_MESSAGES[400]}")
raise e # 把错误重新抛出，方便你看错误堆栈
````
然后我们检查方法是否是`get`，路径是否是`/`或者`/index.html`， ：
````python
if method == "get" and (path == "/" or path == "/index.html"):
headers = [
("Charset", "UTF-8"),
("Content-Length",str(len(DEFAULT_PAGE_HTML))),
("Connection", "close"),
]
conn.send(build_http_response_header(200, headers))
conn.send(DEFAULT_PAGE_HTML)
print(f"{method.upper()} {path} 200 {STATUS_MESSAGES[200]}")
````
你发现我们在这里设置了三个头，一个是`Charset`，我们将它设置为`UTF-8`， ，
````python
DEFAULT_PAGE_HTML = """<!doctype html>
< html >
< head >
< meta charset = "utf-8" / >
< title > Default Page< / title >
< / head >
< body >
< h1 > Hello World!< / h1 >
< / body >
< / html > """.encode("utf-8")
````
这里我们使用`.encode("utf-8")`将字符串转换为`bytes`。关于`decode`、`encode`方法和编解码可以阅读Python文档相应页面。
另一个头是`Content-Length`， （ ） ， ，
最后一个是`Connection: close`， ： ，
最后， ， ，
````python
else:
conn.send(build_http_response_header(404, []))
print(f"{method.upper()} {path} 404 {STATUS_MESSAGES[404]}")
````
最后只要在我们的main函数使用这个`handle_http_request`就好了。
````python
def main():
with socket(AF_INET, SOCK_STREAM) as server_port:
server_port.bind(("127.0.0.1", 8989))
server_port.listen()
conn, addr = server_port.accept()
with conn:
conn.settimeout(8)
handle_http_request(conn)
````
使用`python server.py`启动之后，使用`curl http://localhost:8989 -v`来看看效果。
````
$ curl http://localhost:8989 -v
* Trying 127.0.0.1:8989...
* Connected to localhost (127.0.0.1) port 8989 (#0)
> GET / HTTP/1.1
> Host: localhost:8989
> User-Agent: curl/7.85.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP / 1 . 1 200 OK
< Charset: UTF-8
< Content-Length: 175
< Connection: close
<
<!doctype html>
< html >
< head >
< meta charset = "utf-8" / >
< title > Default Page< / title >
< / head >
< body >
< h1 > Hello World!< / h1 >
< / body >
* Closing connection 0
< / html > ⏎
````
我们的代码处理了一个新连接就退出了，如果要让它持续处理新连接，只要从`accept`方法开始放在死循环里就行：
````python
def main():
with socket(AF_INET, SOCK_STREAM) as server_port:
server_port.bind(("127.0.0.1", 8989))
server_port.listen()
while True:
conn, addr = server_port.accept()
with conn:
conn.settimeout(8)
handle_http_request(conn)
````
[完整代码请见Gist ](https://gist.github.com/thislight/b0aaa23f247d62bb6d78cc650732b214 )
### 使用浏览器开发者工具
浏览器开发者工具是调试你Web程序的利器！ ， ， ，
先打开一个新标签页。你有两种方法打开开发者工具：一种是在浏览器菜单里点击“更多工具”， 点击“Web开发者工具”。
另一种打开方法是按键盘上的F12。
打开后， ， （ ）
接下来，在地址栏中输入我们服务器的地址`http://localhost:8989`、确认访问，就可以在这个页面下看到浏览器产生的请求。点击单个项目可以展开详细信息。
## GET和POST
我们的服务器应该能够根据用户的输入进行不同的操作， ？ ， ： （ ） ， ， ，
> 查询其实是属于URI的一部分。我们在这里说查询是在“路径”中，
但是有一些字符不能直接放进URI里， ， ， （ ） （ ， ， ）
比如说我们要在路径里携带`example@example.com`，比如`/?email=example@example.com`，我们必须将其编码成`/?email=example%40example.com`。
虽然查询里面可以携带任何允许的字符，但是使用类似上面的格式仍然是比较常用的做法。也就是`key=val`代表键key的值是val， & `从中间区分，比如`email=example%40example.com& nuke=1`，就有`email`和`nuke`两对键值。
接下来，我们一起改写上面的服务器，让它能够接受查询字符串，比如说在访问`/?name=HTTP`的时候可以返回"Hello HTTP！
### 在GET请求中接受用户输入
我们要修改以下部分：
- 修改访问路径匹配。我们之前使用`path == "/"`来确认正在访问的路径，这样的话`/?name=HTTP`就不能访问到`/`了。
- 处理查询里的键值对。我们需要从请求中的路径取得访问路径和查询，将查询里的键值对解析成我们需要的数据结构，在这里是字典。
- 让`DEFAULT_HTML_PAGE`的"World"可以自定义。我们在这里使用Python的`str.format`方法。
首先，我们需要从请求中的路径取得访问路径和查询：
````python
def read_path(path: str): # 返回访问路径和查询
parts = path.split("?", maxsplit=1)
if len(parts) > 1:
return parts[0], parts[1]
else:
return parts[0], ""
def handle_http_request(conn: socket):
# ...
onlypath, query = read_path(path)
if onlypath == "/" and method == "get":
# ...
````
然后，我们需要将查询里的键值对解析成字典：
````python
def parse_query(q: str):
pairs_str = q.split("& ")
pairs = {}
for s in pairs_str:
if s: # 确保不是空字符串
k, v = s.split("=")
pairs[unquote_plus(k)] = unquote_plus(v)
return pairs
````
在这里，我们使用了`urllib.parse`的`unquote_plus`函数，你需要在文件顶部引入它：
````python
from urllib.parse import unquote_plus
````
我们使用这个函数将URL编码的字符串转换为普通字符串。
接下来，我们要让`DEFAULT_HTML_PAGE`可以接受自定义名字。因为`bytes`对象没有`format`方法，我们得去掉`.encode`，改在自定义名字之后完成。
````python
DEFAULT_PAGE_HTML = """<!doctype html>
< html >
< head >
< meta charset = "utf-8" / >
< title > Default Page< / title >
< / head >
< body >
< h1 > Hello {name}!< / h1 >
< / body >
< / html > """
````
当我们使用`format`方法时，就可以替换掉`{name}`的内容，生成实际要发送给客户端的页面。这时`DEFAULT_PAGE_HTML`就被叫作“模板”，生成这个页面的过程叫“渲染”。
````python
if onlypath == "/" and method == "get":
query_dict = parse_query(query) # 解析查询键值对
# 渲染页面
content = DEFAULT_PAGE_HTML.format(
# 检查键值对中有没有键name， ，
name=(query_dict["name"] if query_dict.get("name") else "World")
).encode("utf-8")
headers = [
("Charset", "UTF-8"),
("Content-Length",str(len(content))), # 主体长度等于实际内容长度
("Connection", "close"),
]
conn.send(build_http_response_header(200, headers))
conn.send(content) # 发送渲染出来的页面
# ...
````
启动你的服务器。用`curl http://localhost:8989?name=HTTP -v`试试。
````
$ curl http://localhost:8989?name=HTTP -v
* Trying 127.0.0.1:8989...
* Connected to localhost (127.0.0.1) port 8989 (#0)
> GET /?name=HTTP HTTP/1.1
> Host: localhost:8989
> User-Agent: curl/7.85.0
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP / 1 . 1 200 OK
< Charset: UTF-8
< Content-Length: 174
< Connection: close
<
<!doctype html>
< html >
< head >
< meta charset = "utf-8" / >
< title > Default Page< / title >
< / head >
< body >
< h1 > Hello HTTP!< / h1 >
< / body >
* Closing connection 0
< / html > ⏎
````
你也可以用浏览器看看。修改一下`name`的值， ，
修改一下模板，就可以直接在网页里面使用这个参数了。
````python
DEFAULT_PAGE_HTML = """<!doctype html>
< html >
< head >
< meta charset = "utf-8" / >
< title > Default Page< / title >
< / head >
< body >
< h1 > Hello {name}!< / h1 >
< form method = "GET" >
< input name = "name" label = "Hello to..." / >
< button type = "submit" > Submit< / button >
< / form >
< / body >
< / html > """
````
HTML不在本文范围，
[完整代码请见Gist ](https://gist.github.com/thislight/d32a565609ee1f2379fc9b3af1d87012 )
### HTTP POST
目前为止， ， ？
- HTTP请求可以跟响应一样携带主体。GET请求不可以携带主体， ； ，
- 理论上HTTP请求头部的路径可以无限长，
- 在浏览器中，路径会被记录在浏览历史里，放在主体里的数据一般不会被记录。
如果我们使用HTML的form元素进行请求，
2024-10-04 06:09:28 +00:00
> 绝大部分情况下， ， ， （ ） ，
2024-10-03 07:00:34 +00:00
> 如果你使用HTML的form直接处理POST提交， ，
> 我们接下来就是采用类似方法。
让我们来改写我们之前的服务器， ， （ ）
先添加一个全局变量：
````python
global default_name
default_name = "World"
````
这是个比较大的改写， ，
````python
def read_http_request_header_string(conn: socket):
buffer = bytearray()
while True:
buffer.extend(conn.recv(4096))
header_length = buffer.find(b"\r\n\r\n")
if header_length != -1:
return buffer[:header_length], buffer[header_length+4:]
def read_http_request(conn: socket):
s, rest = read_http_request_header_string(conn)
s = s.decode("ascii")
lines = s.split("\r\n")
# 解析第一行
fstline = lines[0]
method, path, protocol = fstline.split(" ")
if protocol != "HTTP/1.1":
raise RuntimeError("unknown protocol", protocol)
method = method.lower()
# 解析头
header = {}
if len(lines) > 1:
for line in lines[1:]:
key, value = line.split(": ")
header[key] = value
return method, path, header, rest
def read_http_request_body(conn: socket, length: int, buffer: bytearray):
while len(buffer) < length:
buffer.extend(conn.recv(4096))
return buffer[:length]
````
我们在原先`read_http_request`函数的基础上增加`read_http_request_body`，并且让`read_http_request`返回多读的数据（在`\r\n\r\n`之后的数据）。在` handle_http_request`，我们这样读取主体：
````python
def handle_http_request(conn: socket):
global default_name
try:
method, path, headers, rest = read_http_request(conn)
if "Content-Length" in headers:
body = read_http_request_body(conn, int(headers["Content-Length"]), rest)
# 我们在这只支持Content-Length，
else:
body = bytearray()
except Exception as e:
conn.send(build_http_response_header(400, []))
print(f"- - 400 {STATUS_MESSAGES[400]}")
raise e
# ...
````
接下来我们要改动检查路径和方法的代码：
````python
onlypath, query = read_path(path)
if onlypath == "/":
if method == "get":
query_dict = parse_query(query)
# 渲染页面
content = DEFAULT_PAGE_HTML.format(
name=(query_dict["name"] if query_dict.get("name") else default_name)
# 这里引用全局变量default_name的值，
).encode("utf-8")
headers = [
("Charset", "UTF-8"),
("Content-Length",str(len(content))),
("Connection", "close"),
]
conn.send(build_http_response_header(200, headers))
conn.send(content)
print(f"{method.upper()} {path} 200 {STATUS_MESSAGES[200]}")
return # 响应完成，直接返回
elif method == "post": # 处理POST请求
form_data_s = body.decode("utf-8")
form_dict = parse_query(form_data_s)
if form_dict.get("default_name"):
default_name = form_dict["default_name"]
conn.send(build_http_response_header(303, [
("Connection", "close"),
("Location", "."),
])) # 让浏览器重新用GET请求并展示当前页面，
print(f"{method.upper()} {path} 303 {STATUS_MESSAGES[303]}")
return # 响应完成，直接返回
conn.send(build_http_response_header(404, [])) # 没有匹配的路径或者方法，
print(f"{method.upper()} {path} 404 {STATUS_MESSAGES[404]}")
````
最后，改动一下模板，这样我们就可以直接使用这个参数了：
````python
DEFAULT_PAGE_HTML = """<!doctype html>
< html >
< head >
< meta charset = "utf-8" / >
< title > Default Page< / title >
< / head >
< body >
< h1 > Hello {name}!< / h1 >
< form method = "GET" >
< input name = "name" / >
< button type = "submit" > Submit< / button >
< / form >
< h2 > Default Name< / h2 >
< form method = "POST" >
< input name = "default_name" / >
< button type = "submit" > Submit< / button >
< / form >
< / body >
< / html > """
````
[完整代码请见Gist ](https://gist.github.com/thislight/b69161000e5ea2904057a49f16b5ac8b )
### 再进一步
我们的代码尚不完善，你可以试试按以下方向改进。
2024-10-04 06:09:28 +00:00
- 处理并发连接
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
当前的代码只能依照顺序一个一个处理连接，
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
参考资料：
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- [Python文档： ](https://docs.python.org/zh-cn/3/library/threading.html#module-threading )
- [Python文档： ](https://docs.python.org/zh-cn/3/library/asyncio.html#module-asyncio )
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- 连接复用
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
当前代码在回应请求之后就直接关闭连接，
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
参考资料：
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- [MDN Web Docs： ](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Keep-Alive )
- [MDB Web Docs： ](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Connection )
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- 增强兼容性
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
我们目前的代码作了一些假设，你可以改进代码以提高对不同客户端的兼容性。
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- 支持[HTTP Transfer-Encoding](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Transfer-Encoding)，我们的代码中没有支持这种传输方式
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- 包装和抽象
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
你可以将HTTP服务器包装起来， ， ：
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
````python
from mymodule import MyServer
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
def handle_index(request):
return request.ok(template="index.html")
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
if __name__ == "__main__":
server = MyServer({
"/": handle_index
})
server.run()
````
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
你还可以试试阅读[Tornado的代码](https://github.com/tornadoweb/tornado)，
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- 支持Cookie
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
HTTP是一个无状态协议： ，
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
参考资料：
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- [MDN Web Docs： ](https://developer.mozilla.org/en-US/docs/Web/HTTP/Cookies )
2024-10-03 07:00:34 +00:00
## 参考资料和扩展阅读
- [MDN Web Docs: HTTP ](https://developer.mozilla.org/en-US/docs/Web/HTTP )
- [Python Docs: socket ](https://docs.python.org/zh-cn/3/library/socket.html )
- [Wikipedia: URL encoding ](https://en.wikipedia.org/wiki/URL_encoding )
- [Wikipedia: Telnet ](https://en.wikipedia.org/wiki/Telnet )
2024-10-04 06:09:28 +00:00
本文内容主要基于HTTP/1.1。如今， ，
2024-10-03 07:00:34 +00:00
2024-10-04 06:09:28 +00:00
- [Web.dev: Introduction to HTTP/2 ](https://web.dev/performance-http2/ )
- [Couldflare: What is HTTP/3? ](https://www.cloudflare.com/learning/performance/what-is-http3/ )
