Django框架

分手后的思念是犯贱 2022-05-21 06:38 228阅读 0赞

### MVC编程模式    ###

MVC是

MVC 是一种使用 MVC(Model View Controller 模型-视图-控制器)设计创建 Web 应用程序的模式:

*  Model(模型)表示应用程序核心(比如数据库记录列表)。
 *  View(视图)显示数据(数据库记录)。
 *  Controller(控制器)处理输入(写入数据库记录)。

MVC 模式同时提供了对 HTML、CSS 和 JavaScript 的完全控制。

**Model(模型)**：是应用程序中用于处理应用程序数据逻辑的部分。

通常模型对象负责在数据库中存取数据。

**View(视图)：**是应用程序中处理数据显示的部分。

通常视图是依据模型数据创建的。

**Controller(控制器)**：是应用程序中处理用户交互的部分。

通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

### MTV编程模式 ###

本质上与MVC模型没有什么差别，也是各组件之间为了保持松耦合关系，只是定义上有些不同。也是Django使用的一种编程模式。

Model（模型）：负责业务对象与数据库的对象（ORM）

Template(模板)：负责如何把页面展示给用户

View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

注意：Django还有一个url分发器它的作用是将一个个URL的页面请求分发给不同的view处理，view在调用Model和Template。

下面分别对Django各模块进行介绍：

#### Model（模型）    ####

概述：Django对各种数据库都提供了很好的支持，并且为这些数据库提供了统一的调用接口API，我们可以根据业务需求选择使用不同的数据库。

#####      ORM #####

概述： ORM （ 对象\-关系-映射 ） 是一种程序技术，它可以将对对象的操作自动转换成对应数据库的语句 ， 它的任务就是根据类生成表结构 、 将对象、列表的操作转换为SQL 语句、将SQL 查询到的结果转换为对象、列表。它具有的优点：极大的减少开发人员的工作量，不需要面对因数据库变更而导致代码无效。  
  任务：它是根据类生成表结构，将对象列表的操作转换为SQL语句，将SQL查询到的结果转换为对象、列表。  
  优点：极大地减少了开发人员的工作量，不需要面对因数据库变更而导致代码无效。  
  缺点：会增加时间开销，降低效率，性能相对较低，增加学习成本。  
  定义模型：一个模型在数据库中对应一张表，在模型中定义属性，对应该模型对照表中的一个字段。

#####   创建模型对象常用的有两种方式： #####

第一种方式：  
    在模型中创建学生类  
    class Student(models.Model):  
    \# 自定义管理器  
    name     = models.CharField(max\_length=20)  
    sex      = models.BooleanField()  
    contend  = models.CharField(max\_length=20)  
    age      = models.IntegerField()  
    grade    = models.ForeignKey("Grade")  
    isDelete = models.BooleanField(default=False)  
    def \_\_str\_\_(self):  
        return self.name  
    class Meta:  
        db\_table = "students"  
        ordering = \["-id"\]  
    @classmethod  
    def create(cls, name, sex, age, contend, grade):  
        return cls(name=name, sex=sex,age=age,contend=contend,grade=grade)  
在视图中创建学生对象  
def addStudent(request):  
    stu = Student.create("kaige",True,17,"kaige is a nice man", Grade.objects.get(pk=2))  
    stu.save()  
    stus = Student.objects.all()  
    return render(request, 'myApp/students.html', \{"stus": stus\})  
    第二种方式：  
在自定义管理类中添加一个方法  
   class StudentManager(models.Manager):  
    def get\_queryset(self):  
        return super(StudentManager, self).get\_queryset().filter(isDelete=False)  
    def create(self, name, sex, age, contend, grade):  
        obj = self.model()  
        obj.name = name  
        obj.sex = sex  
        obj.age = age  
        obj.contend = contend  
        obj.grade = grade  
        return obj  
class Student(models.Model):  
    \# 自定义管理器  
    objects = StudentManager()  
  
    name     = models.CharField(max\_length=20)  
    sex      = models.BooleanField()  
    contend  = models.CharField(max\_length=20)  
    age      = models.IntegerField()  
    grade    = models.ForeignKey("Grade")  
    isDelete = models.BooleanField(default=False)  
    def \_\_str\_\_(self):  
        return self.name  
    class Meta:  
        db\_table = "students"  
        ordering = \["-id"\]  
在视图中创建学生对象  
def addStudent(request):  
    stu = Student.objects.create("kaishen", True, 19,"kaishen is a cool man", Grade.objects.get(pk=3))  
    stu.save()  
  
    stus = Student.objects.all()  
    return render(request, 'myApp/students.html', \{"stus": stus\})  
模型的继承  
默认模型时是允许继承的，但是默认的继承处理方式不是很合理，在开发中需要将父类抽象化，在元信息中添加abstart=True。  
示例如下：  
class Animal(models.Model):  
    name = models.CharField(max\_length=20)  
    age  = models.IntegerField()  
    class Meta:  
        \# 将该类抽象化，将父类中的字段直接放入子类对应的表中，并且不会生成该模型对应的表  
        abstract = True  
class Dog(Animal):  
    a = models.CharField(max\_length=10)  
模型关系  
1:1  
使用场景:表的字段太多，需要拆分.  
class Person(models.Model):  
    name = models.CharField(max\_length=20)  
    age  = models.IntegerField()  
class IDCard(models.Model):  
    cardID = models.CharField(max\_length=18)  
    sex    = models.BooleanField()  
    \# 关系存放在哪张表里都可以  
    \# 绑定身份证与人的一对一关系，默认情况下，当人被删除，于人绑定的身份证也就删除了，这个可以使用on\_delete来进行调整  
    person = models.OneToOneField(Person)  
on\_delete各种类型：  
models.CASCADE：默认值；  
models.PROTECT：保护模式；  
models.SET\_NULL：置空模式；  
models.SET\_DEFAULT：置默认值；  
models.SET()：删除的时候重新动态指定一个实体访问对象  
注意：声明关系的表示从表  
级联数据获取：  
主获取从：关系字段是隐性属性，对象.关系模型名(小写)  
def person(request, pid):  
    per = Person.objects.get(pk=pid)  
    return HttpResponse(per.name+"--"+per.idcard.cardID)  
从获取主：关系是直接声明的，它是一个显性属性  
def idcard(request, cid):  
    card = IDCard.objects.get(pk=cid)  
    return HttpResponse(card.cardID+"--"+card.person.name)  
m:n  
原理：底层是通过两个外键实现的，两个外键存在于关系表中。会自动生成一张外键管理表  
class Buyer(models.Model):  
    name  = models.CharField(max\_length=20)  
    level = models.IntegerField(default=1)  
class Goods(models.Model):  
    name  = models.CharField(max\_length=20)  
    price = models.FloatField()  
    num   = models.IntegerField()  
    \# 形成多对多关系，外键写在哪张表里都可以  
    buyers = models.ManyToManyField(Buyer)  
模型查询  
简介：从数据库中获取对象集合，查询集可以有零个、一个或者多个过滤器，过滤器基于所给的参数限制查询结果。  
从sql的角度，和查询集合select语句等价，过滤器如：where和limit等子句。查询集不会带来任何数据库的访问，直到调用数据时才会访问数据库。