Django-Filter源码解析一

Django Filter源码解析

最近在看Django-FIlter项目的源码,学习一下别人的开发思想;

整体介绍

首先,我从其中一个测试用例作为入口,开始了debug之路,一点一点的断点,分析它的执行顺序,如图:

ok,下面从代码的层面进行分析:

  1. url

    url(r'^books/$', FilterView.as_view(model=Book)),

  2. view函数,这里的实现方式应该是借鉴了Django中自带的ListView,其同样的继承了MultipleObjectTemplateResponseMixin, BaseListView,继承的好处在于可以复用其已经封装好的方法,最终可以简单的实现展示,详情可以看

    class FilterView(MultipleObjectTemplateResponseMixin, BaseFilterView):
       """
      Render some list of objects with filter, set by `self.model` or
      `self.queryset`.
      `self.queryset` can actually be any iterable of items, not just a queryset.
      """
       template_name_suffix = '_filter'

  1. 基础过滤view,这里做的就是类似BaseListView的功能,获取计算出来的查询集,将结果渲染后返回;

    class BaseFilterView(FilterMixin, MultipleObjectMixin, View):
       """
      显示对象的过滤功能的基view,实现的方式类似BaseListView
      """
       def get(self, request, *args, **kwargs):
           # 获取过滤的类
           filterset_class = self.get_filterset_class()
           # 传入类,构造参数,返回类的对象
           self.filterset = self.get_filterset(filterset_class)

           # 重新赋值MultipleObjectMixin中的object_list
           if self.filterset.is_valid() or not self.get_strict():
               self.object_list = self.filterset.qs
           else:
               self.object_list = self.filterset.queryset.none()

           context = self.get_context_data(filter=self.filterset,
                                           object_list=self.object_list)
           return self.render_to_response(context)
  2. 接下来就分成三件事:a.获取过滤类,b.根据过滤类获取过滤对象,c.过滤,下面的代码就做到了前面两步;

    class FilterMixin(metaclass=FilterMixinRenames):
       """
      A mixin that provides a way to show and handle a FilterSet in a request.
      提供控制过滤的方法
      """

       def get_filterset_class(self):
           """
          Returns the filterset class to use in this view
          返回过滤类
          """
           if self.filterset_class:  # 避免重复创建
               return self.filterset_class
           elif self.model:
               # 使用了工厂模式
               return filterset_factory(model=self.model, fields=self.filterset_fields)
           else:
               msg = "'%s' must define 'filtserset_class' or 'model'"
               raise ImproperlyConfigured(msg % self.__class__.__name__)

       def get_filterset(self, filterset_class):
           """
          Returns an instance of the filterset to be used in this view.
          """
           kwargs = self.get_filterset_kwargs(filterset_class)
           return filterset_class(**kwargs)
       
    def filterset_factory(model, fields=ALL_FIELDS):
       # 根据model生成相对应的FilterSet,比如model是Book,那么就会生成BookFilterSet的实例
       meta = type(str('Meta'), (object,), {'model': model, 'fields': fields})
       # 使用type进行创建类,并且继承了FilterSet类
       filterset = type(str('%sFilterSet' % model._meta.object_name),
                        (FilterSet,), {'Meta': meta})
       return filterset
  3. 接下来就是重头戏,开始过滤了!下面会被调用是因为调用了FilterSet中的qs方法;

class BaseFilterSet(object):
   # ...
   def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
       # 如果没传进来则在全部的基础进行过滤
       if queryset is None:
           queryset = self._meta.model._default_manager.all()

       model = queryset.model
# ...
       self.filters = copy.deepcopy(self.base_filters)

       # propagate the model and filterset to the filters
       for filter_ in self.filters.values():
           filter_.model = model
           filter_.parent = self
   

def filter_queryset(self, queryset):
       """
      Filter the queryset with the underlying form's `cleaned_data`. You must
      call `is_valid()` or `errors` before calling this method.

      This method should be overridden if additional filtering needs to be
      applied to the queryset before it is cached.
      """
       for name, value in self.form.cleaned_data.items():
           # 重复执行,queryset会在每次执行后的queryset上继续执行,达到过滤的效果
           queryset = self.filters[name].filter(queryset, value)
           assert isinstance(queryset, models.QuerySet), \
               "Expected '%s.%s' to return a QuerySet, but got a %s instead." \
               % (type(self).__name__, name, type(queryset).__name__)
       return queryset

   @property
   def qs(self):
       if not hasattr(self, '_qs'):
           qs = self.queryset.all()
           if self.is_bound:
               # ensure form validation before filtering
               self.errors
               qs = self.filter_queryset(qs)
           self._qs = qs
       return self._qs

或许你会疑惑self.filtersself.base_filters)里面的内容是什么,其实就是每个需要过滤的数据库字段到具体的Filter的映射,那这个是哪里进行计算赋值的呢?其实是被元类给拦截了,下面则会把该的内容是从类的get_filters方法中获取得到的,

class FilterSet(BaseFilterSet, metaclass=FilterSetMetaclass):
   pass

class FilterSetMetaclass(type):
   # 元类,FilterSet创建时最终会创建FilterSetMetaclass的实例
   def __new__(cls, name, bases, attrs):
...
       
       new_class = super().__new__(cls, name, bases, attrs)
       new_class._meta = FilterSetOptions(getattr(new_class, 'Meta', None))
       new_class.base_filters = new_class.get_filters()  # 会被
       

class BaseFilterSet(object):
   # ...
   
@classmethod
   def get_filters(cls):
       """
      Get all filters for the filterset. This is the combination of declared and
      generated filters.
      获取到每个需要过滤的数据库字段到Filter的映射
      比如:{title: CharFilter}
      """

       # No model specified - skip filter generation
       if not cls._meta.model:
           return cls.declared_filters.copy()

       # Determine the filters that should be included on the filterset.
       filters = OrderedDict()
       fields = cls.get_fields()
       undefined = []

       for field_name, lookups in fields.items():
           field = get_model_field(cls._meta.model, field_name)

           # warn if the field doesn't exist.
           if field is None:
               undefined.append(field_name)

           for lookup_expr in lookups:
               filter_name = cls.get_filter_name(field_name, lookup_expr)

               # If the filter is explicitly declared on the class, skip generation
               if filter_name in cls.declared_filters:
                   filters[filter_name] = cls.declared_filters[filter_name]
                   continue

               if field is not None:
                   filters[filter_name] = cls.filter_for_field(field, field_name, lookup_expr)

       # filter out declared filters
       undefined = [f for f in undefined if f not in cls.declared_filters]
       if undefined:
           raise TypeError(
               "'Meta.fields' contains fields that are not defined on this FilterSet: "
               "%s" % ', '.join(undefined)
          )

       # Add in declared filters. This is necessary since we don't enforce adding
       # declared filters to the 'Meta.fields' option
       filters.update(cls.declared_filters)
       return filters
   
   @classmethod
   def filter_for_field(cls, field, field_name, lookup_expr='exact'):
       field, lookup_type = resolve_field(field, lookup_expr)

       default = {
           'field_name': field_name,
           'lookup_expr': lookup_expr,
      }

       filter_class, params = cls.filter_for_lookup(field, lookup_type)
       default.update(params)

       assert filter_class is not None, (
           "%s resolved field '%s' with '%s' lookup to an unrecognized field "
           "type %s. Try adding an override to 'Meta.filter_overrides'. See: "
           "https://django-filter.readthedocs.io/en/master/ref/filterset.html"
           "#customise-filter-generation-with-filter-overrides"
      ) % (cls.__name__, field_name, lookup_expr, field.__class__.__name__)

       return filter_class(**default)

   @classmethod
   def filter_for_lookup(cls, field, lookup_type):
       """
      过滤
      :param field:
      :param lookup_type:
      :return:
      """
       DEFAULTS = dict(cls.FILTER_DEFAULTS)
       if hasattr(cls, '_meta'):
           DEFAULTS.update(cls._meta.filter_overrides)

       data = try_dbfield(DEFAULTS.get, field.__class__) or {}
       filter_class = data.get('filter_class')
       params = data.get('extra', lambda field: {})(field)

       # if there is no filter class, exit early
       if not filter_class:
           return None, {}

       # perform lookup specific checks
       if lookup_type == 'exact' and getattr(field, 'choices', None):
           return ChoiceFilter, {'choices': field.choices}

       if lookup_type == 'isnull':
           data = try_dbfield(DEFAULTS.get, models.BooleanField)

           filter_class = data.get('filter_class')
           params = data.get('extra', lambda field: {})(field)
           return filter_class, params

       if lookup_type == 'in':
           class ConcreteInFilter(BaseInFilter, filter_class):
               pass
           ConcreteInFilter.__name__ = cls._csv_filter_class_name(
               filter_class, lookup_type
          )

           return ConcreteInFilter, params

       if lookup_type == 'range':
           class ConcreteRangeFilter(BaseRangeFilter, filter_class):
               pass
           ConcreteRangeFilter.__name__ = cls._csv_filter_class_name(
               filter_class, lookup_type
          )

           return ConcreteRangeFilter, params

       return filter_class, params

具体的数据库字段类型对应的Filter如下,上面也就是根据这些来找到对应的Filter,发现没,是BaseFilterSet类的FILTER_DEFAULTS变量

FILTER_FOR_DBFIELD_DEFAULTS = {
   models.AutoField:                   {'filter_class': NumberFilter},
   models.CharField:                   {'filter_class': CharFilter},
   models.TextField:                   {'filter_class': CharFilter},
   models.BooleanField:               {'filter_class': BooleanFilter},
   models.DateField:                   {'filter_class': DateFilter},
   models.DateTimeField:               {'filter_class': DateTimeFilter},
   models.TimeField:                   {'filter_class': TimeFilter},
   models.DurationField:               {'filter_class': DurationFilter},
   models.DecimalField:               {'filter_class': NumberFilter},
   models.SmallIntegerField:           {'filter_class': NumberFilter},
   models.IntegerField:               {'filter_class': NumberFilter},
   models.PositiveIntegerField:       {'filter_class': NumberFilter},
   models.PositiveSmallIntegerField:   {'filter_class': NumberFilter},
   models.FloatField:                 {'filter_class': NumberFilter},
   models.NullBooleanField:           {'filter_class': BooleanFilter},
   models.SlugField:                   {'filter_class': CharFilter},
   models.EmailField:                 {'filter_class': CharFilter},
   models.FilePathField:               {'filter_class': CharFilter},
   models.URLField:                   {'filter_class': CharFilter},
   models.GenericIPAddressField:       {'filter_class': CharFilter},
   models.CommaSeparatedIntegerField: {'filter_class': CharFilter},
   models.UUIDField:                   {'filter_class': UUIDFilter},

   # Forward relationships
   models.OneToOneField: {
       'filter_class': ModelChoiceFilter,
       'extra': lambda f: {
           'queryset': remote_queryset(f),
           'to_field_name': f.remote_field.field_name,
           'null_label': settings.NULL_CHOICE_LABEL if f.null else None,
      }
  },
   models.ForeignKey: {
       'filter_class': ModelChoiceFilter,
       'extra': lambda f: {
           'queryset': remote_queryset(f),
           'to_field_name': f.remote_field.field_name,
           'null_label': settings.NULL_CHOICE_LABEL if f.null else None,
      }
  },
   models.ManyToManyField: {
       'filter_class': ModelMultipleChoiceFilter,
       'extra': lambda f: {
           'queryset': remote_queryset(f),
      }
  },

   # Reverse relationships
   OneToOneRel: {
       'filter_class': ModelChoiceFilter,
       'extra': lambda f: {
           'queryset': remote_queryset(f),
           'null_label': settings.NULL_CHOICE_LABEL if f.null else None,
      }
  },
   ManyToOneRel: {
       'filter_class': ModelMultipleChoiceFilter,
       'extra': lambda f: {
           'queryset': remote_queryset(f),
      }
  },
   ManyToManyRel: {
       'filter_class': ModelMultipleChoiceFilter,
       'extra': lambda f: {
           'queryset': remote_queryset(f),
      }
  },
}

ok,到这里就简单的介绍完毕了。

posted @ 2018-10-03 02:48  banananana  阅读(...)  评论(... 编辑 收藏