python-21-HTTP服务器

最新推荐文章于 2024-04-28 22:39:56 发布

老板来片烤面包

最新推荐文章于 2024-04-28 22:39:56 发布

阅读量568

点赞数

分类专栏： python全栈技术文章标签： python

本文链接：https://blog.csdn.net/gregcsdn/article/details/124020560

版权

python全栈技术专栏收录该内容

22 篇文章 4 订阅

订阅专栏

视频在线学习地址：https://www.bilibili.com/video/BV1Yp4y117BA
————————————————
——Python全套：BV1jZ4y1p7zQ

学习目标

能够说出什么是HTTP协议
能够手写代码搭建一个HTTP服务器
了解WSGI接口
能够看懂自定义WSGI服务器
能够使用requests插件发送请求

1. 使用谷歌/火狐浏览器分析

在Web应用中，服务器把网页传给浏览器，实际上就是把网页的HTML代码发送给浏览器，让浏览器显示出来。而浏览器和服务器之间的传输协议是HTTP，所以：

HTML是一种用来定义网页的文本，会HTML，就可以编写网页；
HTTP是在网络上传输HTML的协议，用于浏览器和服务器的通信。

Chrome浏览器提供了一套完整地调试工具，非常适合Web开发。

安装好Chrome浏览器后，打开Chrome，在菜单中选择“视图”，“开发者”，“开发者工具”，就可以显示开发者工具：

说明

Elements显示网页的结构
Network显示浏览器和服务器的通信

我们点Network，确保第一个小红灯亮着，Chrome就会记录所有浏览器和服务器之间的通信：

2. http协议的分析

当我们在地址栏输入www.sina.com时，浏览器将显示新浪的首页。在这个过程中，浏览器都干了哪些事情呢？通过Network的记录，我们就可以知道。在Network中，找到www.sina.com那条记录，点击，右侧将显示Request Headers，点击右侧的view source，我们就可以看到浏览器发给新浪服务器的请求：

2.1 浏览器请求

说明

最主要的头两行分析如下，第一行：
    GET / HTTP/1.1
Copy
GET表示一个读取请求，将从服务器获得网页数据，/表示URL的路径，URL总是以/开头，/就表示首页，最后的HTTP/1.1指示采用的HTTP协议版本是1.1。目前HTTP协议的版本就是1.1，但是大部分服务器也支持1.0版本，主要区别在于1.1版本允许多个HTTP请求复用一个TCP连接，以加快传输速度。

从第二行开始，每一行都类似于Xxx: abcdefg：
    Host: www.sina.com
Copy
表示请求的域名是www.sina.com。如果一台服务器有多个网站，服务器就需要通过Host来区分浏览器请求的是哪个网站。

2.2 服务器响应

继续往下找到Response Headers，点击view source，显示服务器返回的原始响应数据：

HTTP响应分为Header和Body两部分（Body是可选项），我们在Network中看到的Header最重要的几行如下：
    HTTP/1.1 200 OK
Copy
200表示一个成功的响应，后面的OK是说明。

如果返回的不是200，那么往往有其他的功能，例如

失败的响应有404 Not Found：网页不存在
500 Internal Server Error：服务器内部出错
...等等...
    Content-Type: text/html
Copy
Content-Type指示响应的内容，这里是text/html表示HTML网页。

请注意，浏览器就是依靠Content-Type来判断响应的内容是网页还是图片，是视频还是音乐。浏览器并不靠URL来判断响应的内容，所以，即使URL是http://www.baidu.com/meimei.jpg，它也不一定就是图片。

HTTP响应的Body就是HTML源码，我们在菜单栏选择“视图”，“开发者”，“查看网页源码”就可以在浏览器中直接查看HTML源码：

浏览器解析过程

当浏览器读取到新浪首页的HTML源码后，它会解析HTML，显示页面，然后，根据HTML里面的各种链接，再发送HTTP请求给新浪服务器，拿到相应的图片、视频、Flash、JavaScript脚本、CSS等各种资源，最终显示出一个完整的页面。所以我们在Network下面能看到很多额外的HTTP请求。

3. 总结

3.1 HTTP请求

跟踪了新浪的首页，我们来总结一下HTTP请求的流程：

3.1.1 步骤1：浏览器首先向服务器发送HTTP请求，请求包括：

方法：GET还是POST，GET仅请求资源，POST会附带用户数据；

路径：/full/url/path；

域名：由Host头指定：Host: www.sina.com

以及其他相关的Header；

如果是POST，那么请求还包括一个Body，包含用户数据

3.1.1 步骤2：服务器向浏览器返回HTTP响应，响应包括：

响应代码：200表示成功，3xx表示重定向，4xx表示客户端发送的请求有错误，5xx表示服务器端处理时发生了错误；

响应类型：由Content-Type指定；

以及其他相关的Header；

通常服务器的HTTP响应会携带内容，也就是有一个Body，包含响应的内容，网页的HTML源码就在Body中。

3.1.1 步骤3：如果浏览器还需要继续向服务器请求其他资源，比如图片，就再次发出HTTP请求，重复步骤1、2。

Web采用的HTTP协议采用了非常简单的请求-响应模式，从而大大简化了开发。当我们编写一个页面时，我们只需要在HTTP请求中把HTML发送出去，不需要考虑如何附带图片、视频等，浏览器如果需要请求图片和视频，它会发送另一个HTTP请求，因此，一个HTTP请求只处理一个资源(此时就可以理解为TCP协议中的短连接，每个链接只获取一个资源，如需要多个就需要建立多个链接)

HTTP协议同时具备极强的扩展性，虽然浏览器请求的是http://www.sina.com的首页，但是新浪在HTML中可以链入其他服务器的资源，比如<img src="http://i1.sinaimg.cn/home/2013/1008/U8455P30DT20131008135420.png">，从而将请求压力分散到各个服务器上，并且，一个站点可以链接到其他站点，无数个站点互相链接起来，就形成了World Wide Web，简称WWW。

3.2 HTTP格式

每个HTTP请求和响应都遵循相同的格式，一个HTTP包含Header和Body两部分，其中Body是可选的。

HTTP协议是一种文本协议，所以，它的格式也非常简单。

3.2.1 HTTP GET请求的格式：
    GET /path HTTP/1.1
    Header1: Value1
    Header2: Value2
    Header3: Value3
Copy
每个Header一行一个，换行符是\r\n。

3.2.2 HTTP POST请求的格式：
    POST /path HTTP/1.1
    Header1: Value1
    Header2: Value2
    Header3: Value3

    body data goes here...
Copy
当遇到连续两个\r\n时，Header部分结束，后面的数据全部是Body。

3.2.3 HTTP响应的格式：
    200 OK
    Header1: Value1
    Header2: Value2
    Header3: Value3

    body data goes here...
Copy
HTTP响应如果包含body，也是通过\r\n\r\n来分隔的。

请再次注意，Body的数据类型由Content-Type头来确定，如果是网页，Body就是文本，如果是图片，Body就是图片的二进制数据。

当存在Content-Encoding时，Body数据是被压缩的，最常见的压缩方式是gzip，所以，看到Content-Encoding: gzip时，需要将Body数据先解压缩，才能得到真正的数据。压缩的目的在于减少Body的大小，加快网络传输。

手动搭建HTTP服务器
import re
import socket
from multiprocessing import Process


class WSGIServer():
    def __init__(self, server, port, root):
        self.server = server
        self.port = port
        self.root = root
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((self.server, self.port))
        self.server_socket.listen(128)
    def handle_socket(self, socket):
        data = socket.recv(1024).decode('utf-8').splitlines()[0]
        file_name = re.match(r'[^/]+(/[^ ]*)', data)[1]
        # print(file_name)

        if file_name == '/':
            file_name = self.root + '/index.html'
        else:
            file_name = self.root + file_name

        try:
            file = open(file_name, 'rb')
        except IOError:
            response_header = 'HTTP/1.1 404 NOT FOUND \r\n'
            response_header += '\r\n'
            response_body = '========Sorry,file not found======='.encode('utf-8')
        else:
            response_header = 'HTTP/1.1 200 OK \r\n'
            response_header += '\r\n'
            response_body = file.read()

        finally:
            socket.send(response_header.encode('utf-8'))
            socket.send(response_body)

    def forever_run(self):
        while True:
            client_socket, client_addr = self.server_socket.accept()
            # self.handle_socket(client_socket)
            p = Process(target=self.handle_socket, args=(client_socket,))
            p.start()
            client_socket.close()
if __name__ == '__main__':
    ip = '0.0.0.0'
    port = 8899
    server = WSGIServer(ip, port, './pages')
    print('server is running at {}:{}'.format(ip, port))
    server.forever_run()
WSGI接口

WSGI接口定义非常简单，它只要求Web开发者实现一个函数，就可以响应HTTP请求。我们来看一个最简单的Web版本的“Hello, web!”：
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return '<h1>Hello, web!</h1>'
上面的application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：

environ：一个包含所有HTTP请求信息的dict对象；
start_response：一个发送HTTP响应的函数。

在application()函数中，调用：
start_response('200 OK', [('Content-Type', 'text/html')])
Copy
就发送了HTTP响应的Header，注意Header只能发送一次，也就是只能调用一次start_response()函数。start_response()函数接收两个参数，一个是HTTP响应码，一个是一组list表示的HTTP Header，每个Header用一个包含两个str的tuple表示。

通常情况下，都应该把Content-Type头发送给浏览器。其他很多常用的HTTP Header也应该发送。

然后，函数的返回值'<h1>Hello, web!</h1>'将作为HTTP响应的Body发送给浏览器。

有了WSGI，我们关心的就是如何从environ这个dict对象拿到HTTP请求信息，然后构造HTML，通过start_response()发送Header，最后返回Body。

整个application()函数本身没有涉及到任何解析HTTP的部分，也就是说，底层代码不需要我们自己编写，我们只负责在更高层次上考虑如何响应请求就可以了。

不过，等等，这个application()函数怎么调用？如果我们自己调用，两个参数environ和start_response我们没法提供，返回的str也没法发给浏览器。

所以application()函数必须由WSGI服务器来调用。有很多符合WSGI规范的服务器，我们可以挑选一个来用。但是现在，我们只想尽快测试一下我们编写的application()函数真的可以把HTML输出到浏览器，所以，要赶紧找一个最简单的WSGI服务器，把我们的Web应用程序跑起来。

好消息是Python内置了一个WSGI服务器，这个模块叫wsgiref，它是用纯Python编写的WSGI服务器的参考实现。所谓“参考实现”是指该实现完全符合WSGI标准，但是不考虑任何运行效率，仅供开发和测试使用。

新建WSGI服务器

创建hello.py文件，用来实现WSGI应用的处理函数。
def application(environ, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    print(environ)
    return ['<h1>Hello, web!</h1>'.encode('utf-8'),'hello'.encode('utf-8')]
创建server.py文件，用来启动WSGI服务器，加载appliction 函数
# 从wsgiref模块导入:
from wsgiref.simple_server import make_server
# 导入我们自己编写的application函数:
from hello import application

# 创建一个服务器，IP地址为空，端口是8000，处理函数是application:
httpd = make_server('', 8000, application)
print("Serving HTTP on port 8000...")
# 开始监听HTTP请求:
httpd.serve_forever()
使用if管理请求路径

文件结构:
├── server.py
├── utils.py
├── pages
        └── index.html
└── templates
    └── info.html

---------------------------------
Copy
utlis.py文件
----------------------------------

PAGE_ROOT = './pages'
TEMPLATE_ROOT = './templates'

def load_html(file_name, start_response, root=PAGE_ROOT):
    """
    加载HTML文件时调用的方法
    :param file_name: 需要加载的HTML文件
    :param start_response: 函数，用来设置响应头。如果找到文件，请求头设置为200,否则设置为410
    :param root: HTML文件所在的目录。默认PAGE_ROOT表示静态HTML文件，TEMPLATE_ROOT表示的是模板文件
    :return: 读取HTML文件成功的话，返回HTML文件内容；读取失败提示资源被删除
    """
    file_name = root + file_name
    try:
        file = open(file_name, 'rb')
    except IOError:
        start_response('410 GONE', [('Content-Type', "text/html;charset=utf-8")])
        return ['资源被删除了'.encode('utf-8')]
    else:
        start_response('200 OK', [('Content-Type', "text/html;charset=utf-8")])
        content = file.read()
        return [content]

def load_template(file_name, start_respone, **kwargs):
    """
    加载模板文件
    :param file_name: 需要加载的模板文件名
    :param start_respone: 函数，用来设置响应头。如果找到文件，请求头设置为200,否则设置为410
    :param kwargs: 用来设置模板里的变量
    :return: 读取HTML文件成功的话，返回HTML文件内容；读取失败提示资源被删除
    """
    content = load_html(file_name, start_respone, root=TEMPLATE_ROOT)
    html = content[0].decode('utf-8')
    if html.startswith('<!DOCTYPE html>'):
        return [html.format(**kwargs).encode('utf-8')]
    else:
        return content

-----------------------------
Copy
service.py文件

------------------------------



from wsgiref.simple_server import make_server
from utils import load_html, load_template

def show_home(start_response):
    return load_html('/index.html', start_response)

def show_test(start_response):
    start_response('200 OK', [('Content-Type', "text/html;charset=utf-8")])
    return ['我是一段普通的文字'.encode('utf-8')]

def show_info(start_response):
    return load_template('/info.html', start_response, name='张三',age=18})

def application(environ, start_response):
    path = environ.get('PATH_INFO')
    # 处理首页请求(加载一个HTML文件)
    if path == '/' or path == '/index.html':
        result = show_home(start_response)
        return result
    # 处理test.html请求(返回一个普通的字符串)
    elif path == '/test.html':
        return show_test(start_response)
    # 处理info.html请求(加载一个模板并且返回)
    elif path == '/info.html':
        return show_info(start_response)
    # 其它请求暂时无法处理，返回404
    else:
        start_response('400 NOT FOUND', [('Content-Type', "text/html;charset=utf-8")])
        return ['页面未找到'.encode('utf-8')]

httpd = make_server('', 8000, application)
print("Serving HTTP on port 8000...")
httpd.serve_forever()
使用字典管理请求路径

文件结构:
├── server.py
├── utils.py
├── urls.py
├── pages
        └── index.html
└── templates
    └── info.html

---------------------------------------------
Copy
urls.py文件：该文件里只有一个字典对象，用来保存请求路径和处理函数之间的对应关系。
---------------------------------------------

urls = {
    '/': 'show_home', 
    '/index.html': 'show_home', 
    '/test.html': 'show_test', 
    '/info.html': 'show_info'
}

--------------------------------------
Copy
server.py文件：
--------------------------------------

from wsgiref.simple_server import make_server
from urls import urls
from utils import load_html, load_template

def show_home(start_response):
    return load_html('/index.html', start_response)

def show_test(start_response):
    start_response('200 OK', [('Content-Type', "text/html;charset=utf-8")])
    return ['我是一段普通的文字'.encode('utf-8')]

def show_info(start_response):
    return load_template('/info.html', start_response, name='张三',age=18})

def application(environ, start_response):
    path = environ.get('PATH_INFO')
    # 这里不再是一大堆的if...elif语句了，而是从urls字典里获取到对应的函数
    func = urls.get(path)
    if func:
        return eval(func)(start_response)
    # 其它请求暂时无法处理，返回404
    else:
        start_response('400 NOT FOUND', [('Content-Type', "text/html;charset=utf-8")])
        return ['页面未找到'.encode('utf-8')]

httpd = make_server('', 8000, application)
print("Serving HTTP on port 8000...")
httpd.serve_forever()
使用装饰器管理请求路径
from wsgiref.simple_server import make_server
from utils import load_html, load_template

g_url_route = {}


def route(url):
    def handle_action(action):
        g_url_route[url] = action

        def do_action(start_response):
            return action(start_response)

        return do_action

    return handle_action


@route('/index.html')
@route('/')
def show_home(start_response):
    return load_html('/index.html', start_response)


@route('/test.html')
def show_test(start_response):
    start_response('200 OK', [('Content-Type', "text/html;charset=utf-8")])
    return ['我是一段普通的文字'.encode('utf-8')]


@route('/info.html')
def show_info(start_response):
    return load_template('/info.html', start_response, name='张三', age=18)


def application(environ, start_response):
    file_name = environ.get('PATH_INFO')
    try:
        return g_url_route[file_name](start_response)
    except Exception:
        start_response('404 NOT FOUND', [('Content-Type', 'text/html;charset=utf-8')])
        return ['对不起，界面未找到'.encode('utf-8')]


if __name__ == '__main__':
    httpd = make_server('', 8000, application)
    print("Serving HTTP on port 8000...")
    httpd.serve_forever()
requests模块

除了使用浏览器给服务器发送请求以外，我们还可以使用第三方模块requests用代码来给服务器发送器请求，并获取结果。
url = 'https://www.apiopen.top/satinApi'
params = {'type': 1, 'page': 2}
response = requests.get(url, params)
print(response)

# 方法二: 只能用于get请求
url = 'https://www.apiopen.top/satinApi?type=1&page=1'
response = requests.get(url)
# print(response)

# 2.获取请求结果
print(response.headers)

# 2)响应体(数据)
# a.获取二进制对应的原数据(数据本身是图片、压缩文件、视频等文件数据)
content = response.content
print(type(content))

# b.获取字符类型的数据
text = response.text
print(type(text))

# c.获取json数据(json转换成python对应的数据)
json = response.json()
print(type(json))
print(json)