La structure des dossiers de Flask est résumée

Une personne qui développe des systèmes Web en utilisant Django tout le temps. J'ai récemment commencé à étudier Flask parce que je veux créer une application simple pendant mon temps libre. Il n'est pas bon de regrouper trop de paramètres dans un seul fichier, j'ai donc résumé la structure des répertoires basée sur MVC.

flask_app
├ common
│ ├ libs
│ └ models  ---modèle
│ 　 ├ user.py
│ └ ・ ・ ・
├ config　---Dossier de paramètres
│ ├ base_setting.py　---Paramètres communs pour chaque environnement
│ ├ local_setting.py　---Paramètres de l'environnement de développement local
│ └ production_setting.py ---Paramètres de l'environnement de production
├ controllers ---manette
│ ├ index.py
│ └ ・ ・ ・
├ interceptors 
│ ├ auth.py ---Traitement du système d'authentification
│ └ error_handler.py　---La gestion des erreurs
├ static　---Emplacement du fichier statique
├ templates　---modèle
│ ├ common
│ │ └ layout.html
│ └ index.html
├ application.py　---Définissez ce qui est utilisé par plusieurs fichiers (instance Flask, DB, variables d'environnement, etc.)
├ manager.py ---Script d'exécution d'application (entrée d'application)
├ requirements.py ---Liste de la bibliothèque
└ www.py ---routage

Flux d'exécution

• Dans application.py, chargez l'initialisation et les paramètres de l'application et de la base de données (Comme Django, je veux démarrer l'application avec une commande (`` python manager.py runserver ''), donc j'utilise le gestionnaire de flask_script)
• Lisez et acheminez l'application qui a mordu le Manager sur www.py
• Lire la base de données avec les modèles et définir le modèle
• Exécutez l'application routée dans manager.py

Description du rôle du fichier

Je vais expliquer dans l'ordre.

app.config.from_pyfile("config/base_setting.py")Lisez d'abord les paramètres communs avec. Les paramètres qui changent en fonction de l'environnement (développement / production) sont les variables d'environnement prédéfinies ops._Changé pour lire un fichier de paramètres différent en fonction de la valeur différente de config.

#### **`flask_app/application.py`**
```flask

from flask import Flask
from flask_script import Manager
from flask_sqlalchemy import SQLAlchemy
import os
app = Flask(__name__)

manager = Manager(app)
app.config.from_pyfile("config/base_setting.py")

# linux export ops_config=local|production
# windows set ops_config=local|production
if "ops_config" in os.environ:
    app.config.from_pyfile("config/%s_setting.py" % (os.environ['ops_config']))

db = SQLAlchemy(app)

Le contenu des contrôleurs est divisé en unités fonctionnelles et intégré à l'aide d'un plan sur www.py.

flask_app/www.py

from interceptors.errorHandler import *
from interceptors.Auth import *
from application import app
from controllers.index import index_page

from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)


app.register_blueprint(index_page, url_prefix="/")

Définissez le modèle dans les modèles. Ici, un modèle de test est défini dans user.py.

flask_app/common/models/user.py

from application import db


class User(db.Model):
    __tablename__ = 'user'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(20), nullable=False)

Définissez le traitement réel dans les contrôleurs.

flask_app/controllers/index.py

from flask import Blueprint, render_template
from common.models.user import User

index_page = Blueprint("index_page", __name__)


@index_page.route("/")
def index():
    name = "hello"
    context = {"name": name}
    context["user"] = {"nickname": "xxxx",
                       "id": "xxxxx", "home_page": "http://www.xxx"}
    context["num_list"] = [1, 2, 3, 4, 5]

    result = User.query.all()
    context['result'] = result

    return render_template("index.html", **context)

Enregistrez les commandes runserver et create_all avec la méthode add_commend de Manager.

flask_app/manager.py

 from application import app, db, manager
from flask_script import Server, Command
from www import *

# web server
manager.add_command("runserver", Server(host = "0.0.0.0", use_debugger=True, use_reloader=True))

# create tables
@Command
def create_all():
    from common.models.user import User  
    db.create_all()

manager.add_command("create_all", create_all)

def main():
    manager.run()
    
if __name__ == "__main__":
    # app.run( host = "0.0.0.0" )
    
    try:
        import sys
        sys.exit( main() )
    except Exception as e:
        import traceback
        traceback.print_exc()

Courir

• `pip install -r requirements.py `pour installer les modules requis.
• flask_app / local_setting.py` pour définir l'utilisateur, le mot de passe, l'hôte et le port de db en fonction de votre environnement.
• Créez une base de données avec le nom flask dans votre environnement.
• Cliquez sur `` python manager.py create_all '' sous le dossier du projet (flask_app). Un maître avec le nom d'utilisateur est généré.
• Appuyez sur python manager.py runserver` '' et

http://localhost:Accédez à 5000 et réussissez lorsque l'écran suivant apparaît!

 ![flask_app_image.JPG](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/545184/b64db0c9-64cf-0b1b-e7a8-9935f14b5008.jpeg)


## La source
 J'ai téléchargé la source sur gitHub, donc si vous avez le temps, veuillez [Télécharger](https://github.com/shixujapan/flask_app) et jouer avec.
## Que faire ensuite

 * Créez une application CRUD simple à l'aide de Flask
 * Envisagez une coopération avec Vue.js