day59-Flask模型关系和钩子函数

一、一对多模型

1.查询语法

'多'的信息 = '一'的对象.rerelationship字段

'一'的信息 = '多'的对象.backref字段

2.建立模型

注意：表的外键由db.ForeignKey指定，传入的参数是表的字段。db.relationship它声明的属性不作为表字段，第一个参数是关联类的名字，backref是一个反向身份的代理。一般情况db.relationship()会放在'一'这一边。

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()


# 学生模型
class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    s_name = db.Column(db.String(20), unique=True, nullable=False)
    s_phone = db.Column(db.String(11), nullable=True)
    s_age = db.Column(db.Integer, nullable=False)
    s_gender = db.Column(db.Integer, default=1)

    grade_id = db.Column(db.Integer, db.ForeignKey('grade.id'), nullable=True)


# 班级模型
class Grade(db.Model):
    __tablename__ = 'grade'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    g_name = db.Column(db.String(10), unique=True, nullable=False)

    stus = db.relationship('Student', backref='g', lazy=True)

3.通过班级查询学生信息(一查多)

@blue.route('/sel_stu_by_grade/', methods=['GET'])
def sel_stu_by_grade():
    grade = Grade.query.filter(Grade.g_name == 'Python').first()
    students = grade.stus

    return '查询成功'

4.通过学生查询班级信息(多查一)

@blue.route('/sel_grade_by_stu/', methods=['GET'])
def sel_grade_by_stu():
    stu = Student.query.get(10)
    grade = stu.g

    return '学生查询班级成功'

5.lazy参数

lazy决定了SQLAlchemy什么时候从数据库中加载数据，有如下四个值:

True/select就是访问到属性的时候,就会全部加载该属性的数据。

False/joined则是在对关联的两个表进行join操作，从而获取到所有相关的对象。

dynamic则不一样，在访问属性的时候，并没有在内存中加载数据，而是返回一个query对象, 需要执行相应方法才可以获取对象。

---

二、多对多模型

1.向中间表添加关联关系

方法一：
对象1.relationship字段.append(对象2)

方法二：
对象2.backrel字段.append(对象1)

2.建立模型

s_c表由db.Table声明，我们不需要关心这张表，因为这张表将会由SQLAlchemy接管，它唯一的作用是作为student表和course表的关联表，所以必须在db.relationship()中指出sencondary关联表参数。backref是声明反向身份代理。

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()


# 学生模型
class Student(db.Model):
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    s_name = db.Column(db.String(20), unique=True, nullable=False)
    s_phone = db.Column(db.String(11), nullable=True)
    s_age = db.Column(db.Integer, nullable=False)
    s_gender = db.Column(db.Integer, default=1)
    grade_id = db.Column(db.Integer, db.ForeignKey('grade.id'), nullable=True)


# 中间表
s_c = db.Table('s_c',
               db.Column('s_id', db.Integer, db.ForeignKey('student.id')),
               db.Column('c_id', db.Integer, db.ForeignKey('course.id'))
               )


# 课程模型
class Course(db.Model):
    __tablename__ = 'course'
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    c_name = db.Column(db.String(10), unique=True, nullable=False)
    stus = db.relationship('Student', secondary=s_c, backref='cou')

3.学生添加课程

@blue.route('/add_s_c/', methods=['GET'])
def add_s_c():
    stu = Student.query.get(3)
    course = Course.query.filter(Course.c_name == '线代').first()
    # 方法一：
    stu.cou.append(course)

    #方法二：
    course.stus.append(stu)

    db.session.commit()

    return '添加学生课程'

4.删除学生课程

@blue.route('/del_s_c/', methods=['GET'])
def del_s_c():
    stu = Student.query.get(3)
    course = Course.query.filter(Course.c_name == '线代').first()
    # 方法一：
    stu.cou.remove(course)

    # 方法二：
    course.stus.remove(stu)

    db.session.commit()

    return '删除学生课程'

---

三、应用上下文和钩子函数

1.钩子函数

before_request: 被装饰的函数会在每个请求被处理之前调用。

after_request: 被装饰的函数会在每个请求退出时才被调用。在程序没有抛出异常的情况下，才会执行。

teardown_request: 被装饰的函数会在每个请求退出时才被调用。不论程序是否抛出异常，都会执行。

2.钩子函数执行顺序

@blue.before_request
def before_req():
    print('请求之前执行代码')


@blue.route('/index/', methods='GET')
def index():
    return '我是index'


@blue.after_request
def after_req(response):
    print('请求之后执行的代码')

    return response


@blue.teardown_request
def teardown_req(exception):
    print('teardown request')

控制台打印结果：

请求之前执行代码

请求之后执行的代码

teardown request

从控制台的输出中可以看出各函数的执行顺序，被before_request装饰的函数会在请求处理之前被调用。而after_request和teardown_request会在请求处理完后才被调用。区别就在于after_request只会在请求正常退出的情况下才会被调用，并且atfer_request函数必须接受一个响应对象，并返回一个响应对象。而teardown_request函数在任何情况下都会被调用，并且必须传入一个参数来接收异常对象。

3.应用上下文g对象
应用全局对象（g）是Flask为每一个请求自动建立的一个对象。g的作用范围只是在一个请求（也就是一个线程）里，它不能在多个请求中共享数据，故此应用全局变量（g）确保了线程安全。

import pymysql
from flask import g


@blue.before_request
def before_req():
    conn = pymysql.Connection(host='127.0.0.1', port=3306, database='flask',
                       user='root', password='123456')
    cursor = conn.cursor()

    # 设置当前请求上下文中的应用全局对象
    g.conn = conn
    g.cursor = cursor


@blue.route('/my_sel_stu/')
def my_sel_stu():
    sql = 'select * from student;'
    g.cursor.excute(sql)
    data = g.cursor.fetchall()

    return '查询成功'


@blue.teardown_request
def teardown_req(e):
    g.conn.close()

    return e

---