Detailed example of organizational structure adjustment (python)

The birth of a web application based on flask is the seventh article. This article mainly introduces the adjustment of the organizational structure and has a certain reference value. Interested friends can refer to

All Py now The codes are all written in the default.py file. Obviously, under this method, once the program becomes responsible, it will cause many problems for both development and maintenance.

The Flask framework does not force projects to use a specific organizational structure, so the organizational structure used here is not necessarily the same as in other projects.

According to the code in default.py, it can be roughly divided into three categories: form model, data model, and view method, so models are also distinguished by this category. Therefore, according to the experience gained from other languages ​​​​(java), each class is a py file and placed in the corresponding folder

In a single file, all configurations They are all written in a single file. After performing multi-file reconstruction, it is obviously inappropriate to do this, so it is necessary to create an independent config file:

class Config:
 SECRET_KEY="Niu_blog String"
 SQLALCHEMY_DATABASE_URI='mysql://root:1234@localhost/cblog'
 SQLALCHEMY_COMMIT_ON_TEARDOWN=True
 LOGIN_PROTECTION="strong"
 LOGIN_VIEW="login"

Then the initialization file ( app/__init__.py):

from flask import Flask
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
import pymysql
pymysql.install_as_MySQLdb()
from config import Config

bootstrap = Bootstrap()
db = SQLAlchemy()
login_manager=LoginManager();

def create_app():
 app = Flask(__name__)
 app.config.from_object(Config)
 bootstrap.init_app(app)
 login_manager.init_app(app)
 login_manager.session_protection=Config.LOGIN_PROTECTION
 login_manager.login_view=Config.LOGIN_VIEW
 db.init_app(app)
 return app

Further modularization requires the use of blueprints. The functions of blueprints are somewhat similar to areas in asp.net mvc, integrating the view methods of different modules and distinguishing them through URLs. , first the entrance, that is, the index page is defined as the main blueprint. The method is as follows:

• Create the main folder

• Create a new blueprint initialization file in the folder_ _init__.py

• Create the view method file view.py

• Create the error page view method errors.py
  ## in the main blueprint

#The initialization file code is as follows:

from flask import Blueprint

main=Blueprint("main",__name__) # 创建蓝本
from . import errors,views

Currently, the view method file has only one index method, the code is as follows:

from flask import render_template
from . import main

@main.route("/")
def index():
 return render_template("index.html",site_name='myblog')

The error page code is omitted

The URL of the main blueprint does not use the prefix

Then the login registration and logout page is concentrated in the permission blueprint (auth). The permission blueprint initialization code is as follows:

from flask import Blueprint

auth=Blueprint("auth",__name__)
from . import views

The view is mainly completed before Migrate the view:

from . import auth
from .. import db,login_manager
from ..forms.LoginForm import LoginForm（*）
from ..models.User import User （*）
from flask_login import login_user,logout_user
from flask import render_template,flash,redirect,url_for

@auth.route("/login",methods=["GET","POST"])
def login():
 form = LoginForm()
 print(url_for("main.index"))
 if form.validate_on_submit():
  username = form.username.data
  password = form.password.data
  print(User)
  user = User.query.filter_by(username=username, password=password).first()
  if user is not None:
   login_user(user, form.remember_me.data)
   print(url_for("main.index"))
   return redirect(url_for("main.index"))
  else:
   flash("您输入的用户名或密码错误")
   return render_template("/auth/login.html", form=form) # 返回的仍为登录页
  return redirect(url_for("main.index"))
 return render_template("/auth/login.html",form=form)

@auth.route("/logout",methods=["GET","POST"])
def logout():
 logout_user()
 return redirect(url_for("main.index"))

@login_manager.user_loader
def load_user(user_id):
 return User.query.get(int(user_id))

Pay attention to the two lines marked with asterisks. Be sure to pay attention to the py file and py object. The object must be imported in the file.

The code in the LoginForm file is as follows:

from flask_wtf import FlaskForm
from wtforms import StringField,PasswordField,SubmitField,BooleanField
from wtforms.validators import DataRequired

class LoginForm(FlaskForm):
 username=StringField("请输入用户名",validators=[DataRequired()])
 password=PasswordField("请输入密码")
 remember_me=BooleanField("记住我")
 submit=SubmitField("登录")

The code in the User file is as follows:

from flask_login import UserMixin
from .. import db

class User(UserMixin,db.Model):
 __tablename__="users"
 id=db.Column(db.Integer,primary_key=True)
 username=db.Column(db.String(50),unique=True,index=True)
 password=db.Column(db.String(50))
 nickname=db.Column(db.String(50))
 email=db.Column(db.String(100))
 birthday=db.Column(db.DateTime)
 gender=db.Column(db.Integer)
 remark=db.Column(db.String(200))
 role_id=db.Column(db.Integer,db.ForeignKey("roles.id"))

Note that the import method of the flask plug-in has been changed from flask.ext.* to the flask_* method recommended by the new version. Thank you for this. Reminder from Yuji Denbaicai.

Of course, the blueprint must be registered in the end, so the final code of the create_app method is:

def create_app():
 app = Flask(__name__)
 app.config.from_object(Config)
 bootstrap.init_app(app)
 login_manager.init_app(app)
 login_manager.session_protection=Config.LOGIN_PROTECTION
 login_manager.login_view=Config.LOGIN_VIEW
 db.init_app(app)
 from .main import main as main_blueprint
 from .auth import auth as auth_blueprint
 app.register_blueprint(main_blueprint)     #无url前缀
 app.register_blueprint(auth_blueprint,url_prefix="/auth") #url前缀为/auth
 return app

The last modification is the way to start the operation, create a new manager.py file, and configure the startup code As follows:

from app import create_app, db
from flask_script import Manager,Shell
from flask_migrate import Migrate,MigrateCommand
from app.models.User import User
from app.models.Role import Role
import pymysql
pymysql.install_as_MySQLdb()
app=create_app()
manager=Manager(app);
migrate = Migrate(app, db)
def make_shell_context():
 return dict(app=app,db=db,User=User,Role=Role) #注册shell命令
manager.add_command("db", MigrateCommand) #新增db命令用于数据库迁移
manager.add_command("shell" ,Shell(make_context=make_shell_context()))

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

Use the most rustic way to run it. The running result is the same as when there was only default.py. At this time, the system directory is as follows, for reference only:

The above is the detailed content of Detailed example of organizational structure adjustment (python). For more information, please follow other related articles on the PHP Chinese website!