Flak项目拆分

Flask项目拆分

为什么要 拆分

• 让代码更有层次更清晰
• 提升代码的扩展性
• 方便多人协作
• 拆分规则：MTV
• 高内聚，低耦合，将同一类事务的所有操作封装在一起，提高内聚。将具体操作进行分层，降低耦合

拆分后的项目

manage.py 负责管理整个项目

# 从系统环境变量中加载配置
env = os.environ.get("FLASK_ENV") or "default"

app = create_app(env)

manager = Manager(app)
manager.add_command("db", MigrateCommand)
if __name__ == '__main__':
    manager.run()

App文件夹存 放具体项目

__ init__

def create_app(env):
    # 创建Flask对象
    app = Flask(__name__)

    # 加载配置  初始化配置
    app.config.from_object(envs.get(env))

    # 初始化扩展库  加载扩展库
    init_ext(app)
  # 加载中间件
    load_middleware(app)
    # 初始化路由  加载路由
    init_blue(app)

    return app

extension.py 各种第三方扩展库,除路由

db = SQLAlchemy()
migrate = Migrate()
cache = Cache(config={
    "CACHE_TYPE": "redis",
    "CACHE_REDIS_URL": "redis://:rock1204@10.0.127.143:6379/1"
})


def init_ext(app):
    db.init_app(app)
    migrate.init_app(app, db)
    cache.init_app(app)

setting Flask配置

def get_db_uri(dbinfo):

    database = dbinfo.get("DATABASE")
    driver = dbinfo.get("DRIVER")
    user = dbinfo.get("USER")
    password = dbinfo.get("PASSWORD")
    host = dbinfo.get("HOST")
    port = dbinfo.get("PORT")
    name = dbinfo.get("NAME")

    return "{}+{}://{}:{}@{}:{}/{}".format(database, driver, user, password, host, port, name)


class Config:
    SECRET_KEY = "rock1204"

    DEBUG = False

    TESTING = False

    SQLALCHEMY_TRACK_MODIFICATIONS = False

#开发环境
class DevelopConfig(Config):
    DEBUG = True
    dbinfo = {
        "DATABASE": "mysql",
        "DRIVER": "pymysql",
        "USER": "root",
        "PASSWORD": "*****",
        "HOST": "localhost",
        "PORT": "3306",
        "NAME": "FlaskProject"
    }

    SQLALCHEMY_DATABASE_URI = get_db_uri(dbinfo)

#测试环境
class TestingConfig(Config):
    TESTING = True

    SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:rock1204@localhost:3306/FlaskProject"

#演示环境
class StagingConfig(Config):
    SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:rock1204@localhost:3306/FlaskProject"

#生产环境
class ProductConfig(Config):
    SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:rock1204@localhost:3308/FlaskProject"


envs = {
    "develop": DevelopConfig,
    "testing": TestingConfig,
    "staging": StagingConfig,
    "product": ProductConfig,
    "default": ProductConfig
}

views视图函数

#总路由
def init_blue(app):
    app.register_blueprint(blueprint=user_blue)
    app.register_blueprint(blueprint=movie_blue)

#分路由
user_blue = Blueprint("user_blue", __name__, url_prefix="/users")
@user_blue.route("/")
def index():
    return "Hello Index"
@user_blue.route("/create/")
def create():
    db.create_all()
    return "创建成功"
#分路由
@movie_blue.route("/learn/")
#  缓存配置   timeout 缓存过期时间
@cache.cached(timeout=60)
def learn():

    print("开始学习")
    sleep(10)
    print("终于学完了")

    return "睡着了，做梦了"

model模型

class Movie(db.Model):
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    m_name = db.Column(db.String(256))
    m_detail = db.Column(db.String(256))

middleware中间件（AOP）

• 拓展：面向过程（POP）、面向对象（OOP）、面向接口（IOP）、面向切面（AOP）

• 面向过程：典型的是C/C++的结构体，结构体里只有变量，没有处理变量的方法，需要专门编写处理变量的方法。

  面向对象：ArrayList list=new ArrayList();坏处是如果改为LinkedList，所有代码可能需要重写，同时扩展一个新的List的话，需要重新调用。

  面向接口：List=new Arraylist();是面向对象的一种形式，广义上讲，抽象类也是接口的一种形式，使用该类的某种属性（接口）来表示，降低耦合性，增加代码复用性。

  面向切面：这种在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

  def load_middleware(app):
  
      @app.before_request
      def app_before():
          print(request.remote_addr)
          print(request.url)
          print(request.path)
  
          if request.path == "/movies/":
              addr = request.remote_addr
              ip = addr.split(".")[-1]
              if int(ip) > 50:
                  if random.randrange(100) > 20:
                      return "恭喜您特等奖"
  
      @app.before_request
      def before():
          print("before")
  
      @app.after_request
      def after(resp):
          print(type(resp))
          print("xxx")
  
          return resp
  
      @app.errorhandler(500)
      def error500(exce):
  
          print(type(exce))
  
          return "跳转到首页"
  

migration迁移文件

• python manage.py db init
• python manage.py migrate
• python manage.py upgrade
• python manage.py downgrade

迁移命令自动生成

四大内置对象

• request 请求对象

• session 会话技术入口

• g 单次请求中的全局。服务器默认是多线程的，实现数据的跨函数传递

• config flask内置配置文件

  <ul>
      {% for con in config %}
          <li>{{ con }}</li>
      {% endfor %}
  
  </ul>
  

  • sqlalchemy_binds
    sqlalchemy_engine_options
    sqlalchemy_database_uri
    secret_key
    sqlalchemy_commit_on_teardown
    session_cookie_httponly
    preserve_context_on_exception
    session_refresh_each_request
    send_file_max_age_default
    sqlalchemy_pool_size
    sqlalchemy_native_unicode
    session_cookie_name
    json_as_ascii
    preferred_url_scheme
    session_cookie_path
    sqlalchemy_record_queries
    json_sort_keys
    application_root
    trap_http_exceptions
    testing
    session_cookie_domain
    env
    sqlalchemy_max_overflow
    templates_auto_reload
    jsonify_mimetype
    sqlalchemy_pool_timeout
    sqlalchemy_track_modifications
    trap_bad_request_errors
    permanent_session_lifetime
    debug
    use_x_sendfile
    jsonify_prettyprint_regular
    sqlalchemy_echo
    session_cookie_secure
    explain_template_loading
    session_cookie_samesite
    sqlalchemy_pool_recycle
    propagate_exceptions
    server_name
    max_content_length
    max_cookie_size

  debug
  use_x_sendfile
  jsonify_prettyprint_regular
  sqlalchemy_echo
  session_cookie_secure
  explain_template_loading
  session_cookie_samesite
  sqlalchemy_pool_recycle
  propagate_exceptions
  server_name
  max_content_length
  max_cookie_size