手把手教你使用Flask框架构建Python接口以及如何请求该接口
作者:mmseoamin日期:2023-12-11

目录

  • 前言
  • 0、Flask框架的详细介绍
  • 一、Flask 框架封装接口
    • 1-1、分步解析在python中调用Flask框架
    • 1-2、示例代码分析
    • 1-3、示例代码改进
    • 1-4、其他注意问题
    • 1-5、app.run()详细介绍
    • 二、请求该接口
      • 2-1、接口请求
      • 2-2、接口请求改进
      • 三、请求接口代码转换为java
      • 四、拓展Flask高级用法
        • 4-1、使用蓝图(Blueprints)
        • 4-2、使用模板
        • 4-3、使用数据库
        • 总结

          前言

          Flask是一个轻量级的Web应用框架,基于Python编写,其核心思想是保持简洁,灵活性和易于扩展。

          0、Flask框架的详细介绍

          Flask是一个轻量级的Web应用框架,基于Python编写,其核心思想是保持简洁,灵活性和易于扩展。Flask提供了基本的Web开发工具和应用程序的结构,但同时也允许开发者自由选择其他库和工具来扩展其功能。Flask的设计目标是使开发者能够快速构建具有基本功能的Web应用程序。在日常生活中我们需要将模型打包为api接口,这里需要借助一些web框架,最常用的就是flask框架。

          下面是一些Flask框架的主要特点:

          • 轻量级:Flask是一个轻量级的框架,其代码库非常小,并且不需要依赖大量的外部库和工具,因此可以轻松地安装和部署。
          • 灵活性:Flask允许开发者自由选择其他库和工具来扩展其功能,这使得开发者可以根据自己的需求进行灵活的配置。
          • 易于扩展:Flask提供了简单易用的扩展接口,开发者可以使用这些接口来添加新功能或定制框架的行为。
          • Web服务器支持:Flask支持多种Web服务器,如内置的开发服务器、Gunicorn和uWSGI等。
          • RESTful支持:Flask提供了内置的RESTful路由,使得开发RESTful API变得非常容易。
          • Jinja2模板引擎:Flask集成了Jinja2模板引擎,开发者可以使用模板来构建灵活的Web应用程序。
          • Flask-WTF表单:Flask提供了Flask-WTF扩展,使得表单处理变得简单而直观。
          • 内置的调试器:Flask提供了内置的调试器,使得开发者可以轻松地调试和排除错误。
          • 序列化与反序列化:Flask提供了内置的序列化和反序列化功能,使得开发RESTful API变得更加容易。

            总的来说,Flask是一个非常适合快速构建小型Web应用程序的框架。它提供了基本的Web开发工具和应用程序的结构,同时也支持灵活的扩展和定制。如果您需要快速构建一个小型的Web应用程序,Flask是一个非常好的选择。

            一、Flask 框架封装接口

            1-1、分步解析在python中调用Flask框架

            • 安装Flask:在命令行终端中输入以下命令:
              pip install Flask
              
              • 创建一个Flask应用程序:在Python脚本中导入Flask模块,然后创建一个Flask应用程序实例。例如:
                from flask import Flask
                app = Flask(__name__)
                # 在这个例子中,__name__ 参数传递给Flask构造函数,以便Flask知道应用程序的名称。
                
                • 定义路由:在Flask应用程序中,路由用于指定URL与执行相应代码的函数之间的映射。可以使用@app.route() 装饰器来定义路由。例如:
                  @app.route('/')
                  def hello_world():
                      return 'Hello, World!'
                  # 在这个例子中,@app.route('/') 指定了根URL路径(即'/'),而hello_world()函数是在URL被访问时执行的函数。
                  
                  • 运行应用程序:最后一步是在应用程序中运行app.run() 方法。例如:
                    if __name__ == '__main__':
                        app.run()
                    # 在这个例子中,__name__ 参数是特殊的Python变量,当脚本被执行时,它的值为'__main__',这个条件语句保证应用程序只在被作为主程序运行时才会执行。
                    
                    • 完整代码如下:
                      from flask import Flask
                      app = Flask(__name__)
                      @app.route('/')
                      def hello_world():
                          return 'Hello, World!'
                      if __name__ == '__main__':
                          app.run()
                      

                      1-2、示例代码分析

                      以下是一个使用 Flask 框架封装接口的示例代码:

                      from flask import Flask, request, jsonify
                      app = Flask(__name__)
                      # methods: 指定请求方式
                      @app.route('/process', methods=['POST'])
                      def process_data():
                      	# 请求方式为post时,可以使用 request.get_json()接收到JSON数据
                          data = request.get_json()  # 获取 POST 请求中的 JSON 数据
                          # 处理数据
                          # 调用do_something_with_data函数来处理接收到的数据。
                          processed_data = do_something_with_data(data)
                          # 请求方得到处理后的数据
                          return jsonify(processed_data)
                      if __name__ == '__main__':
                          app.run()
                      

                      在这个示例中,我们定义了一个 /process 的路由,并且指定了它只接受 POST 请求。当接收到请求时,我们首先从请求中获取 JSON 数据,然后使用 do_something_with_data 函数处理数据,最后将处理后的结果作为 JSON 数据返回给调用者。

                      注意,这个示例中的 do_something_with_data 函数并没有实现,你需要根据你的具体需求自己实现它。此外,你也可以根据你的需求修改路由和请求方法,例如改为 GET 请求或者定义不同的路由。

                      1-3、示例代码改进

                      # 添加异常检测代码
                      from flask import Flask, request, jsonify
                      app = Flask(__name__)
                      # methods: 指定请求方式
                      @app.route('/process', methods=['POST'])
                      def process_data():
                      	# 请求方式为post时,可以使用 request.get_json()接收到JSON数据
                          try:
                              data = request.get_json()
                              # 如果得到的data是字符串格式,则需要用json.loads来变换成python格式,看个人需求
                              # data = json.loads(data)
                              print(data)# 获取 POST 请求中的 JSON 数据
                          except Exception as e:
                              return jsonify({'error': '请求数据失败'}), 400
                          # 处理数据
                          # 调用do_something_with_data函数来处理接收到的数据。
                          # 判断是否接收到数据
                      	if data:
                              try:
                                  processed_data= do_something_with_data(data)
                              except Exception as e:
                                  return jsonify({'error': '处理数据失败'}), 666
                          # 返回的数据格式看请求方的要求了,也有可能需要json处理后的数据,即jsonify(processed_data)
                          return str(processed_data)
                      if __name__ == '__main__':
                          app.run()
                      

                      1-4、其他注意问题

                      转义问题:在字符串中,反斜杠(\)通常用于转义字符,如\n表示换行符。而在LaTeX中,\也被用于表示一些特殊的符号。因此,在Python中,如果要在字符串中表示LaTeX代码中的特殊符号,需要在其前面加上一个反斜杠。

                      • 解决办法:

                        即原本的:

                        ‘c = 2 \cdot a + \frac{ b }{ 3 }’

                        变为:

                        ‘c = 2 \cdot a + \frac{ b }{ 3 }’

                      • 解决办法2:

                        我们在字符串前面加上一个r,表示这是一个“原始字符串”,其中的反斜杠不会被解释为转义符号。

                        即原本的:

                        ‘c = 2 \cdot a + \frac{ b }{ 3 }’

                        变为:

                        r’c = 2 \cdot a + \frac{ b }{ 3 }’

                      • 注意:

                        输出的结果中有多出来的\,是因为它们是表示LaTeX语法的一部分,而不是Python中的转义符号。

                        1-5、app.run()详细介绍

                        app.run() 是 Flask 框架中启动服务器的方法。该方法会启动一个开发用的服务器,它会监听指定的主机和端口,接收来自客户端的请求,并将请求交给应用程序处理。

                        该方法有如下几个参数:

                        host: 服务器监听的主机名或 IP 地址,默认为 127.0.0.1,即本地回环地址。
                        port: 服务器监听的端口号,默认为 5000。
                        debug: 是否启用调试模式,默认为 False。调试模式下,Flask 会自动重载代码、打印详细的错误信息等,方便开发和调试。
                        threaded: 是否开启多线程模式,开启后可以提高服务器的并发处理能力,默认为 True。
                        options: 其它选项,如 SSL/TLS 配置等。
                        processes: 指定启动的进程数,用于多进程模式,默认为 1。
                        ssl_context: 用于配置 SSL/TLS 加密连接的上下文,用于启用 HTTPS,默认为 None。
                        

                        案例分析:

                        from flask import Flask
                        app = Flask(__name__)
                        @app.route('/')
                        def hello_world():
                            return 'Hello, World!'
                        if __name__ == '__main__':
                            app.run(host='0.0.0.0', port=8080, debug=True)
                        

                        该示例代码中,我们定义了一个简单的 Flask 应用程序,当客户端访问根路由时,会返回一个字符串消息。在启动应用程序时,我们将主机地址指定为 0.0.0.0,表示可以通过任何网络接口进行访问,将端口号指定为 8080,开启了调试模式。这样,我们就可以通过浏览器或其他 HTTP 客户端访问我们的应用程序了。

                        注意:

                        将 Flask 应用程序的 debug 参数设置为 True 是为了在开发阶段方便调试。但是在生产环境中,应该将其设置为 False,因为开启调试模式可能会带来一些安全风险和性能问题,例如:

                        • 安全风险:开启调试模式会在错误页面中显示详细的错误信息,包括源代码和堆栈跟踪,如果攻击者利用这些信息,可能会对应用程序造成安全威胁。
                        • 性能问题:开启调试模式会影响应用程序的性能,因为它会启用额外的调试代码和功能,例如自动重新加载和调试工具栏,这些功能会消耗计算资源。

                          因此,当你将 Flask 应用程序部署到生产环境时,应该将 debug 参数设置为 False,以确保应用程序的安全性和性能。

                          二、请求该接口

                          2-1、接口请求

                          可以使用类似 requests 的 Python 库来编写发送请求的代码。以下是一个使用 requests 库发送 POST 请求的示例:

                          import requests
                          import json
                          # 要传入的数据
                          data = {'param1': 'value1', 'param2': 'value2'}
                          # 要监听的地址
                          url = 'http://localhost:5000/process'  # 假设 Flask 应用监听在本地的 5000 端口上
                          response = requests.post(url, json=data)
                          if response.status_code == 200:
                              processed_data = json.loads(response.content)
                              print(processed_data)
                          else:
                              print('请求失败:', response.status_code)
                          

                          在这个示例中,我们定义了一个 data 字典,它包含了我们要传递给接口的参数。然后,我们使用 requests.post 函数向接口发送 POST 请求,并将参数以 JSON 格式传递给接口。

                          如果接口成功处理了请求并返回了正确的数据,我们可以使用 json.loads 函数将接口返回的 JSON 数据解析为 Python 对象,并进行进一步的处理。否则,我们可以查看响应的状态码来了解请求是否成功。

                          2-2、接口请求改进

                          接口请求改进: 为了增加代码的健壮性,我们需要添加异常检测代码

                          import requests
                          import json
                          # 要传入的数据
                          data = {'param1': 'value1', 'param2': 'value2'}
                          # 要监听的地址
                          url = 'http://localhost:5000/process'  # 假设 Flask 应用监听在本地的 5000 端口上
                          try:
                          	# 需要注意的是:JSON 格式不支持包含 Python 对象的字符串,需要json.dumps方法将其编码为 JSON 格式的字符串
                          	# response = requests.post(url, json=json.dumps(data))
                              response = requests.post(url, json=data)
                              response.raise_for_status()
                          except requests.exceptions.RequestException as e:
                              print('请求出错:', e)
                          if response.status_code == 200:
                              processed_data = json.loads(response.content)
                              print(processed_data)
                          else:
                              print('请求失败:', response.status_code)
                          

                          三、请求接口代码转换为java

                          后端开发工程师需要调用我们的接口?请求接口代码转换为java格式

                          import java.net.HttpURLConnection;
                          import java.net.URL;
                          import java.io.OutputStream;
                          import java.io.BufferedReader;
                          import java.io.InputStreamReader;
                          import com.google.gson.Gson;
                          import com.google.gson.JsonObject;
                          public class SendPOSTRequest {
                              public static void main(String[] args) {
                                  String url = "http://localhost:5000/process"; // 假设 Flask 应用监听在本地的 5000 端口上
                                  // 构造请求参数
                                  JsonObject data = new JsonObject();
                                  data.addProperty("param1", "value1");
                                  data.addProperty("param2", "value2");
                                  try {
                                      // 发送 POST 请求
                                      URL obj = new URL(url);
                                      HttpURLConnection con = (HttpURLConnection) obj.openConnection();
                                      con.setRequestMethod("POST");
                                      con.setRequestProperty("Content-Type", "application/json");
                                      // 将参数写入请求体
                                      con.setDoOutput(true);
                                      OutputStream os = con.getOutputStream();
                                      os.write(new Gson().toJson(data).getBytes("utf-8"));
                                      os.flush();
                                      os.close();
                                      // 处理响应结果
                                      BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
                                      String inputLine;
                                      StringBuffer response = new StringBuffer();
                                      while ((inputLine = in.readLine()) != null) {
                                          response.append(inputLine);
                                      }
                                      in.close();
                                      // 解析 JSON 数据
                                      JsonObject processedData = new Gson().fromJson(response.toString(), JsonObject.class);
                                      System.out.println(processedData);
                                  } catch (Exception e) {
                                      System.out.println("请求失败:" + e.getMessage());
                                  }
                              }
                          }
                          

                          在这个示例中,我们使用 Java 的标准库 java.net 发送 POST 请求,并将参数以 JSON 格式传递给接口。我们使用 Google 的 Gson 库来解析接口返回的 JSON 数据。

                          注意,这个示例中的代码并不包含异常处理,你需要根据实际情况添加适当的异常处理代码。此外,你也可以根据你的需求修改请求方法、请求头和请求体的格式。

                          四、拓展Flask高级用法

                          4-1、使用蓝图(Blueprints)

                          当应用程序的规模增大时,为了方便管理,可以使用蓝图将应用程序分解成更小的模块。每个蓝图代表一个功能模块,包含自己的路由、模板、静态文件等。例如:

                          from flask import Blueprint
                          auth_bp = Blueprint('auth', __name__)
                          @auth_bp.route('/login')
                          def login():
                              return 'Login page'
                          @auth_bp.route('/logout')
                          def logout():
                              return 'Logout page'
                          

                          在这个例子中,auth_bp 是一个蓝图,包含两个路由:/login 和 /logout。

                          将蓝图注册到应用程序中:

                          app.register_blueprint(auth_bp, url_prefix='/auth')
                          

                          在这个例子中,url_prefix=‘/auth’ 指定了蓝图中所有路由的URL前缀。

                          4-2、使用模板

                          Flask提供了内置的模板引擎Jinja2,用于将数据渲染到HTML页面中。例如:

                          from flask import render_template
                          @app.route('/user/')
                          def show_user_profile(username):
                              user = {'username': username, 'age': 18}
                              return render_template('user.html', user=user)
                          

                          在这个例子中,render_template() 函数将数据 user 渲染到名为 user.html 的模板中,然后返回渲染后的HTML页面。

                          在模板中,可以使用Jinja2语法来获取数据、控制流程、引入子模板等。例如:

                          Hello, {{ user.username }}!

                          {% if user.age >= 18 %}

                          You are an adult.

                          {% else %}

                          You are a minor.

                          {% endif %}

                          4-3、使用数据库

                          Flask没有内置的数据库支持,但可以轻松地集成第三方数据库库(如SQLAlchemy)来访问数据库。例如:

                          from flask_sqlalchemy import SQLAlchemy
                          app = Flask(__name__)
                          app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///myapp.db'
                          db = SQLAlchemy(app)
                          class User(db.Model):
                              id = db.Column(db.Integer, primary_key=True)
                              username = db.Column(db.String(80), unique=True, nullable=False)
                              email = db.Column(db.String(120), unique=True, nullable=False)
                              def __repr__(self):
                                  return '' % self.username
                          

                          在这个例子中,SQLAlchemy 是一个第三方数据库库,使用SQLite数据库来存储数据。User 类是一个模型类,用于定义数据库中的表结构。

                          在使用模型之前,需要执行一次数据库初始化操作:

                          with app.app_context():
                              db.create_all()
                          

                          然后就可以使用模型类来访问数据库了。例如:

                          user = User(username='john', email='john@example.com')
                          

                          总结

                          😊 小论文总算有了一些进展。