TemplateResponse and SimpleTemplateResponse

However, it can sometimes be beneficial to allow decorators ormiddleware to modify a response after it has been constructed by theview. For example, you may want to change the template that is used,or put additional data into the context.

TemplateResponse provides a way to do just that. Unlike basicHttpResponse objects, TemplateResponse objects retainthe details of the template and context that was provided by the view tocompute the response. The final output of the response is not computed untilit is needed, later in the response process.

• class SimpleTemplateResponse

• SimpleTemplateResponse.template_name
• The name of the template to be rendered. Accepts a backend-dependenttemplate object (such as those returned byget_template()), the name of a template,or a list of template names.

Example: ['foo.html', 'path/to/bar.html']

• SimpleTemplateResponse.context_data
• The context data to be used when rendering the template. It must be adict.

Example: {'foo': 123}

• SimpleTemplateResponse.rendered_content

• The current rendered value of the response content, using the currenttemplate and context data.

• SimpleTemplateResponse.is_rendered

• A boolean indicating whether the response content has been rendered.

• SimpleTemplateResponse.init(template, context=None, content_type=None, status=None, charset=None, using=None)
• SimpleTemplateResponse.resolvecontext(_context)
• Preprocesses context data that will be used for rendering a template.Accepts a of context data. By default, returns the samedict.

Override this method in order to customize the context.

• SimpleTemplateResponse.resolvetemplate(_template)
• Resolves the template instance to use for rendering. Accepts abackend-dependent template object (such as those returned by), the name of a template,or a list of template names.

Override this method in order to customize template loading.

• SimpleTemplateResponse.add_post_render_callback()[源代码]
• Add a callback that will be invoked after rendering has takenplace. This hook can be used to defer certain processingoperations (such as caching) until after rendering has occurred.

If the SimpleTemplateResponsehas already been rendered, the callback will be invokedimmediately.

When called, callbacks will be passed a single argument — therendered instance.

If the callback returns a value that is not None, this will beused as the response instead of the original response object (andwill be passed to the next post rendering callback etc.)

• SimpleTemplateResponse.render()[源代码]

render() will only have an effect the first time it is called. Onsubsequent calls, it will return the result obtained from the first call.

• class TemplateResponse[源代码]
• TemplateResponse is a subclass ofSimpleTemplateResponse that knows aboutthe current .

• TemplateResponse.init(request, template, context=None, content_type=None, status=None, charset=None, using=None)[源代码]

• Instantiates a TemplateResponse objectwith the given request, template, context, content type, HTTP status, andcharset.

  • request
  • An instance.
  • A backend-dependent template object (such as those returned byget_template()), the name of a template,or a list of template names.
  • context
  • A of values to add to the template context. By default,this is an empty dictionary.
  • content_type
  • The value included in the HTTP Content-Type header, including theMIME type specification and the character set encoding. Ifcontent_type is specified, then its value is used. Otherwise,DEFAULT_CONTENT_TYPE is used.
  • status
  • The HTTP status code for the response.
  • charset
  • The charset in which the response will be encoded. If not given it willbe extracted from content_type, and if that is unsuccessful, the setting will be used.
  • using
  • The NAME of a template engine to use forloading the template.

Before a instance can bereturned to the client, it must be rendered. The rendering process takes theintermediate representation of template and context, and turns it into thefinal byte stream that can be served to the client.

There are three circumstances under which a TemplateResponse will berendered:

• When the TemplateResponse instance is explicitly rendered, usingthe SimpleTemplateResponse.render() method.
• After passing through template response middleware, but beforepassing through response middleware.
  A TemplateResponse can only be rendered once. The first call to sets the content of the response;subsequent rendering calls do not change the response content.

Some operations — such as caching — cannot be performed on anunrendered template. They must be performed on a fully complete andrendered response.

If you're using middleware, the solution is easy. Middleware providesmultiple opportunities to process a response on exit from a view. Ifyou put behavior in the response middleware, it's guaranteed to executeafter template rendering has taken place.

However, if you're using a decorator, the same opportunities do notexist. Any behavior defined in a decorator is handled immediately.

To compensate for this (and any other analogous use cases),TemplateResponse allows you to register callbacks that willbe invoked when rendering has completed. Using this callback, you candefer critical processing until a point where you can guarantee thatrendered content will be available.

To define a post-render callback, just define a function that takesa single argument — response — and register that function withthe template response:

my_render_callback() will be invoked after the mytemplate.htmlhas been rendered, and will be provided the fully rendered instance as an argument.

If the template has already been rendered, the callback will beinvoked immediately.

A TemplateResponse object can be used anywhere that a normal can be used. It can also be used as analternative to calling render().