Question

我一直在尝试使用Django的基于类的视图，我正在尝试编写一个简单的基于类的视图来处理request中的某些信息，以便“处理程序”方法可以使用已处理的信息。

我似乎并没有完全理解文档所说的内容，也不确定这应该是Mixin，泛型视图还是其他内容。我正在考虑建立一个这样的课程：

class MyNewGenericView(View):

    redirect_on_error = 'home'
    error_message = 'There was an error doing XYZ'

    def dispatch(self, request, *args, **kwargs):
        try:
            self.process_information(request)
            # self.process_information2(request)
            # self.process_information3(request)
            # etc...
        except ValueError:
            messages.error(request, self.error_message)
            return redirect(self.redirect_on_error)
        return super(MyNewGenericView, self).dispatch(request, *args, **kwargs)

    def process_information(self, request):
        # Use get/post information and process it using
        # different models, APIs, etc.
        self.useful_information1 = 'abc'
        self.useful_information2 = 'xyz'

    def get_extra_info(self):
        # Get some extra information on something
        return {'foo':'bar'}

这将允许某人编写如下视图：

class MyViewDoesRealWork(MyNewGenericView):
    def get(self, request, some_info):
        return render(request, 'some_template.html',
            {'info':self.useful_information1})

    def post(self, request, some_info):
        # Store some information, maybe using get_extra_info
        return render(request, 'some_template.html',
            {'info':self.useful_information1})

以上代码是正确的方法吗？有没有更简单/更好的方法呢？这是否会阻止上述功能在另一个通用视图中使用（例如内置的通用视图）？

Answer 1

看看这个。很棒的示例代码。 http://www.stereoplex.com/blog/get-and-post-handling-in-django-views

Answer 2

我似乎只是问了一个愚蠢的问题。

这可以通过创建一个处理该信息的类来轻松实现：

class ProcessFooInformation(object):
    def __init__(self, request):
        self.request = request
    @property
    def bar(self):
        baz = self.request.GET.get('baz', '')
        # do something cool to baz and store it in foobar
        return foobar
    # etc...

然后使用旧式函数视图或新的基于类的视图：

def my_view(request):
    foo = ProcessFooInformation(request)
    # use foo in whatever way and return a response
    return render(request, 'foobar.html', {'foo':foo})

我还通过使用属性的惰性评估来提高效率。

我改编了lazy property evaluation recipe和评论中的想法来编写包装器：

def lazy_prop(func):
    def wrap(self, *args, **kwargs):
        if not func.__name__ in self.__dict__:
            self.__dict__[func.__name__] = func(self, *args, **kwargs)
        return self.__dict__[func.__name__]
    return property(wrap)

这仅为每个实例计算一次包装方法的值，并在后续调用中使用存储值。如果属性评估缓慢，这很有用。

使用基于类的视图来处理信息？

2 个答案: