pip3 freeze -l > requirements.txt  #导出
pip3 install -r requirements.txt   #导入

 1 # 启动程序
 2 from app import create_app
 3 
 4 """
 5 development:    开发环境
 6 production:     生产环境
 7 testing:        测试环境
 8 default:        默认环境
 9 
10 """
11 # 通过传入当前的开发环境，创建应用实例，不同的开发环境配置有不同的config。这个参数也可以从环境变量中获取
12 app = create_app(‘development‘)
13 
14 if __name__ == ‘__main__‘:
15     # flask内部自带的web服务器，只可以在测试时使用
16     # 应用启动后，在9001端口监听所有地址的请求，同时根据配置文件中的DEBUG字段，设置flask是否开启debug
17     app.run(host=‘0.0.0.0‘, port=9001, debug=app.config[‘DEBUG‘])

from flask_sqlalchemy import SQLAlchemy
from flask import Flask
from config import config

# 创建数据库
db = SQLAlchemy()

def create_app(config_name):

    # 初始化
    app = Flask(__name__)

    # 导致指定的配置对象:创建app时，传入环境的名称
    app.config.from_object(config[config_name])

    # 初始化扩展（数据库）
    db.init_app(app)

    # 创建数据库表
    create_tables(app)

    # 注册所有蓝本
    regist_blueprints(app)

    return app

def regist_blueprints(app):

    # 导入蓝本对象
    # 方式一
    from app.api import api

    # 方式二：这样，就不用在app/api/__init__.py（创建蓝本时）里面的最下方单独引入各个视图模块了
    # from app.api.views import api
    # from app.api.errors import api

    # 注册api蓝本,url_prefix为所有路由默认加上的前缀
    app.register_blueprint(api, url_prefix=‘/api‘)

def create_tables(app):
    """
    根据模型，创建表格（可以有两种写法）
    1、模型必须在create_all方法之前导入，模型类声明后会注册到db.Model.metadata.tables属性中
    不导入模型模块，就不会执行模型中的代码，也就无法完成注册。
    2、但是，如果db是在模型模块中创建的，同时在此处 from app.models import db 引用db,则就实现了
    模型和数据库的绑定，不需要再单独导入模型模块了。
    """
    from app.models import Video
    db.create_all(app=app)

from flask import Blueprint

# 两个参数分别指定蓝本的名字、蓝本所在的包或模块
api = Blueprint(‘api‘, __name__)

"""
 导入路由模块、错误处理模块，将其和蓝本关联起来

 1、应用的路由保存在包里的 views.py 和 errors.py 模块中
 2、导入这两个模块就能把路由与蓝本关联起来
 3、注意，这些模块在 app/__init__.py 脚本的末尾导入，原因是：
    为了避免循环导入依赖，因为在 app/views.py 中还要导入api蓝本，所以除非循环引用出现在定义 api 之后，否则会致使导入出错。

"""
from app.api import views, error

 1 # 配置环境的基类
 2 class Config(object):
 3 
 4     # 每次请求结束后，自动提交数据库中的变动，该字段在flask-sqlalchemy 2.0之后已经被删除了（有bug）
 5     SQLALCHEMY_COMMIT_ON_TEARDOWN = True
 6 
 7     # 2.0之后新加字段，flask-sqlalchemy 将会追踪对象的修改并且发送信号。
 8     # 这需要额外的内存，如果不必要的可以禁用它。
 9     # 注意，如果不手动赋值，可能在服务器控制台出现警告
10     SQLALCHEMY_TRACK_MODIFICATIONS = False
11 
12     # 数据库操作时是否显示原始SQL语句，一般都是打开的，因为后台要日志
13     SQLALCHEMY_ECHO = True
14 
15 
16 # 开发环境的配置
17 class DevelopmentConfig(Config):
18     """
19     配置文件中的所有的账号密码等敏感信息，应该避免出现在代码中，可以采用从环境变量中引用的方式，比如：
20     username = os.environ.get(‘MYSQL_USER_NAME‘)
21     password = os.environ.get(‘MYSQL_USER_PASSWORD‘)
22 
23     本文为了便于理解，将用户信息直接写入了代码里
24 
25     """
26     DEBUG = True
27     # 数据库URI
28     SQLALCHEMY_DATABASE_URI = ‘mysql+pymysql://root:123456@172.17.180.2/cleven_development‘
29 
30     # 也可如下来写，比较清晰
31     # SQLALCHEMY_DATABASE_URI = "mysql+pymysql://{username}:{password}@{hostname}/{databasename}".format(username="xxxx", password="123456", hostname="172.17.180.2", databasename="cleven_development")
32 
33 
34 # 测试环境的配置
35 class TestingConfig(Config):
36 
37     TESTING = True
38     SQLALCHEMY_DATABASE_URI = ‘mysql+pymysql://root:123456@172.17.180.3:3306/cleven_test‘
39 
40 
41     """
42     测试环境也可以使用sqlite，默认指定为一个内存中的数据库，因为测试运行结束后无需保留任何数据
43     也可使用  ‘sqlite://‘ + os.path.join(basedir, ‘data.sqlite‘) ，指定完整默认数据库路径
44     """
45     # import os
46     # basedir = os.path.abspath(os.path.dirname(__file__))
47     # SQLALCHEMY_DATABASE_URI = os.environ.get(‘TEST_DATABASE_URL‘) or ‘sqlite://‘ 
48 
49 
50 # 生产环境的配置
51 class ProductionConfig(Config):
52 
53     SQLALCHEMY_DATABASE_URI = ‘mysql+pymysql://root:123456@172.17.180.4:3306/cleven_production‘
54 
55 
56 # 初始化app实例时对应的开发环境声明
57 config = {
58     ‘development‘: DevelopmentConfig,
59     ‘production‘: ProductionConfig,
60     ‘testing‘: TestingConfig,
61     ‘default‘: DevelopmentConfig
62 }

 1 from app import db
 2 from flask import abort
 3 
 4 class Video(db.Model):
 5     """
 6     视频 Model
 7     """
 8     __tablename__ = ‘videos‘
 9     # 主键
10     id = db.Column(db.Integer, primary_key=True)
11     # 视频id
12     vid = db.Column(db.String(50))
13     # 封面图片
14     coverUrl = db.Column(db.Text)
15     # 详情描述
16     desc = db.Column(db.Text)
17     # 概要
18     synopsis = db.Column(db.Text)
19     # 标题
20     title = db.Column(db.String(100))
21     # 发布时间
22     updateTime = db.Column(db.Integer)
23     # 主题
24     theme = db.Column(db.String(10))
25     # 是否已删除？（逻辑）
26     isDelete = db.Column(db.Boolean, default=False)
27 
28     def to_json(self):
29         """
30         完成Video数据模型到JSON格式化的序列化字典转换
31         """
32         json_blog = {
33             ‘id‘: self.vid,
34             ‘coverUrl‘: self.coverUrl,
35             ‘desc‘: self.desc,
36             ‘synopsis‘: self.synopsis,
37             ‘title‘: self.title,
38             ‘updateTime‘: self.updateTime
39         }
40         return json_video

 1 from flask import make_response, jsonify
 2 from app.api import api
 3 from app.models import getHomepageData
 4 
 5 @api.route(‘/v1.0/homePage/‘, methods=[‘GET‘, ‘POST‘])
 6 def homepage():
 7     """
 8      上面 /v1.0/homePage/ 定义的url最后带上"/"：
 9      1、如果接收到的请求url没有带"/"，则会自动补上，同时响应视图函数
10      2、如果/v1.0/homePage/这条路由的结尾没有带"/"，则接收到的请求里也不能以"/"结尾，否则无法响应
11     """
12     response = jsonify(code=200,
13                        msg="success",
14                        data=getHomepageData())
15 
16     return response
17     # 也可以使用 make_response 生成指定状态码的响应
18     # return make_response(response, 200)
19     

from app import db
from flask import abort

class Video(db.Model):
    """
    视频 Model
    """
    __tablename__ = ‘videos‘
    # 主键
    id = db.Column(db.Integer, primary_key=True)
    # 视频id
    vid = db.Column(db.String(50))
    # 封面图片
    coverUrl = db.Column(db.Text)
    # 详情描述
    desc = db.Column(db.Text)
    # 概要
    synopsis = db.Column(db.Text)
    # 标题
    title = db.Column(db.String(100))
    # 发布时间
    updateTime = db.Column(db.Integer)
    # 主题
    theme = db.Column(db.String(10))
    # 是否已删除？（逻辑）
    isDelete = db.Column(db.Boolean, default=False)

    def to_json(self):
        """
        完成Video数据模型到JSON格式化的序列化字典转换
        """
        json_blog = {
            ‘id‘: self.vid,
            ‘coverUrl‘: self.coverUrl,
            ‘desc‘: self.desc,
            ‘synopsis‘: self.synopsis,
            ‘title‘: self.title,
            ‘updateTime‘: self.updateTime
        }
        return json_blog


def getHomepageData():

    result = {}
    # 获取banner
    banners = Video.query.filter_by(theme=‘banner‘)
    result[‘banner‘] = [banner.to_json() for banner in banners]
    # 获取homepage
    first = Video.query.filter_by(theme=‘hot‘).all()
    second = Video.query.filter_by(theme=‘dramatic‘).all()
    third = Video.query.filter_by(theme=‘idol‘).all()
    if len(first) and len(second) and len(third):
        homepage = [{‘Hot Broadcast‘: [item.to_json() for item in first]},
                    {‘Dramatic Theater‘: [item.to_json() for item in second]},
                    {‘Idol Theatre‘: [item.to_json() for item in third]}]
        result[‘homepage‘] = homepage
        return result
    else:
        abort(404)

from flask import jsonify
from . import api

# 使用errorhandler装饰器，只有蓝本才能触发处理程序
# 要想触发全局的错误处理程序，要用app_errorhandler

@api.app_errorhandler(404)
def page_not_found(e):
    """这个handler可以catch住所有abort(404)以及找不到对应router的处理请求"""
    return jsonify({‘error‘: ‘没有找到您想要的资源‘, ‘code‘: ‘404‘, ‘data‘: ‘‘})


@api.app_errorhandler(500)
def internal_server_error(e):
    """这个handler可以catch住所有的abort(500)和raise exeception."""
    return jsonify({‘error‘: ‘服务器内部错误‘, ‘code‘: ‘500‘, ‘data‘: ‘‘})