Django-Filter源码解析一

Posted 2021-01-10 george1994

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‘

3. 基础过滤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)

4. 接下来就分成三件事：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

5. 接下来就是重头戏，开始过滤了！下面会被调用是因为调用了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.filters（self.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，到这里就简单的介绍完毕了。