1.关联关系 —> 多对多
定义模型:
引入SQLALchemy
1
2
3
| from flask_sqlalchemy import SQLALchemy
db = SQLALchemy
|
创建中间表
1
2
3
| sc = db.Table('sc',
db.Column('s_id', db.Integer, db.ForeignKey('student.s_id'), primary_key=True),
db.Column('c_id'), db.Integer, db.ForeignKey('course.c_id'), primary_key=True)
|
创建学生类Student
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class Student(db.Model):
s_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
s_name = db.Column(db.String(16), unique=True)
s_age = db.Column(db.Integer, defauult=18)
s_g = db.Column(db.Integer, db.Foreignkey('grade.g_id'), nullable=True)
__tablename__ = 'student'
def __init__(self, name, age):
self.s_name = name
self.s_age = age
self.s_g = None
|
创建课程表的模型, Course类
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Course(db.Model):
c_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
c_name = db.Column(db.String(20), unique=True)
students = db.relationship('Student',
secondary=sc,
backref='cou')
__tablename__ = 'courses'
def __init__(self, name):
self.s_name = name
|
sc表由db.Table声明，我们不需要关心这张表，因为这张表将会由SQLAlchemy接管，它唯一的作用是作为students表和courses表关联表，所以必须在db.relationship()中指出sencondary关联表参数。lazy是指查询时的惰性求值的方式，这里有详细的参数说明，而db.backref是声明反向身份代理，其中的lazy参数是指明反向查询的惰性求值方式.
2. 添加学生和课程之间的关系
通过页面中传递学生的id和课程的id，分别获取学生的对象和课程的对象，在使用关联关系append去添加学生对象，并且add以后再commit后，就可以在中间表sc中查看到新增的关联关系了。
1
2
3
4
5
6
7
8
9
| userid = request.form.get('userid')
courseid = request.form.get('courseid')
stu = Student.query.get(userid)
cou = Course.query.get(courseid)
cou.students.append(stu)
db.session.add(cou)
db.session.commit()
|
3. 删除学生和课程之间的关系
通过页面获取传递的学生的id和课程的id，分别获取学生对象和课程对象，在使用关联关系remove去删除学生对象，并commit将事务提交到数据库中
1
2
3
4
5
| stu = Student.query.get(s_id)
cou = Course.query.get(c_id)
cou.students.remove(stu)
db.session.commit()
|
4. 通过课程查询学生的信息
以下定义在课程course的模型中，所以通过课程查询学生的信息，语法为课程的对象.studengs。如果知道学生的信息反过来找课程的信息，则使用backref的反向关联去查询，语语法为学生的对象.cou(反向)
students = db.relationship(‘Student’,secondary=sc,backref=’cou’)
1
2
| cou = Course.query.get(3)
stus = cou.students
|
5. 通过学生去查询课程的信息
1
2
| stu = Student.query.get(id)
cous = stu.cou
|
1.1安装
1
| pip install flask-debugtoolbar
|
1.2配置
1
2
3
4
5
6
7
8
9
10
11
| from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension
app = Flask(__name__)
app.debug = True
app.config['SECRET_KEY'] = '<replace with a secret key>'
toolbar = DebugToolbarExtension(app)
|
2. restful
Flask-RESTful 提供的最主要的基础就是资源(resources)。资源(Resources)是构建在 Flask 可拔插视图 之上，只要在你的资源(resource)上定义方法就能够容易地访问多个 HTTP 方法
官网上描述了一个最简单的restful风格的api，如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| from flask import Flask
from flask.ext import restful
app = Flask(__name__)
api = restful.Api(app)
class HelloWorld(restful.Resource):
def get(self):
return {'hello': 'world'}
api.add_resource(HelloWorld, '/')
if __name__ == '__main__':
app.run(debug=True)
|
2.1安装
1
| pip install flask_restful
|
2.2配置
在create_app()获取Flask(name)对象中，设置如下配置
1
2
3
4
5
| from flask_restful import Api
api = Api()
api.init_app(app=app)
|
在views中需要引入配置的api还有Resource
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| # 导入包和restful中的Api对象
from flask_restful import Resource
from tuils.functions import api
# 定义类, 启动包含了对数据处理的GET, POST, PATCH, PUT, DELETE请求
class CreateCourse(Resource):
def get(self, id):
course = Course.query.get(id)
return course.to_dict()
def post(self):
courses = ['大学英语', '大学物理', '线性代数', '高数', '大学语文', '马克思主义', 'C++', '课外拓展']
course_list = []
for course in courses:
c = Course()
c.c_name = course
course_list.append(c)
db.session.add_all(course_list)
db.session.commit()
courses = Course.query.all()
return [course.to_dict() for course in courses]
def patch(self, id):
c_name = request.form.get('c_name')
course = Course.query.get(id)
course.c_name = c_name
db.session.commit()
return {'code':200, 'data': course.to_dict(), 'msg': '请求成功'}
def delete(self, id):
course = Course.query.get(id)
db.session.delete(course)
db.seesion.commit()
return {'code': 200, 'msg': '删除成功'}
# 绑定处理url
api.add_resource(CreateCourse, '/api/course/<int:id>/', '/api/course/')
|
2.3 端点(Endpoints)
在一个 API 中，你的资源可以通过多个 URLs 访问。你可以把多个 URLs 传给 Api 对象的 Api.add_resource() 方法。每一个 URL 都能访问到你的 Resource
如：
1
| api.add_resource(CreateCourse, '/api/course/<int:id>/', '/api/course/')
|
2.4 返回响应
Flask-RESTful 支持视图方法多种类型的返回值。同 Flask 一样，你可以返回任一迭代器，它将会被转换成一个包含原始 Flask 响应对象的响应。Flask-RESTful 也支持使用多个返回值来设置响应代码和响应头
如：
1
2
3
| def get(self, id):
course = Course.query.get(id)
return course.to_dict(), 200
|
