Django Web架构：全面掌握Django模型字段（下） - 码农知识堂 - 文章详情页

Django Web架构：全面掌握Django模型字段（下）
Django Web架构 全面掌握Django模型字段（下）
- 文章信息 -
Author: 李俊才 (jcLee95)
Visit me at CSDN: https://jclee95.blog.csdn.net
My WebSite：http://thispage.tech/
Email: 291148484@163.com.
Shenzhen China
Address of this article:https://blog.csdn.net/qq_28550263/article/details/136380968
HuaWei:https://bbs.huaweicloud.com/blogs/422968

【介绍】：在开发Django应用时，模型字段扮演着至关重要的角色。它们不仅定义了数据的结构，即数据库表的列，还规定了数据的行为和如何与之交互。通过精心设计的模型字段，开发者可以在数据库和应用层之间建立起一座桥梁，使得数据的存取、验证和处理变得既高效又安全。

上一节：《全面掌握Django模型字段（上） 》
目录
开始前，请先阅读上一节：《全面掌握Django模型字段（上） 》

1. 字段与数据库交互

在 Django 模型中，字段与数据库的交互是通过各种选项和方法来控制的。这些选项和方法定义了如何将模型字段映射到数据库列、如何处理索引以及如何在 Python 对象和数据库值之间进行转换。本节重点讨论数据库列映射，包括 db_column 和 db_index 等选项的使用及其对数据库性能的影响。

1.1 数据库列映射

 1.1.1 数据库列映射的概念和用法

数据库列映射是指如何将Django模型字段映射到数据库中的列。这一过程主要通过db_column、db_index等选项来控制。

1. db_column

db_column 选项允许开发者自定义字段在数据库中的列名。如果不指定db_column，Django 默认使用字段的名称作为数据库列名。例如：
```
class Person(models.Model):
    name = models.CharField(max_length=100, db_column='person_name')
1
2
```
在上述示例中，虽然模型字段名为name，但在数据库中，该字段的列名将被映射为person_name。

在实际开发中：
- 当模型字段名称与数据库列名不一致时，可以使用db_column来指定正确的数据库列名。
- 当数据库列名是SQL保留字或包含非法字符时，使用db_column来避免潜在的冲突。
2. db_index

db_index 选项用于指定是否为字段创建数据库索引。默认情况下，db_index 设置为False，意味着不会为字段创建索引。如果设置为True，Django 将为该字段创建索引，这可以提高查询性能，但可能会降低写入性能并增加数据库的存储需求。
例如：
```
class Article(models.Model):
    title = models.CharField(max_length=100, db_index=True)
1
2
```
在上面的代码中，title 字段将被创建索引，这有助于提高基于文章标题的查询速度。

1.1.2 数据库列映射的应用场景

当频繁根据某个字段进行查询时，为该字段创建索引可以显著提高查询效率。需要权衡索引带来的查询性能提升与其对写入性能和存储空间的影响。

对数据库性能的影响：
- 查询性能：为字段创建索引可以显著提高基于该字段的查询速度，尤其是在数据量大时。
- 写入性能：每次插入或更新数据时，数据库都需要更新索引，这可能会降低写入性能。
- 存储需求：索引需要额外的存储空间，对于大型数据库，这可能是一个考虑因素。
通过合理使用 db_column 和 db_index 等选项，开发者可以在保证数据模型清晰性的同时，优化数据库的性能和存储效率。

1.2 数据库值与Python值的转换

在 Django 模型中，字段值在从数据库读取和保存到数据库时，经常需要进行数据类型的转换。这一过程确保了数据在 Python 代码和数据库之间的正确传递和存储。Django 提供了几个方法来处理这种类型转换，主要包括 from_db_value() 和 to_python() 方法，以及 pre_save() 和 get_db_prep_save() 方法。下面将详细介绍这些方法的作用和使用场景。

1. from_db_value()方法

from_db_value() 方法用于将数据库中的值转换为 Python 类型的值。当 Django 从数据库中读取数据时，会自动调用此方法。这对于自定义字段特别有用，因为它允许开发者控制从数据库读取数据后的数据处理过程。
```
def from_db_value(self, value, expression, connection):
    if value is None:
        return value
    return my_custom_transformation(value)
1
2
3
4
```
在这个示例中，my_custom_transformation 是一个假设的函数，用于对数据库中读取的原始值进行处理，将其转换为所需的Python类型。

2. to_python()方法

to_python() 方法确保 Django 能够将字段的值转换为合适的 Python 数据类型。这个方法在多个场景下被调用，包括从数据库读取数据时、以及通过表单或序列化过程对数据进行清洗时。
```
def to_python(self, value):
    if isinstance(value, MyDesiredType):
        return value
    return my_conversion_logic(value)
1
2
3
4
```
在这个例子中，MyDesiredType是目标Python数据类型，my_conversion_logic是将值转换为MyDesiredType类型的逻辑。

3. pre_save()方法

pre_save() 方法在模型保存到数据库之前被调用。这个方法允许开发者在数据被保存之前对其进行最后的处理或验证。
```
def pre_save(self, model_instance, add):
    value = getattr(model_instance, self.attname)
    return my_pre_save_process(value)
1
2
3
```
这里，my_pre_save_process是对即将保存的值进行处理的函数，self.attname是字段在模型中的属性名。

4. get_db_prep_save()方法

get_db_prep_save() 方法用于在将数据保存到数据库之前，将 Python 类型的值转换为适合数据库存储的格式。这个方法通常与 pre_save()方法一起使用，以确保数据正确地保存到数据库。
```
def get_db_prep_save(self, value, connection):
    return my_db_preparation(value)
1
2
```
在这个例子中，my_db_preparation 是一个函数，用于将 Python 值转换为数据库可以接受的格式。
通过正确使用这些方法，开发者可以确保数据在 Python 代码和数据库之间正确、高效地转换，同时也为处理复杂数据类型提供了灵活性。这些方法的组合使用，特别是在自定义字段类型时，是非常重要的，它们帮助开发者确保数据的一致性和完整性。

2. 字段与表单交互

在 Django 中，模型字段与表单字段之间的交互是通过 formfield 方法实现的。这一机制不仅确保了数据的一致性和有效性，还提供了灵活性，允许开发者根据具体需求自定义表单字段。

2.1 formfield方法的作用

formfield方法负责将模型字段转换为表单字段。每种模型字段类型（如CharField、IntegerField等）都有一个对应的默认表单字段类型。当模型表单被创建时，Django会自动调用模型字段的formfield方法，以生成相应的表单字段。
```
from django.db import models
from django.forms import CharField, Form

class MyModel(models.Model):
    my_field = models.CharField(max_length=100)

    def formfield(self, **kwargs):
        return super().formfield(**{
            'form_class': CharField,
            'max_length': self.max_length,
            **kwargs,
        })
1
2
3
4
5
6
7
8
9
10
11
12
```
2.2 自定义表单字段

虽然 Django 为大多数模型字段提供了合适的默认表单字段，但有时候默认的表单字段可能无法满足特定的需求。在这种情况下，开发者可以通过覆盖 formfield 方法来自定义表单字段。
自定义表单字段允许开发者指定不同的表单字段类型、设置额外的表单字段选项（如widget、help_text等），或者添加自定义的验证逻辑。
```
from django import forms
from django.db import models

class CustomModelField(models.CharField):
    def formfield(self, **kwargs):
        defaults = {'widget': forms.Textarea}
        defaults.update(kwargs)
        return super().formfield(**defaults)
1
2
3
4
5
6
7
8
```
在上述示例中，自定义的模型字段 CustomModelField 通过覆盖 formfield 方法，指定了一个不同的表单控件 forms.Textarea，使得在表单中该字段将以文本区域（而非单行输入框）的形式展现。

2.3 影响数据的验证和处理

自定义表单字段的一个重要方面是它们如何影响数据的验证和处理。通过自定义表单字段，开发者可以实现特定的数据清洗和验证逻辑，确保用户输入的数据符合预期。
```
class CustomForm(forms.Form):
    custom_field = forms.CharField(widget=forms.Textarea)

    def clean_custom_field(self):
        data = self.cleaned_data['custom_field']
        # 在这里添加自定义验证逻辑
        return data
1
2
3
4
5
6
7
```
在上述 CustomForm表单中，通过定义clean_custom_field方法，开发者可以对custom_field 字段的数据进行自定义的清洗和验证。这种机制提供了极大的灵活性，使得开发者可以根据具体的业务需求，对数据进行精确的控制和处理。

通过理解和利用Django模型字段与表单字段之间的交互机制，开发者可以构建出既灵活又强大的数据输入和验证逻辑，从而提升应用的用户体验和数据质量。

3. 字段的高级特性

3.1 关系字段

在 Django 中，关系字段允许模型之间建立链接，这是构建具有复杂数据关系的应用的基础。主要的关系字段包括 ForeignKey、 ManyToManyField和OneToOneField 。每种字段类型都有其特定的用途和配置选项，可以用来实现不同类型的数据关系。

ForeignKey（外键）

ForeignKey 用于定义“多对一”的关系。例如，一个 Order 模型可能会有一个 ForeignKey 指向 Customer 模型，表示每个订单都关联到一个客户。
示例：
```
from django.db import models

class Customer(models.Model):
    name = models.CharField(max_length=100)

class Order(models.Model):
    product = models.CharField(max_length=100)
    customer = models.ForeignKey(Customer, on_delete=models.CASCADE)
1
2
3
4
5
6
7
8
```
配置选项：
- related_name：允许从 Customer 实例反向查询到所有相关的 Order 实例。
- on_delete：定义当关联的 Customer 被删除时，对应的 Order 应如何处理。models.CASCADE 表示级联删除。
ManyToManyField（多对多关系）

ManyToManyField 用于定义 “多对多” 的关系。例如，一个 Student 模型和一个 Course 模型之间的关系，一个学生可以参加多个课程，一个课程也可以有多个学生参加。

例如：
```
class Student(models.Model):
    name = models.CharField(max_length=100)
    courses = models.ManyToManyField('Course', related_name='students')

class Course(models.Model):
    name = models.CharField(max_length=100)
1
2
3
4
5
6
```
配置选项：

through：指定一个中间模型来详细定义多对多关系的额外数据。例如，可以通过through指定一个Enrollment模型来存储学生的选课时间等信息。

OneToOneField（一对一关系）

OneToOneField 用于定义“一对一”的关系。例如，一个 User 模型和一个UserProfile 模型，每个用户都有一个对应的用户档案，每个用户档案也只关联到一个用户。

例如：
```
from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()
1
2
3
4
5
```
配置选项：
通常用于扩展已存在模型的信息。on_delete=models.CASCADE 确保当 User 被删除时，对应的 UserProfile 也会被删除。

3.2 字段查询与查找

在Django中，模型字段的查询和查找功能是通过一套丰富的API实现的，这些API允许开发者以几乎无限的方式查询数据库。此外，Django还提供了扩展这些查询能力的机制，包括注册自定义的查找和转换方法。本节将深入探讨如何利用这些功能，以及如何为模型字段添加自定义的查询方法。

查找注册API

Django的查找注册API允许开发者为模型字段注册自定义的查找逻辑。这是通过Field.register_lookup()方法实现的。查找是一种特殊的方法，用于在查询中指定如何比较字段和值。Django内置了多种查找类型，如exact、icontains等，但有时你可能需要定义特定于应用的查找逻辑。

示例：注册自定义查找
假设我们有一个需求，需要对CharField进行不区分大小写的精确匹配查找，但不使用iexact查找，因为我们想要实现一些特殊的逻辑。我们可以创建一个自定义查找类并注册它：
```
from django.db.models import CharField, Lookup

@CharField.register_lookup
class InsensitiveExact(Lookup):
    lookup_name = 'iexact_custom'

    def as_sql(self, compiler, connection):
        lhs, lhs_params = self.process_lhs(compiler, connection)
        rhs, rhs_params = self.process_rhs(compiler, connection)
        params = lhs_params + rhs_params
        return f'LOWER({lhs}) = LOWER({rhs})', params
1
2
3
4
5
6
7
8
9
10
11
```
在这个例子中，InsensitiveExact 类继承自Lookup，并实现了as_sql方法，该方法定义了如何生成SQL查询。lookup_name属性定义了查找的名称，可以在查询中使用它，如 Model.objects.filter(field_name__iexact_custom='value')。

自定义转换

转换是另一种强大的特性，允许在将数据库值转换为Python值时应用自定义逻辑。这通过覆盖字段的get_lookup()方法并返回一个自定义的转换类来实现。

示例：添加自定义转换
假设我们想要在查询结果返回之前，对某个字段的值进行自定义的处理，例如，对加密的字段进行解密：
```
from django.db.models import CharField, Transform

class DecryptTransform(Transform):
    lookup_name = 'decrypt'

    def as_sql(self, compiler, connection):
        lhs, params = compiler.compile(self.lhs)
        return f'DECRYPT({lhs})', params

CharField.register_lookup(DecryptTransform)
1
2
3
4
5
6
7
8
9
10
```
在这个例子中，DecryptTransform类继承自 Transform，并实现了 as_sql 方法，该方法定义了如何生成 SQL查询以实现解密逻辑。现在，我们可以在查询中使用__decrypt来应用这个转换，如Model.objects.filter(field_name__decrypt='value')。

通过使用查找注册API 和自定义转换，开发者可以极大地扩展 Django 的查询能力，实现复杂的查询逻辑和数据处理。这些高级特性为处理特殊的数据类型和查询需求提供了强大的工具。

4. 字段属性与方法解析

在Django中，每个模型字段都是Field类的一个实例或其子类的实例。这些字段类定义了如何在Python代码和数据库之间转换数据，以及如何在Django的ORM系统中使用这些数据。理解Field类的关键属性和方法对于高效地使用Django模型至关重要，尤其是在创建自定义字段时。

4.1 关键属性

name: 字段的名称。在模型中定义字段时使用的名称。
verbose_name: 字段的人类可读名称。如果未提供，Django会自动从字段的名称生成。
primary_key: 如果设置为True，该字段将作为模型的主键。
max_length: 用于CharField和TextField等字段，指定数据的最大长度。
default: 字段的默认值。可以是一个值或一个可调用对象。
null: 如果为True，允许字段在数据库中存储NULL值。对于非字符串字段，这通常用于表示“无数据”。
blank: 如果为True，字段在表单验证时可以为空。这与null不同，blank影响的是表单验证而非数据库存储。
choices: 一个由二元组组成的序列，用于定义字段的可选值。在表单和管理界面中，这些选项将显示为下拉列表。

4.2 关键方法
- to_python(self, value): 将存储在数据库中的值转换为Python类型。这个方法在从数据库读取数据时被调用，以及在通过表单或序列化过程对数据进行清洗时。
```
def to_python(self, value):
    if isinstance(value, MyDesiredType):
        return value
    return my_conversion_logic(value)
1
2
3
4
```
- get_prep_value(self, value): 在将数据保存到数据库之前，将Python类型的值转换为适合数据库存储的格式。这个方法通常与pre_save方法一起使用，以确保数据正确地保存到数据库。
```
def get_prep_value(self, value):
    return my_db_preparation(value)
1
2
```
- from_db_value(self, value, expression, connection): 用于从数据库类型转换为Python类型。这个方法在Django从数据库中读取数据时被调用。
```
def from_db_value(self, value, expression, connection):
    if value is None:
        return value
    return my_custom_transformation(value)
1
2
3
4
```
- pre_save(self, model_instance, add): 在模型保存到数据库之前被调用。这个方法允许开发者在数据被保存之前对其进行最后的处理或验证。
```
def pre_save(self, model_instance, add):
    value = getattr(model_instance, self.attname)
    return my_pre_save_process(value)
1
2
3
```
- formfield(self, kwargs): 将模型字段转换为表单字段。这个方法负责创建表单字段的实例，可以通过覆盖这个方法来自定义表单字段的行为。
```
def formfield(self, **kwargs):
    defaults = {'form_class': MyFormField}
    defaults.update(kwargs)
    return super().formfield(**defaults)
1
2
3
4
```
4.3 自定义字段的实现

在定义自定义字段时，通常需要重写上述方法之一或多个，以实现特定的数据转换逻辑或验证逻辑。

例如，如果你正在创建一个用于存储加密文本的自定义字段，你可能需要重写 to_python 和 get_prep_value 方法，以确保数据在保存到数据库之前被加密，在从数据库读取时被解密。通过深入理解 Field 类的属性和方法，开发者可以创建功能强大且灵活的自定义字段，满足特定应用的需求。这不仅增强了 Django 模型的功能，也使得数据处理和验证更加灵活和强大。

例如，如果你需要一个自定义字段来处理复杂的数据结构，如嵌套的字典或列表，你可能需要重写 to_python 方法来确保这些复杂数据在从数据库读取时能够被正确地转换为 Python 数据结构。同时，get_prep_value方法需要被重写以确保这些复杂数据在保存到数据库前能够被转换为数据库能够存储的格式，如 JSON 字符串。
```
from django.db import models
import json

class JSONField(models.TextField):
    """
    自定义字段，用于处理JSON数据。
    """
    def from_db_value(self, value, expression, connection):
        if value is None:
            return value
        return json.loads(value)

    def to_python(self, value):
        if isinstance(value, dict) or value is None:
            return value
        return json.loads(value)

    def get_prep_value(self, value):
        if value is None:
            return value
        return json.dumps(value)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
```
这段代码中，JSONField 是一个自定义模型字段，用于处理存储在数据库中的 JSON 数据。通过重写 from_db_value、to_python 和 get_prep_value 方法，该字段能够在 Python 字典和数据库中的 JSON 字符串之间自动转换数据。

5. 结论

在本文中，我们深入探讨了 Django 模型中字段与数据库的交互、字段与表单的交互以及字段的高级特性。通过了解数据库列映射、数据库值与 Python值的转换、字段查询与查找、字段属性与方法解析等方面的内容，我们能够更好地理解和利用 Django 模型中字段的功能和灵活性。

深入理解 Django 模型中字段的交互和特性，能够帮助开发者更好地设计和管理数据模型，提升应用的性能、灵活性和可维护性，从而为用户提供更好的使用体验。
相关阅读:
整形提升和算术转换
 【低代码】角色和权限的解决方案
 使用 Webmin+bind9快速搭建私有DNS服务器
 [含文档+PPT+源码等]精品基于SpringCloud实现的商品服务系统-微服务-分布式[包运行成功]
Centos7 安装 Nginx
8.系统研发中的领导意志
 赛特转债，华懋转债上市价格预测
 Nginx之反向代理讲解
 海量数据怎么处理？报表引擎得选对
 Qt浏览器模块的几点说明
原文地址：https://blog.csdn.net/qq_28550263/article/details/136383570