登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›Django 懒加载实现方法

Django 懒加载实现方法

处匈跑 2025-8-18 09:48:32
Django 懒加载实现方法

在Django中，我们都知道当我们all之后是不会马上去查询数据的，当我们真正使用的时候，才会去触发查询操作。
模型类

下面我将带着大家从源码的角度一步一步解析。
  1. from django.db import models
  4. # Create your models here.
  5. class Demo1(models.Model):
  6.     name = models.CharField(max_length=100)
  7.     age = models.IntegerField()
  9.     def __str__(self):
  10.         return self.name
复制代码
看一下这几行代码发生了什么
使用是继承了models.Model。去看一下models.Model做了什么
  1. # models.Model
  2. class Model(AltersData, metaclass=ModelBase):
  3.     pass
复制代码
可以看到把ModelBase当成了元类，那我们就去再看一下ModelBase
  1. class ModelBase(type):
  2.     """Metaclass for all models."""
  4.     def __new__(cls, name, bases, attrs, **kwargs):
  5.         super_new = super().__new__
  7.         # Also ensure initialization is only performed for subclasses of Model
  8.         # (excluding Model class itself).
  9.         parents = [b for b in bases if isinstance(b, ModelBase)]
  10.         if not parents:
  11.             return super_new(cls, name, bases, attrs)
  13.         # Create the class.
  14.         module = attrs.pop("__module__")
  15.         new_attrs = {"__module__": module}
  16.         classcell = attrs.pop("__classcell__", None)
  17.         if classcell is not None:
  18.             new_attrs["__classcell__"] = classcell
  19.         attr_meta = attrs.pop("Meta", None)
  20.         # Pass all attrs without a (Django-specific) contribute_to_class()
  21.         # method to type.__new__() so that they're properly initialized
  22.         # (i.e. __set_name__()).
  23.         contributable_attrs = {}
  24.         for obj_name, obj in attrs.items():
  25.             if _has_contribute_to_class(obj):
  26.                 contributable_attrs[obj_name] = obj
  27.             else:
  28.                 new_attrs[obj_name] = obj
  29.         new_class = super_new(cls, name, bases, new_attrs, **kwargs)
  31.         abstract = getattr(attr_meta, "abstract", False)
  32.         meta = attr_meta or getattr(new_class, "Meta", None)
  33.         base_meta = getattr(new_class, "_meta", None)
  35.         app_label = None
  37.         # Look for an application configuration to attach the model to.
  38.         app_config = apps.get_containing_app_config(module)
  40.         if getattr(meta, "app_label", None) is None:
  41.             if app_config is None:
  42.                 if not abstract:
  43.                     raise RuntimeError(
  44.                         "Model class %s.%s doesn't declare an explicit "
  45.                         "app_label and isn't in an application in "
  46.                         "INSTALLED_APPS." % (module, name)
  47.                     )
  49.             else:
  50.                 app_label = app_config.label
  52.         new_class.add_to_class("_meta", Options(meta, app_label))
  53.         if not abstract:
  54.             new_class.add_to_class(
  55.                 "DoesNotExist",
  56.                 subclass_exception(
  57.                     "DoesNotExist",
  58.                     tuple(
  59.                         x.DoesNotExist
  60.                         for x in parents
  61.                         if hasattr(x, "_meta") and not x._meta.abstract
  62.                     )
  63.                     or (ObjectDoesNotExist,),
  64.                     module,
  65.                     attached_to=new_class,
  66.                 ),
  67.             )
  68.             new_class.add_to_class(
  69.                 "MultipleObjectsReturned",
  70.                 subclass_exception(
  71.                     "MultipleObjectsReturned",
  72.                     tuple(
  73.                         x.MultipleObjectsReturned
  74.                         for x in parents
  75.                         if hasattr(x, "_meta") and not x._meta.abstract
  76.                     )
  77.                     or (MultipleObjectsReturned,),
  78.                     module,
  79.                     attached_to=new_class,
  80.                 ),
  81.             )
  82.             if base_meta and not base_meta.abstract:
  83.                 # Non-abstract child classes inherit some attributes from their
  84.                 # non-abstract parent (unless an ABC comes before it in the
  85.                 # method resolution order).
  86.                 if not hasattr(meta, "ordering"):
  87.                     new_class._meta.ordering = base_meta.ordering
  88.                 if not hasattr(meta, "get_latest_by"):
  89.                     new_class._meta.get_latest_by = base_meta.get_latest_by
  91.         is_proxy = new_class._meta.proxy
  93.         # If the model is a proxy, ensure that the base class
  94.         # hasn't been swapped out.
  95.         if is_proxy and base_meta and base_meta.swapped:
  96.             raise TypeError(
  97.                 "%s cannot proxy the swapped model '%s'." % (name, base_meta.swapped)
  98.             )
  100.         # Add remaining attributes (those with a contribute_to_class() method)
  101.         # to the class.
  102.         for obj_name, obj in contributable_attrs.items():
  103.             new_class.add_to_class(obj_name, obj)
  105.         # All the fields of any type declared on this model
  106.         new_fields = chain(
  107.             new_class._meta.local_fields,
  108.             new_class._meta.local_many_to_many,
  109.             new_class._meta.private_fields,
  110.         )
  111.         field_names = {f.name for f in new_fields}
  113.         # Basic setup for proxy models.
  114.         if is_proxy:
  115.             base = None
  116.             for parent in [kls for kls in parents if hasattr(kls, "_meta")]:
  117.                 if parent._meta.abstract:
  118.                     if parent._meta.fields:
  119.                         raise TypeError(
  120.                             "Abstract base class containing model fields not "
  121.                             "permitted for proxy model '%s'." % name
  122.                         )
  123.                     else:
  124.                         continue
  125.                 if base is None:
  126.                     base = parent
  127.                 elif parent._meta.concrete_model is not base._meta.concrete_model:
  128.                     raise TypeError(
  129.                         "Proxy model '%s' has more than one non-abstract model base "
  130.                         "class." % name
  131.                     )
  132.             if base is None:
  133.                 raise TypeError(
  134.                     "Proxy model '%s' has no non-abstract model base class." % name
  135.                 )
  136.             new_class._meta.setup_proxy(base)
  137.             new_class._meta.concrete_model = base._meta.concrete_model
  138.         else:
  139.             new_class._meta.concrete_model = new_class
  141.         # Collect the parent links for multi-table inheritance.
  142.         parent_links = {}
  143.         for base in reversed([new_class] + parents):
  144.             # Conceptually equivalent to `if base is Model`.
  145.             if not hasattr(base, "_meta"):
  146.                 continue
  147.             # Skip concrete parent classes.
  148.             if base != new_class and not base._meta.abstract:
  149.                 continue
  150.             # Locate OneToOneField instances.
  151.             for field in base._meta.local_fields:
  152.                 if isinstance(field, OneToOneField) and field.remote_field.parent_link:
  153.                     related = resolve_relation(new_class, field.remote_field.model)
  154.                     parent_links[make_model_tuple(related)] = field
  156.         # Track fields inherited from base models.
  157.         inherited_attributes = set()
  158.         # Do the appropriate setup for any model parents.
  159.         for base in new_class.mro():
  160.             if base not in parents or not hasattr(base, "_meta"):
  161.                 # Things without _meta aren't functional models, so they're
  162.                 # uninteresting parents.
  163.                 inherited_attributes.update(base.__dict__)
  164.                 continue
  166.             parent_fields = base._meta.local_fields + base._meta.local_many_to_many
  167.             if not base._meta.abstract:
  168.                 # Check for clashes between locally declared fields and those
  169.                 # on the base classes.
  170.                 for field in parent_fields:
  171.                     if field.name in field_names:
  172.                         raise FieldError(
  173.                             "Local field %r in class %r clashes with field of "
  174.                             "the same name from base class %r."
  175.                             % (
  176.                                 field.name,
  177.                                 name,
  178.                                 base.__name__,
  179.                             )
  180.                         )
  181.                     else:
  182.                         inherited_attributes.add(field.name)
  184.                 # Concrete classes...
  185.                 base = base._meta.concrete_model
  186.                 base_key = make_model_tuple(base)
  187.                 if base_key in parent_links:
  188.                     field = parent_links[base_key]
  189.                 elif not is_proxy:
  190.                     attr_name = "%s_ptr" % base._meta.model_name
  191.                     field = OneToOneField(
  192.                         base,
  193.                         on_delete=CASCADE,
  194.                         name=attr_name,
  195.                         auto_created=True,
  196.                         parent_link=True,
  197.                     )
  199.                     if attr_name in field_names:
  200.                         raise FieldError(
  201.                             "Auto-generated field '%s' in class %r for "
  202.                             "parent_link to base class %r clashes with "
  203.                             "declared field of the same name."
  204.                             % (
  205.                                 attr_name,
  206.                                 name,
  207.                                 base.__name__,
  208.                             )
  209.                         )
  211.                     # Only add the ptr field if it's not already present;
  212.                     # e.g. migrations will already have it specified
  213.                     if not hasattr(new_class, attr_name):
  214.                         new_class.add_to_class(attr_name, field)
  215.                 else:
  216.                     field = None
  217.                 new_class._meta.parents[base] = field
  218.             else:
  219.                 base_parents = base._meta.parents.copy()
  221.                 # Add fields from abstract base class if it wasn't overridden.
  222.                 for field in parent_fields:
  223.                     if (
  224.                         field.name not in field_names
  225.                         and field.name not in new_class.__dict__
  226.                         and field.name not in inherited_attributes
  227.                     ):
  228.                         new_field = copy.deepcopy(field)
  229.                         new_class.add_to_class(field.name, new_field)
  230.                         # Replace parent links defined on this base by the new
  231.                         # field. It will be appropriately resolved if required.
  232.                         if field.one_to_one:
  233.                             for parent, parent_link in base_parents.items():
  234.                                 if field == parent_link:
  235.                                     base_parents[parent] = new_field
  237.                 # Pass any non-abstract parent classes onto child.
  238.                 new_class._meta.parents.update(base_parents)
  240.             # Inherit private fields (like GenericForeignKey) from the parent
  241.             # class
  242.             for field in base._meta.private_fields:
  243.                 if field.name in field_names:
  244.                     if not base._meta.abstract:
  245.                         raise FieldError(
  246.                             "Local field %r in class %r clashes with field of "
  247.                             "the same name from base class %r."
  248.                             % (
  249.                                 field.name,
  250.                                 name,
  251.                                 base.__name__,
  252.                             )
  253.                         )
  254.                 else:
  255.                     field = copy.deepcopy(field)
  256.                     if not base._meta.abstract:
  257.                         field.mti_inherited = True
  258.                     new_class.add_to_class(field.name, field)
  260.         # Copy indexes so that index names are unique when models extend an
  261.         # abstract model.
  262.         new_class._meta.indexes = [
  263.             copy.deepcopy(idx) for idx in new_class._meta.indexes
  264.         ]
  266.         if abstract:
  267.             # Abstract base models can't be instantiated and don't appear in
  268.             # the list of models for an app. We do the final setup for them a
  269.             # little differently from normal models.
  270.             attr_meta.abstract = False
  271.             new_class.Meta = attr_meta
  272.             return new_class
  274.         new_class._prepare()
  275.         new_class._meta.apps.register_model(new_class._meta.app_label, new_class)
  276.         return new_class
  277.       
  278.     def _prepare(cls):
  279.         """Create some methods once self._meta has been populated."""
  280.         opts = cls._meta
  281.         opts._prepare(cls)
  283.         if opts.order_with_respect_to:
  284.             cls.get_next_in_order = partialmethod(
  285.                 cls._get_next_or_previous_in_order, is_next=True
  286.             )
  287.             cls.get_previous_in_order = partialmethod(
  288.                 cls._get_next_or_previous_in_order, is_next=False
  289.             )
  291.             # Defer creating accessors on the foreign class until it has been
  292.             # created and registered. If remote_field is None, we're ordering
  293.             # with respect to a GenericForeignKey and don't know what the
  294.             # foreign class is - we'll add those accessors later in
  295.             # contribute_to_class().
  296.             if opts.order_with_respect_to.remote_field:
  297.                 wrt = opts.order_with_respect_to
  298.                 remote = wrt.remote_field.model
  299.                 lazy_related_operation(make_foreign_order_accessors, cls, remote)
  301.         # Give the class a docstring -- its definition.
  302.         if cls.__doc__ is None:
  303.             cls.__doc__ = "%s(%s)" % (
  304.                 cls.__name__,
  305.                 ", ".join(f.name for f in opts.fields),
  306.             )
  308.         get_absolute_url_override = settings.ABSOLUTE_URL_OVERRIDES.get(
  309.             opts.label_lower
  310.         )
  311.         if get_absolute_url_override:
  312.             setattr(cls, "get_absolute_url", get_absolute_url_override)
  314.         if not opts.managers:
  315.             if any(f.name == "objects" for f in opts.fields):
  316.                 raise ValueError(
  317.                     "Model %s must specify a custom Manager, because it has a "
  318.                     "field named 'objects'." % cls.__name__
  319.                 )
  320.             manager = Manager()
  321.             manager.auto_created = True
  322.             cls.add_to_class("objects", manager)
  324.         # Set the name of _meta.indexes. This can't be done in
  325.         # Options.contribute_to_class() because fields haven't been added to
  326.         # the model at that point.
  327.         for index in cls._meta.indexes:
  328.             if not index.name:
  329.                 index.set_name_with_model(cls)
  331.         class_prepared.send(sender=cls)
复制代码
可以看到在_prepare这个方法里面判断了一下有没有managers。如果没有的话就会去创建一个Manager类。并设置给当前对象的objects类。我们去看一下Managr类
  1. class Manager(BaseManager.from_queryset(QuerySet)):
  2.       def get_queryset(self):
  3.         """
  4.         Return a new QuerySet object. Subclasses can override this method to
  5.         customize the behavior of the Manager.
  6.         """
  7.         return self._queryset_class(model=self.model, using=self._db, hints=self._hints)
  9.     def all(self):
  10.         # We can't proxy this method through the `QuerySet` like we do for the
  11.         # rest of the `QuerySet` methods. This is because `QuerySet.all()`
  12.         # works by creating a "copy" of the current queryset and in making said
  13.         # copy, all the cached `prefetch_related` lookups are lost. See the
  14.         # implementation of `RelatedManager.get_queryset()` for a better
  15.         # understanding of how this comes into play.
  16.         return self.get_queryset()
复制代码
可以看到这里是继承了BaseManager.from_queryset(QuerySet)。那继续看BaseManager.from_queryset(QuerySet)方法
  1.   class BaseManager:  
  2.           @classmethod
  3.     def from_queryset(cls, queryset_class, class_name=None):
  4.         if class_name is None:
  5.             class_name = "%sFrom%s" % (cls.__name__, queryset_class.__name__)
  6.         return type(
  7.             class_name,
  8.             (cls,),
  9.             {
  10.                 "_queryset_class": queryset_class,
  11.                 **cls._get_queryset_methods(queryset_class),
  12.             },
  13.         )
复制代码
可以看到是使用type创建了类，然后继承了当前类，最后定义了一个_queryset_class方法。并把传入的queryset_class(QuerySet)设置成了_queryset_class属性的值。
  1. class QuerySet(AltersData):
  2.     """Represent a lazy database lookup for a set of objects."""
  4.     def __init__(self, model=None, query=None, using=None, hints=None):
  5.         self.model = model
  6.         self._db = using
  7.         self._hints = hints or {}
  8.         self._query = query or sql.Query(self.model)
  9.         self._result_cache = None
  10.         self._sticky_filter = False
  11.         self._for_write = False
  12.         self._prefetch_related_lookups = ()
  13.         self._prefetch_done = False
  14.         self._known_related_objects = {}  # {rel_field: {pk: rel_obj}}
  15.         self._iterable_class = ModelIterable
  16.         self._fields = None
  17.         self._defer_next_filter = False
  18.         self._deferred_filter = None
  19.         
  20.       def __iter__(self):
  21.         """
  22.         The queryset iterator protocol uses three nested iterators in the
  23.         default case:
  24.             1. sql.compiler.execute_sql()
  25.                - Returns 100 rows at time (constants.GET_ITERATOR_CHUNK_SIZE)
  26.                  using cursor.fetchmany(). This part is responsible for
  27.                  doing some column masking, and returning the rows in chunks.
  28.             2. sql.compiler.results_iter()
  29.                - Returns one row at time. At this point the rows are still just
  30.                  tuples. In some cases the return values are converted to
  31.                  Python values at this location.
  32.             3. self.iterator()
  33.                - Responsible for turning the rows into model objects.
  34.         """
  35.         self._fetch_all()
  36.         return iter(self._result_cache)
  37.       
  38.       
  39.     def _fetch_all(self):
  40.         if self._result_cache is None:
  41.             self._result_cache = list(self._iterable_class(self))
  42.         if self._prefetch_related_lookups and not self._prefetch_done:
  43.             self._prefetch_related_objects()
复制代码
开始查询
  1. Demo1.objects.all()
  2. [test_model for test_model in demos]
复制代码
看一下这几行代码发生了什么。
DemoModes.objects 返回的就是上面的Manager。然后调用了Manager的all。然后在all里面返回了了_queryset_class。由上面我们可以知道queryset_class是传入的QuerySet。
查询生命周期
flowchart TDmodel[Demo] --> objects[objects] -- Manager --> all --> get_queryset[返回了QuerySet]这里现在返回了QuerySet，但是实际上没有和数据库交互呢。真正和数据库交互是在[test_model for test_model in demos]这里。
当开始遍历demos的时候会触发__iter__方法，然后在这个魔法函数里面会触发__fetch_all【和数据交互】方法，并返回一个一个迭代对象
查询生命周期
flowchart TDfor[循环] --> iter[_\_iter\_\_] --> _fetch_all --数据库交互--> 返回结果
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
处匈跑
2025-8-18 09:48:32

0

粉丝关注

9

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫