01- FLASK与HTTP

秒速五厘米 2022-09-02 13:53 139阅读 0赞

### 目录 ###

*   *  一 ： HTTP请求
     *  二： Request对象
     *   *  2.1： 获取URL属性：
         *  2.2: 属性与方法：
     *  三： FLASK处理请求
     *   *  3.1：Flask中的路由：
         *  3.2： Flask监听HTTP请求
         *  3.3：路由转换器
         *  3.4： 请求钩子：
     *  四： 响应报文
     *  五： 常见状态码
     *  六： FLASK中的响应
     *   *  6.1： 元组响应：
         *  6.2： 重定向响应
         *  6.3： 错误响应：
     *  七： 响应格式：
     *   *  7.1：纯文本响应：
         *  7.2： HTML响应(默认)：
         *  7.3： XML响应：
         *  7.4： JSON响应：

## 一 ： HTTP请求 ##

*  HTTP请求报文构成：**请求头，空行，请求体**。
 *  请求头的构成：**请求行**，**各种首部字段**。
 *  请求行：**请求方法**，**URL**,**协议**。
 *  常见的6种请求方式: GET, POST, PUT, DELETE, HEAD（获取报文首部）, OPTIONS(跨域试探请求)

## 二： Request对象 ##

*  Request封装了发送过来的请求，本质： 请求的解析和响应的封装本质是werkzeug完成的，而Request,实际上是继承了werkzeug那些实现发送请求的那些类而已。

### 2.1： 获取URL属性： ###

*  1: 获取请求路径:
    
     *  获取完整请求路径： full\_path
     *  获取不带查询字符串参数的路径：path
 *  2: 获取URL:
    
     *  获取完整URL : url
     *  获取不带查询字符串的URL: base\_url
     *  不携带路径的URL: url\_root
 *  3：获取host
    
     *  host：只是获取host
     *  host\_url: 获取host的URL地址。

from flask import Flask, request
    app = Flask(__name__)
    # 案例: 发送： 127.0.0.1:5000/hello?name=liangshan
    @app.route('/hello', methods=['GET', 'POST'])
    def hello_world():
        # 1: 获取URL的请求路径: /hello
        print(request.path)
        # 2: 获取完整的请求路径(包括查询字符串参数) ： /hello?name=liangshan
        print(request.full_path)
        # 3: 获取请求的地址（域名）: 127.0.0.1:5000
        print(request.host)
        # 4: 获取带请求方式的域名: http://127.0.0.1:5000/
        print(request.host_url)
        # 5: 获取不携带查询字符串参数的url: http://127.0.0.1:5000/hello
        print(request.base_url)
        # 6: 获取完整的URL: http://127.0.0.1:5000/hello?name=renshanwen
        print(request.url)
        # 7: 获取url根路径（最基本的URL）: http://127.0.0.1:5000/
        print(request.url_root)
        return 'Hello World!'

### 2.2: 属性与方法： ###

*  1: 了解Werkzeug中的字典封装：
    
     *  python中存在一个原生的dict对象。
     *  werkzeug中的MultiDict**继承于python原生的dict类，并实现了一键多值**。
     *  werkzeug中的ImmutableMultiDict, **继承了MultiDict,并实现了，值不可以修改**。
 *  2： 常用的属性和方法：
    
     *  1： 获取查询字符串： args
     *  2: 获取cookies: cookies（请求头中的）
     *  3： 获取表单数据： form
     *  4： 获取请求体中的json数据： get\_json()
     *  5: 获取所有请求中的字符串数据包括json： get\_data() (一般不常用)

from flask import Flask, request
    
    app = Flask(__name__)
    
    # 案例: 发送： 127.0.0.1:5000/hello?name=liangshan
    @app.route('/hello', methods=['GET', 'POST'])
    def hello_world():
        # 1: 获取请求的查询字符串参数:
        request_args = request.args
        print(request_args.get('name'))
        print(request_args['name'])
        # 输出：liangshan
        print(type(request_args))
        # 输出：<class 'werkzeug.datastructures.ImmutableMultiDict'>
    
        # 2: 获取请求的cookie字典：
        print(request.cookies.get('Path'))
        # 输出/
        print(type(request.cookies))
        # 输出：<class 'werkzeug.datastructures.ImmutableMultiDict'>
    
        # 3:获取请求体中的数据
        print(request.data)
        # 答： 本质还是调用get_data方法，并将parse_from_data 设置为True
        # 3.1： cache= True表示：缓存解析后的数据
        # 3.2： as_text = False: 默认返回的是字节类型字符串，如果设置为True,则返回unicode编码的数据。
        # 3.3： parse_form_data=False
        print(request.get_data(cache=True, as_text=False, parse_form_data=False))
    
        # 4： 获取请求体中的表单数据
        print(request.form)
    
        # 5: 获取请求体中的表单和查询字符串参数
        print(request.values)
        print(type(request.values))
        # 输出为<class 'werkzeug.datastructures.CombinedMultiDict'>，本质也是多值字典。
    
        # 6:前端传递过来json, 将字典转化成json
        print(request.get_json())
        # 输出: {'name': 'liangshan'}
        print(request.get_data())
        # 输出：b'{\r\n    "name": "liangshan"\r\n}'

*  3: 获取请求数据的注意事项：
    
     *  对于上面的字典类型，我们尽量使用get方法获取数据。
     *  **get方法获取数据，第二个参数可以使用默认值**。
     *  如果使用下标获取，**如果不存在，则会返回400的响应错误**， 而不是key错误。
    
    案例：
    
        @app.route('/hello', methods=['GET', 'POST'])
        def hello_world():
            data = request.args
            try:
                print(data['age'])
            except Exception as e:
                print(e)
                # 输出的报错： 400 Bad Request: The browser (or proxy) sent a request that this server could not understand.
        
            return 'Hello World!'

## 三： FLASK处理请求 ##

### 3.1：Flask中的路由： ###

*  flask的路由分发过程:
    
     *  flask中存在一个路由表， app.url\_map中，当请求过来时，与这个路由表中的路由进行匹配，如果匹配成功则分发到对应的视图，如果匹配不成功则返回404的错误。
 *  命令行查询所有路由规则：
    
     *  flask routes
    
    案例：
    
        (flask_with_https) D:\python_project\flask_with_https>flask routes
        Endpoint     Methods    Rule
        -----------  ---------  -----------------------
        hello_world  GET, POST  /hello
        static       GET        /static/<path:filename>

### 3.2： Flask监听HTTP请求 ###

*  思考： 程序即使找到了路由，如何转发到指定的视图中，就需要app(程序对象)时时刻刻的监视着每一个视图。这样才能进行视图的转发工作。
 *  使用@app.route（）装饰器进行监听HTTP请求。
 *  视图默认的监听方法有三个： GET， HEAD， OPTIONS三个请求。
 *  如果存在路由，但是方法不允许，此时HTTP返回405的响应。

案例： 监听请求案例：

@app.route('/hello', methods=['GET', 'POST'])
    def hello_world():
    
        return 'Hello World!'

### 3.3：路由转换器 ###

*  作用：
    
     *  1：（**转换**）前端传递过来的都是字符串类型， 有些时候我们内部需要整型等其他类型，就需要转换器直接转换，省的内部再进行转换。
     *  2：（**校验**） 校验参数是否正确： 传递过来的参数，如果格式不正确，则直接返回404，免的在视图内部在进行校验。
 *  6种内置的转换器：
    
     *  1~3： string:， int, float: 转换类型、限制类型。
     *  4： any：任意转换器（限制any中的值）。
     *  5： uuid: 限制uuid的类型。
 *  案例：
    
     *  进行类型的转换：
        
            @app.route('/hello/<int:age>', methods=['GET', 'POST'])
            def hello_world(age):
                print(type(age))
                # 输出为： <class 'int'>
                return 'Hello World!'
     *  any转换器的使用：
        
            @app.route('/hello/<any(red,blue,white):color>', methods=['GET', 'POST'])
            def hello_world(color):
                print(color)
                # 输出为： red
            
                return 'Hello World!'
     *  uuid转换器进行参数限制：
        
            @app.route('/hello/<uuid:uuid>', methods=['GET', 'POST'])
            def hello_world(uuid):
                # 限制输入的参数必须是uuid格式类型
                print(uuid)
                return 'Hello World!'

### 3.4： 请求钩子： ###

*  @app.before\_first\_request， 第一次请求之前调用。
    
     *  特点： 没有返回值，因为如果存在返回值则之间返回给前端，不会进入我们视图。
     *  案例： 在项目第一次运行时，进行某些初始化操作。
        
            @app.before_first_request
            def inital():
                print("做一些初始化操作....")
 *  @app.before\_request, 每次请求之前调用。
    
     *  特点： 不需要返回值。
     *  案例： 在每次请求之前对该用户进行权限认证操作。
        
            @app.before_request
            def inital():
                print("做一些权限认证工作...")
 *  @app.after\_request, 每次请求之后调用。
    
     *  特点： 一定要返回响应，不然前端收不到响应信息。
     *  案例:在每次返回响应的时候对响应的格式统一处理。
        
            @app.after_request
            def inital(response):
                print("对响应做一些统一的处理工作。。。。")
                return response
 *  @app.teardown\_request, 每次请求结束之后调用。
    
     *  特点： 无需返回值。
     *  案例： 请求结束的时候对某种异常进行统一的处理。
        
            @app.teardown_request
            def inital(error):
                print("异常处理。。。。")
                print(error)

## 四： 响应报文 ##

*  1： 响应头
    
     *  状态行： 协议，状态码，原因短语
     *  首部字段：
 *  2： 空行
 *  3：响应体

## 五： 常见状态码 ##

*  1： 200（成功）， 201（创建成功）， 204（成功但没有返回值）
 *  2： 301（永久）， 302（临时）， 304（重定向到缓存）
 *  3： 400（请求路径错误）， 401,403(权限不足，401返回认证弹窗，403直接禁止)， 404(资源不存在，或者路径写错了)
 *  4： 500（服务器内部错误）

## 六： FLASK中的响应 ##

### 6.1： 元组响应： ###

*  不写状态码默认200

@app.route('/')
    def hello_world():
        # 响应格式： 响应体，状态码，首部字段
        # 302,必须设置Loaction要跳转的地址。
        return 'Hello World!', 302, {
        'Location': 'https://www.baidu.com'}

### 6.2： 重定向响应 ###

from flask import Flask, request, redirect
    
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        # 重定向
        return redirect('https://www.baidu.com')

### 6.3： 错误响应： ###

from flask import Flask, request, redirect, abort
    
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        # 主动抛出异常响应
        return abort(404)

## 七： 响应格式： ##

*  了解MIME类型： **FlASK中使用MIME来标识一个文件的类型**。
 *  HTML（text/html）, PNG图片（image/png）
 *  格式： 类型名/子类型名
 *  如何设置相应格式类型？
    
     *  使用make\_response（）生成响应对象。
     *  响应对象.mimetype = ‘mime类型’

### 7.1：纯文本响应： ###

from flask import Flask, request, redirect, make_response
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        response = make_response('哈哈')
        response.mimetype = 'text/plain'
        return response

### 7.2： HTML响应(默认)： ###

from flask import Flask, request, redirect, make_response
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        response = make_response('哈哈')
        return response

### 7.3： XML响应： ###

from flask import Flask, request, redirect, make_response
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        response = make_response('哈哈')
        response.mimetype = 'application/xml'
        return response

### 7.4： JSON响应： ###

from flask import Flask, request, redirect, make_response, json
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        data = {
        
            'name': "梁山",
            'age': 23
        }
        response = make_response(json.dumps(data))
        response.mimetype = 'application/json'
        return response

*  使用jsonify进行简化：

from flask import Flask, request, redirect, make_response, json, jsonify
    app = Flask(__name__)
    
    @app.route('/')
    def hello_world():
        data = {
        
            'name': "梁山",
            'age': 23
        }
        # 默认也是200
        return jsonify(data), 200