flask的一些组件应用(signal,session的创建的两种方式,自定义组件实现登录权限验证)

点进来

信号的代码:

 

from flask import Flask, signals, render_template, flash

from flask.signals import _signals
aps = Flask(__name__)
aps.debug=True

def ap1(*args, **kwargs):
    print('touch the signal:request_started')


def ap2(*args, **kwargs):
    print('touch the signals:appcontext_pushed')

# aaa=_signals.signal('aaa')  # 这里是自定义的信号
# aaa.connect(ap1)


signals.request_started.connect(ap1)
signals.appcontext_pushed.connect(ap2)

@aps.route('/hello')
def hello():
    # aaa.send('abcdef',k1='vva')
    return 'in me the tiger'


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

 

 

创建session的方式:

import models
from threading import Thread
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session
eaengine = create_engine('mysql+pymysql://root:123@127.0.0.1:3306/demo?charset=utf8')
aaa = sessionmaker(bind=eaengine)
ses=scoped_session(aaa)  # 创建session的第二种方式,把我们的sessionmaker实例化出来的对象作为参数
# 传入到scoped_session里面去然后用scoped_session实例化出来的对象去做操作

def task():
    ret=ses.query(models.Classes).all()
    print(ret)
    ses.remove()

for i in range(3):
    td=Thread(target=task)
    td.start()

 

import models
from threading import Thread
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine

eaengine = create_engine('mysql+pymysql://root:123@127.0.0.1:3306/demo?charset=utf8')
aaa = sessionmaker(bind=eaengine)  # 用sessionmaker实例化出来一个对象aaa,


def hello():
    from sqlalchemy.orm.session import Session
    sess = aaa()  # 然后用sessionmaker实例化出来的这个对象aaa去再实例化出来一个sess,
    # 用这个sess去对我们的数据进行操作,这是创建session的一种方式
    data = sess.query(models.Classes).all()
    print(data)
    sess.close()


for i in range(3):
    th = Thread(target=hello)
    th.start()

这里是配合着session用的model表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, UniqueConstraint, Index, DateTime, ForeignKey
from sqlalchemy import create_engine
from sqlalchemy.orm import relationship
import datetime

Base = declarative_base()


class Classes(Base):
    __tablename__ = 'classes'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(32), nullable=False, unique=True)


class Student(Base):
    __tablename__ = 'student'
    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(32), nullable=False, index=True)
    password = Column(String(64), nullable=False)
    ctime = Column(DateTime, default=datetime.datetime.now)
    class_id = Column(Integer, ForeignKey("classes.id"))

    cls = relationship("Classes", backref='stus')


class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')


class Student2Hobby(Base):
    __tablename__ = 'student2hobby'
    id = Column(Integer, primary_key=True, autoincrement=True)
    student_id = Column(Integer, ForeignKey('student.id'))
    hobby_id = Column(Integer, ForeignKey('hobby.id'))

    __table_args__ = (
        UniqueConstraint('student_id', 'hobby_id', name='uix_student_id_hobby_id'),
        # Index('ix_id_name', 'name', 'extra'),
    )


def init_db():
    # 数据库连接相关
    engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/demo?charset=utf8")
    # 创建表
    Base.metadata.create_all(engine)


def drop_db():
    engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/demo?charset=utf8")
    # 删除表
    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    # drop_db()
    init_db()

 

多App应用

# 这里是多App应用在一个文件夹的代码
from flask import Flask
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple

apa = Flask('api')
apz = Flask('azi')


@apa.route('/xxx')
def xxx():
    return 'in me the '


@apz.route('/zzz')
def zzz():
    return 'tiger'

# 我们的多App运行在一个文件里面这个DispatcherMiddleware类是关键,它内部的逻辑代码实现了这个功能,
dm = DispatcherMiddleware(apa, {
    '/azi': apz,  # 这里的路由就是我们的zai前缀,它是我们上面的flask里面的字符串,
    # 然后apz就是我们的视图里面对应的路由
})

if __name__ == '__main__':
    run_simple('localhost', 5000, dm)

"""
这里就是我们的DispatcherMiddleware的源码
class DispatcherMiddleware(object):

    def __init__(self, app, mounts=None):
        self.app = app  # app就是我们上面的apa
        
        self.mounts = mounts or {}  # {'azi':apz}

    def __call__(self, environ, start_response):
        script = environ.get('PATH_INFO', '')  # /azi/zzz 前面path_info是前缀路由,后面的''空字符串是我们的route里面设定的路由
        path_info = ''
        while '/' in script:
            if script in self.mounts:
                app = self.mounts[script]
                break
            script, last_item = script.rsplit('/', 1)  # script=azi,last_item=zzz
            path_info = '/%s%s' % (last_item, path_info)
        else:
            app = self.mounts.get(script, self.app)
        original_script_name = environ.get('SCRIPT_NAME', '')
        environ['SCRIPT_NAME'] = original_script_name + script
        environ['PATH_INFO'] = path_info
        return app(environ, start_response)
"""

 

最后完整版的flask自定义组件登录权限验证代码:

 

settings

class Base():
    SQLALCHEMY_POOL_SIZE = 3
    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:123@127.0.0.1:3306/demo?charset=utf8'
    SQLALCHEMY_POOL_TIMEOUT = 30
    SQLALCHEMY_RECYCLE = -1

    # 追踪对象的修改并发送信号
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    SECRET_KEY='sghsdjgksdlf'

class DevelopmentConfig(Base):
    DEBUG=True
    ...


class TestingConfig(Base):
    ...


class ProductionConfig(Base):
    ...

 

manage

from end_copy_sqlalchemy import db, create_app
from flask_script import Manager
from flask_migrate import Migrate, MigrateCommand

app = create_app()
manage = Manager(app)
"""
我们在下面使用了flask-migrate组件,就不需要再用我们的离线脚本了,
它就相当于我们django里面的那个makemigration和migrate两个命令,
对于数据库进行监测更新的,
数据库迁移命名
python manage.py db init
python manage.py db migrate # makemigrations
python manage.py db upgrade # migrate
"""
Migrate(app, db)
manage.add_command('db', MigrateCommand)


@manage.command  # 这里是自定制命令我们的程序启动的时候就用这个
def wahaha(obj):
    print(obj)


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

 

model表

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from end_copy_sqlalchemy import db


class User(db.Model):
    __tablename__ = 'person'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(32), nullable=True)
    email=Column(String(32),default='alex@qq.com')

 

init

from flask_sqlalchemy import SQLAlchemy
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from .service.auth import Auth

db = SQLAlchemy()
from .views.accou import acp
from .views.index import ind


def create_app():
    apo = Flask(__name__)
    apo.config.from_object("settings.DevelopmentConfig")
    apo.register_blueprint(acp)
    apo.register_blueprint(ind)
    db.init_app(apo)
    Auth(apo)
    return apo

 

auth认证权限

from flask import request, session, redirect
from flask_session import Session


class Auth():
    def __init__(self, apa=None):
        self.app = apa
        if apa:
            self.init_app(apa)

    def init_app(self, apx):
        apx.auth_manager = self
        self.app = apx
        apx.before_request(self.check_login)
        apx.context_processor(self.context_processor)

    def check_login(self):
        """
        检查用户是否已经登录
        :return:
        """
        if request.path == '/login':
            return
        user = session.get('user')
        if not user:
            return redirect('/login')

    def context_processor(self):
        user = session.get('user')
        return dict(current_user=user)

    def login(self, obj):
        """
        将用户信息放入到session里面
        :param obj:
        :return:
        """
        session['user'] = obj

    def logout(self):
        """
        从session中删除用户信息
        :return:
        """
        del session['user']

 

views

from flask import blueprints, request, render_template, current_app, redirect
from end_copy_sqlalchemy import db, model

acp = blueprints.Blueprint('acp', __name__)


@acp.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template('login.html')
    else:
        user = request.form.get('user')
        email = request.form.get('email')
        obj = db.session.query(model.User).filter(model.User.name == user,model.User.email==email).first()
        db.session.remove()
        if not obj:
            return render_template('login.html', msg='you have got wrong username')
        current_app.auth_manager.login(user)
        return redirect('/index')


@acp.route('/logout')
def logout():
    current_app.auth_manager.logout()
    return redirect('/login')

from flask import blueprints,render_template,redirect
from end_copy_sqlalchemy import model,db
ind=blueprints.Blueprint('index',__name__)
@ind.route('/index')
def index():
    return render_template('index.html')

 

templates

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Title</title>
</head>
<body>
<form method="post">
    <input type="text" name="user" placeholder="user">
    <input type="email" name="email" placeholder="email">
    <input type="submit" value="put on">
    {{msg}}
</form>
</body>
</html>

 

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Title</title>
</head>
<body>
<h1>欢迎登陆{{current_user}}</h1>
</body>
</html>