flask全栈开发7 Flask-Script,alembic,Flask-Migrate

7.Flask-Script,alembic,Flask-Migrate

第七章 Flask-Script

Flask-Script：

Flask-Script的作用是可以通过命令行的形式来操作Flask。例如通过命令跑一个开发版本的服务器、设置数据库，定时任务等。要使用Flask-Script，可以通过pip install flask-script安装最新版本。首先看一个最简单的例子：

# manage.py

from flask_script import Manager
from your_app import app

manager = Manager(app)

@manager.command
def hello():
    print 'hello'

if __name__ == '__main__':
    manager.run()

我们把脚本命令代码放在一个叫做manage.py文件中，然后在终端运行python manage.py hello命令，就可以看到输出hello了。

定义命令的三种方法：

1. 使用@command装饰器：这种方法之前已经介绍过。就不过多讲解了。

2. 使用类继承自Command类：

   from flask_script import Command,Manager
   from your_app import app
   
   manager = Manager(app)
   
   class Hello(Command):
       "prints hello world"
   
       def run(self):
           print "hello world"
   
   manager.add_command('hello',Hello())
   

   使用类的方式，有三点需要注意：

   • 必须继承自Command基类。
   • 必须实现run方法。
   • 必须通过add_command方法添加命令。

3. 使用option装饰器：如果想要在使用命令的时候还传递参数进去，那么使用@option装饰器更加的方便：

   @manager.option('-n','--name',dest='name')
   def hello(name):
       print 'hello ',name
   

   这样，调用hello命令：

   python manage.py -n xt
   

   或者

   python manage.py --name xt
   

   就可以输出：

   hello xt
   

添加参数到命令中：

• option装饰器：以上三种创建命令的方式都可以添加参数，

  @option
  

  装饰器，已经介绍过了。看以下示例介绍展示添加多个参数的方式：

  @manager.option('-n', '--name', dest='name', default='joe')
  @manager.option('-u', '--url', dest='url', default=None) 
  def hello(name, url): 
    if url is None: 
        print "hello", name 
    else: 
        print "hello", name, "from", url
  

• command装饰器：command装饰器也可以添加参数，但是不能那么的灵活，如下示例：

  @manager.command 
  def hello(name="Fred") 
    print "hello", name
  

• 类继承：类继承也可以添加参数，看以下示例：

    from flask_Flask import Comman,Manager,Option
  
    class Hello(Command):
        option_list = (
            Option('--name','-n',dest='name'),
        )
  
        def run(self,name):
            print "hello %s" % name
  

  如果要在指定参数的时候，动态的做一些事情，可以使用get_options方法，示例如下：

    class Hello(Command):
        def __init__(self,default_name='Joe'):
    self.default_name = default_name
  
        def get_options(self):
            return [
                Option('-n','--name',dest='name',default=self.default_name),
            ]
  
        def run(self,name):
            print 'hello',name
  

第八章 alembic教程：

alembic是sqlalchemy的作者开发的。用来做OMR模型与数据库的迁移与映射。alembic使用方式跟git有点了类似，表现在两个方面，第一个，alembic的所有命令都是以alembic开头；第二，alembic的迁移文件也是通过版本进行控制的。首先，通过pip install alembic进行安装。以下将解释alembic的用法：

1. 初始化alembic仓库：在终端中，cd到你的项目目录中，然后执行命令alembic init alembic，创建一个名叫alembic的仓库。

2. 创建模型类：创建一个models.py模块，然后在里面定义你的模型类，示例代码如下：

    from sqlalchemy import Column,Integer,String,create_engine,Text
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy.ext.declarative import declarative_base
   
    Base = declarative_base()
    class User(Base):
        __tablename__ = 'user'
   
        id = Column(Integer,primary_key=True)
        username = Column(String(20),nullable=False)
        password = Column(String(100),nullable=False)
   
    class Article(Base):
        __tablename__ = 'article'
   
        id = Column(Integer,primary_key=True)
        title = Column(String(100),nullable=False)
        content = Column(Text, nullable=False)
   

3. 修改配置文件：

   在alembic.ini中设置数据库的连接，sqlalchemy.url = driver://user:pass@localhost/dbname，比如以mysql数据库为例，则配置后的代码为：

     sqlalchemy.url = mysql+mysqldb://root:root@localhost/alembic_demo?charset=utf8
   

   为了使用模型类更新数据库，需要在env.py文件中设置target_metadata，默认为target_metadata=None。使用sys模块把当前项目的路径导入到path中：

     import os
     import sys
     sys.path.append(os.path.dirname(os.path.abspath(__file__)) + "/../")
     from models import Base
     ... #省略代码
     target_metadata = Base.metadata # 设置创建模型的元类
     ... #省略代码
   

4. 自动生成迁移文件：使用alembic revision --autogenerate -m "message"将当前模型中的状态生成迁移文件。

5. 更新数据库：使用alembic upgrade head将刚刚生成的迁移文件，真正映射到数据库中。同理，如果要降级，那么使用alembic downgrade head。

6. 修改代码后，重复4~5的步骤。

7. 命令和参数解释：

   • init：创建一个alembic仓库。
   • revision：创建一个新的版本文件。
   • --autogenerate：自动将当前模型的修改，生成迁移脚本。
   • -m：本次迁移做了哪些修改，用户可以指定这个参数，方便回顾。
   • upgrade：将指定版本的迁移文件映射到数据库中，会执行版本文件中的upgrade函数。如果有多个迁移脚本没有被映射到数据库中，那么会执行多个迁移脚本。
   • [head]：代表最新的迁移脚本的版本号。
   • downgrade：会执行指定版本的迁移文件中的downgrade函数。
   • heads：展示head指向的脚本文件版本号。
   • history：列出所有的迁移版本及其信息。
   • current：展示当前数据库中的版本号。

另外，在你第一次执行upgrade的时候，就会在数据库中创建一个名叫alembic_version表，这个表只会有一条数据，记录当前数据库映射的是哪个版本的迁移文件。

经典错误：

错误描述	原因	解决办法
FAILED: Target database is not up to date.	主要是heads和current不相同。current落后于heads的版本。	将current移动到head上。alembic upgrade head
FAILED: Can't locate revision identified by '77525ee61b5b'	数据库中存的版本号不在迁移脚本文件中	删除数据库的alembic_version表中的数据，重新执行alembic upgrade head

第九章 Flask-Migrate

在实际的开发环境中，经常会发生数据库修改的行为。一般我们修改数据库不会直接手动的去修改，而是去修改ORM对应的模型，然后再把模型映射到数据库中。这时候如果有一个工具能专门做这种事情，就显得非常有用了，而flask-migrate就是做这个事情的。flask-migrate是基于Alembic进行的一个封装，并集成到Flask中，而所有的迁移操作其实都是Alembic做的，他能跟踪模型的变化，并将变化映射到数据库中。

使用Flask-Migrate需要安装，命令如下：

pip install flask-migrate

要让Flask-Migrate能够管理app中的数据库，需要使用Migrate(app,db)来绑定app和数据库。假如现在有以下app文件：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from constants import DB_URI
from flask_migrate import Migrate

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)
# 绑定app和数据库
migrate = Migrate(app,db)

class User(db.Model):
    id = db.Column(db.Integer,primary_key=True)
    username = db.Column(db.String(20))

    addresses = db.relationship('Address',backref='user')

class Address(db.Model):
    id = db.Column(db.Integer,primary_key=True)
    email_address = db.Column(db.String(50))
    user_id = db.Column(db.Integer,db.ForeignKey('user.id'))

db.create_all()

@app.route('/')
def hello_world():
    return 'Hello World!'

if __name__ == '__main__':
    app.run()

之后，就可以在命令行中映射ORM了。要操作当前的flask app，首先需要将当前的app导入到环境变量中：

# windows
$env:FLASK_APP='your_app.py'

#linux/unix
export FLASK_APP='your_app.py'

将当前的app导入到环境变量中后，接下来就是需要初始化一个迁移文件夹：

    flask db init

然后再把当前的模型添加到迁移文件中：

    flask db migrate

最后再把迁移文件中对应的数据库操作，真正的映射到数据库中：

    flask db upgrade

以上是通过加载当前的app到环境变量的做法，这种做法有点麻烦，每次都要设置环境变量。还有一种方法，可以直接通过flask-script的方式进行调用。现在重构之前的项目，设置为以下的目录结构：
以下对各个文件的作用进行解释：

constants.py文件：

常量文件，用来存放数据库配置。

# constants.py
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'xt_flask_migrate'
USERNAME = 'root'
PASSWORD = 'root'
DB_URI = 'mysql+mysqldb://{}:{}@{}:{}/{}'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)

ext.py文件：

把db变量放到一个单独的文件，而不是放在主app文件。这样做的目的是为了在大型项目中如果db被多个模型文件引用的话，会造成from your_app import db这样的方式，但是往往也在your_app.py中也会引入模型文件定义的类，这就造成了循环引用。所以最好的办法是把它放在不依赖其他模块的独立文件中。

    # ext.py
    from flask_sqlalchemy import SQLAlchemy
    db = SQLAlchemy()

models.py文件：模型文件，用来存放所有的模型，并且注意，因为这里使用的是flask-script的方式进行模型和表的映射，因此不需要使用db.create_all()的方式创建数据库。

    # models.py
    from ext import db
    class User(db.Model): 
        id = db.Column(db.Integer,primary_key=True) 
        username = db.Column(db.String(50)) 
        addresses = db.relationship('Address',backref='user') 

        def __init__(self,username): 
            self.username = username

    class Address(db.Model): 
        id = db.Column(db.Integer,primary_key=True) 
        email_address = db.Column(db.String(50)) 
        user_id = db.Column(db.Integer,db.ForeignKey('user.id')) 

        def __init__(self,email_address): 
            self.email_address = email_address

manage.py文件：

这个文件用来存放映射数据库的命令，MigrateCommand是flask-migrate集成的一个命令，因此想要添加到脚本命令中，需要采用manager.add_command('db',MigrateCommand)的方式，以后运行python manage.py db xxx的命令，其实就是执行MigrateCommand。

    # manage.py
    from flask_migrate import Migrate,MigrateCommand
    from ext import db
    from flask_script import Manager
    from flask import Flask
    from constants import DB_URI
    import models
    app = Flask(__name__)
    app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
    db.init_app(app)
    migrate = Migrate(app,db)
    manager = Manager(app)
    manager.add_command('db',MigrateCommand)

    if __name__ == '__main__': 
        manager.run()

flaskmigrate.py文件：

这个是主app文件，运行文件。并且因为db被放到另外一个文件中，所以使用db.init_app(app)的方式来绑定数据库。

    # flaskmigrate.py
    from flask import Flask
    from ext import db

    app = Flask(__name__)
    db.init_app(app)

    @app.route('/')
    def hello_world():
        return 'Hello World!'

    if __name__ == '__main__':
        app.run()

之后运行命令来初始化迁移文件：

    python manage.py db init

然后运行命令来将模型的映射添加到文件中：

    python manage.py db migrate

最后添加将映射文件真正的映射到数据库中：

    python manage.py db upgrade