Django RequestContext

　　context在Django里表现为Context类，在django.template模块里。它的构造函数带有一个可选的参数：一个字典映射变量和它们的值。调用Template对象的render()方法并传递context来填充模板。

　　RequestContext在初始化的时候比Context多带了一个参数request，查阅源码可以知道request是为context processor准备的。

（１） 模版中的变量由context中的值来替换，如果在多个页面模版中含有相同的变量，比如：每个页面都需要{{user}}，笨办法就是在每个页面的请求视图中都把user放到context中。

from django.temlate import loader,Context

t = loader.get_template('xx.html')
c = Context({'user':'zhangsan'})
return HttpResponse(t.render(c))   #httpresponse

也可简写为：

from django.short_cuts import render_to_response
render_to_response('xxx.html',{'user':'zhangsan'})

缺点： 代码的冗余，不易维护

（２）可以用Context的一个子类：django.template.RequestContext，在渲染模版的时候就不需要Context，转而使用RequestContext。RequestConntext需要接受request和processors参数，processors是context处理器的列表集合。

from django.template import RquestContext
def custom_pros(request):   #context处理器
     return {'age':22,'user':request.user}

#view 代码块
c = RequestContext(request,{'name':'zhang'},processors=[custom_pros])
return HttpResponse(t.render(c))  

这样在每个试图中只需把custom_pros传递给RequestContext的参数processors就行了。如果是render_to_response与RequestContext结合使用，那么render_to_response接收参数context_instance。

缺点：仍然有冗余，必须在视图函数中明确指定context处理器

例子二：

def view_1(request):
    # ...
    t = loader.get_template('template1.html')
    c = Context({
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR'],
        'message': 'I am view 1.'
    })
    return t.render(c)
     
def view_2(request):
    # ...
    t = loader.get_template('template2.html')
    c = Context({
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR'],
        'message': 'I am the second view.'
    })
return t.render(c)

在view_1和view_2中，每个视图都给模板传入了三个相同的变量：app、user和ip_address，这显然增加了代码的冗余度，这时RequestContext就派上用场了，它是一个Context的子类。当在一系例模板中都需要明确指定一些相同的变量时，RequestContext就可以帮你省去多次硬编码的麻烦。以上代码可以变为如下形式：

def custom_proc(request):
    "A context processor that provides 'app', 'user' and 'ip_address'."
    return {
        'app': 'My app',
        'user': request.user,
        'ip_address': request.META['REMOTE_ADDR']
    }
def view_1(request):
    # ...
    t = loader.get_template('template1.html')
    c = RequestContext(request, {'message': 'I am view 1.'},
        processors=[custom_proc])
    return t.render(c)
     
def view_2(request):
    # ...
    t = loader.get_template('template2.html')
    c = RequestContext(request, {'message': 'I am the second view.'},
        processors=[custom_proc])
    return t.render(c)

若使用r ender_to_response，render_to_string等shortcut的时候，可以附带context_instance参数来使用RequestContext：

 def some_view(request): 
# ... return render_to_response('my_template.html',
 my_data_dictionary, context_instance=RequestContext(request))

或者

def view(request):
    #...
    return render_to_response('template1.html',
        {'message':'I am the view.'},
        context_instance=RequestContext(request,processors=[custom_proc]))

（３）全局context处理器

　　默认情况下，Django采用参数 TEMPLATE_CONTEXT_PROCESSORS指定默认处理器，意味着只要是调用的RequestContext，那么默认处理器中返回的对象都就将存储在context中。

　　从RequestContext的构造函数可以看出，我们可以通过processors参数传递context processor，这样我们可以灵活使用context processor。如果希望作用于所有的view，那么则可以在settings的TEMPLATE_CONTEXT_PROCESSORS设置，如果希望作用于特定的view，则可以在初始化一个RequestContext的时候，赋值给processors。同时，该参数是可选的，是一个包含context处理器参数的列表或者元组。　  

　　template_context_processors默认在settings文件中是没有的，而是设置在global_settings.py文件中，如果想加上自己的context处理器，就必须在自己的settings.py中显示的指出参数：TEMPLATE_CONTEXT_PROCESSORS

默认：

TEMPLATE_CONTEXT_PROCESSORS = (<pre name="code" class="python">render_to_response('xxx.html',{'age':33},context_instance=RequestContext(request))

'django.contrib.auth.context_processors.auth',#django1.4 or after 'django.core.context_processors.auth', #django1.4 before 'django.core.context_processors.debug', 'django.core.context_processors.i18n', 'django.core.context_processors.media', 'myapp.processor.foos',)

或者这样添加：

from django.conf import global_settings
TEMPLATE_CONTEXT_PROCESSORS = global_settings.TEMPLATE_CONTEXT_PROCESSORS +("myapp.processor.foos",)

此时，在视图中只要把request参数传递给RquestContext就ok了。

# ...
    return render_to_response('template.html', particular_data_dictionary,
        context_instance=RequestContext(request))

render_to_response('xxx.html',{'name':'zhang'},context_instance=RequestContext(request,processors[custom_pros])

系统在接受到该视图的请求时，自动执行处理器 “myapp.processor.foos"，并把其返回值渲染到模版中