上下文处理器及中间件

上下文处理器

　　返回一些数据，在全局模板中都可以使用。如登录后的用户信息，在很多页面中都需要使用，可将其放在上下文处理器中，避免在每个视图函数中重复返回这个对象。

在 settings.TEMPLATES.OPTIONS.context_processors 中各个处理器的作用：

• django.template.context_processors.debug：增加一个debug和sql_queries变量。在模板中可以通过他来查看到一些数据库查询。
• django.template.context_processors.request：增加一个request变量。这个request变量也就是在视图函数的第一个参数。
• django.contrib.auth.context_processors.auth：Django有内置的用户系统，这个上下文处理器会增加一个user对象。
• django.contrib.messages.context_processors.messages：增加一个messages变量。
• django.template.context_processors.media：在模板中可以读取 MEDIA_URL 。比如想要在模板中使用上传的文件，那么这时候就需要使用settings.py中设置的 MEDIA_URL 来拼接url。示例代码如下： <img src="" /> 
• django.template.context_processors.static：在模板中可以使用STATIC_URL。
• django.template.context_processors.csrf：在模板中可以使用 csrf_token 变量来生成一个 csrf token 。

 messages 处理器：

# forms.py
# 上下文处理器messages，来为模板渲染出错误信息，如登录时提示的‘用户或密码错误’。可定义级别
class Get_error(forms.ModelForm):
    def get_error(self):
        new_errors = []
        errors = self.errors.get_json_data()
        for messages in errors.values():
            for message_dict in messages:
                for key,message in message_dict.items():
                    if key == 'message':
                        new_errors.append(message)
        return new_errors

class SigninForm(Get_error):
    --snip--

# views.py
# 登录页面
class SigninView(View):
    def get(self,request):
        return render(request,'signin.html')

    def post(self,request):
        form = SigninForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data.get('username')
            password = form.cleaned_data.get('password')
            # 验证通过时，保存session信息；将存入数据库的user.id等于session中的user_id的值。
            user = User.objects.filter(username=username,password=password).first()
            if user:
                request.session['user_id'] = user.id
                return redirect(reverse('index'))
            else:
                print('用户名或密码错误')
                # 设置信息的等级及提醒的内容
                # messages.add_message(request,messages.INFO,'用户名或密码错误！')
                messages.info(request,"用户名或密码错误！")
                return redirect(reverse('signin'))
        else:
            # errors = form.errors.get_json_data()
            errors = form.get_error()
            for error in errors:
                messages.info(request,error)
            print(form.get_error())
            return redirect((reverse('signin')))

HTML模板：

<!--signin.html登录模板-->
<!--snip-->
<td>
    <!--渲染出错信息，级别为‘info’时显示红色-->
    {% for message in messages %}
         {% if message.tags == 'info' %}
             <li style="color: red">{{ message }}</li>
         {% endif %}
    {% endfor %}
</td>

自定义上下文处理器：

　　根据这个上下文处理器是属于哪个app，然后在这个app中创建一个文件专门用来存储上下文处理器。比如 context_processors.py 。或者是你也可以专门创建一个Python包，用来存储所有的上下文处理器。
　　上下文处理器文件中，定义一个函数，这个函数只有一个 request 参数。这个函数中处理完自己的逻辑后，把需要返回给模板的数据，通过字典的形式返回。如果不需要返回任何数据，那么也必须返回一个空的字典。

添加处理器：

# settings.py
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                # 添加上下文处理器；
                'front.context_processors.front_user'
            ],
        },
    },
]

判断是否有用户数据存在：

# context_processors.py
from .models import User

def front_user(request):
    user_id = request.session.get('user_id')
    context = {}
    if user_id:
        try:
            user = User.objects.get(pk=user_id)
            context['front_user'] = user
        except:
            pass
    return context

HTML模板：

<!--base.html主模板-->>
<!--snip-->
<!--判断该网站是否已存在登录的账户，存在时不再显示登录页面-->
{% if front_user %}
    <li><a href="">{{ front_user.username }}</a></li>
{% else %}
    <li><a href="{% url 'signin' %}">登录</a></li>
    <li><a href="{% url 'signup' %}">注册</a></li>
{% endif %}

中间件

　　是在 request 和 response 处理过程中的一个插件。比如在request到达视图函数之前，可以使用中间件来做一些相关的事情，比如可以判断当前这个用户有没有登录，如果登录了，就绑定一个user对象到request上。也可以在response到达浏览器之前，做一些相关的处理，比如想要统一在response上设置一些cookie信息等。

Django内置的中间件：

1. django.middleware.common.CommonMiddleware：通用中间件。作用：
   • 限制 settings.DISALLOWED_USER_AGENTS 中指定的请求头来访问本网站。DISALLOWED_USER_AGENT是一个正则表达式的列表。

     # 限制某些网站的访问
     import re
     DISALLOWED_USER_AGENTS = [
         re.compile(r'^s$|^$'),         # 含空白符或空白无内容
         re.compile(r'.*PhantomJS.*')    # 含有该单词的
     ]

   • 如果开发者在定义url的时候，最后有一个斜杠。但是用户在访问url的时候没有提交这个斜杠，那么CommonMiddleware会自动的重定向到加了斜杠的url上去。
2. django.middleware.gzip.GZipMiddleware：将响应数据进行压缩。如果内容长度少于200个长度，那么就不会压缩。
3. django.contrib.messages.middleware.MessageMiddleware：消息处理相关的中间件。
4. django.middleware.security.SecurityMiddleware：做了一些安全处理的中间件。比如设置XSS防御的请求头，比如做了http协议转https协议的工作等。
5. django.contrib.sessions.middleware.SessionMiddleware：session中间件。会给request添加一个处理好的session对象。
6. django.contrib.auth.middleware.AuthenticationMiddleware：会给request添加一个user对象的中间件。
7. django.middleware.csrf.CsrfViewMiddleware：CSRF保护的中间件。
8. django.middleware.clickjacking.XFrameOptionsMiddleware：做clickjacking攻击的保护。（clickjacking保护是攻击者在自己的病毒网站上，写一个诱惑用户点击的按钮，然后使用 iframe 的方式将受攻击的网站（比如银行网站）加载到自己的网站上去，并将其设置为透明的，用户就看不到，再把受攻击的网站的转账按钮定位到病毒网站的按钮上，这样用户在点击病毒网站上按钮的时候，实际上点击的是受攻击的网站上的按钮，从而实现了在不知不觉中给攻击者转账的功能。）
9. 缓存中间件：用来缓存一些页面的。　　
   • django.middleware.cache.UpdateCacheMiddleware。
   • django.middleware.cache.FetchFromCacheMiddleware。

内置中间件放置的顺序：

（中间件的执行是有顺序的，他会根据在 MIDDLEWARE 中存放的顺序来执行。）

• SecurityMiddleware：放到最前面。因为这个中间件并不需要依赖任何其他的中间件。如果你的网站同时支持http协议和https协议，并且你想让用户在使用http协议的时候重定向到https协议，那么就没有必要让他执行下面一大串中间件再重定向，这样效率更高。
• UpdateCacheMiddleware。
• GZipMiddleware。
• ConditionalGetMiddleware。
• SessionMiddleware。
• LocaleMiddleware。
• CommonMiddleware。
• CsrfViewMiddleware。
• AuthenticationMiddleware。
• MessageMiddleware。
• FetchFromCacheMiddleware。
• FlatpageFallbackMiddleware。
• RedirectFallbackMiddleware。

自定义中间件：

　　中间件所处的位置没有规定。只要是放到项目当中即可。一般分为两种情况，如果中间件是属于某个app的，那么可以在这个app下面创建一个python文件用来存放这个中间件，也可以专门创建一个Python包，用来存放本项目的所有中间件。创建中间件有两种方式，一种是使用函数，一种是使用类。

使用函数的中间件：

# middlewares.py
def simple_middleware(get_response):
      # 这个中间件初始化的代码

      def middleware(request):
          # request到达view的执行代码

          response = get_response(request)

          # response到达浏览器的执行代码

          return response

      return middleware

使用类的中间件：

class SimpleMiddleware(object):
      def __init__(self, get_response):
          self.get_response = get_response
          # 这个中间件初始化的代码
          def __call__(self, request):
              # request到达view之前执行的代码

              response = self.get_response(request)

              # response到达用户浏览器之前执行的代码

              return response

定义在 request 到达视图函数之前，判断这个用户是否登录，如果已登录就绑定一个 user对象 到 request 上的中间件：

# 中间件
def front_user_middleware(get_response):
    # 执行一些初始化的代码
    print('front_user_middleware中间件初始化的代码...')
    def middleware(request):
        print('request到达view之前执行的代码...')
        user_id = request.session.get('user_id')
        if user_id:
            try:
                user = User.objects.get(pk=user_id)
                request.front_user = user
            except:
                request.front_user = None
        else:
            request.front_user = None
        # 在这个代码执行之前的代码，是request到view之前的代码
        response = get_response(request)
        print('response到达浏览器之前执行的代码...')
        # response对象到达浏览器之前执行的代码
        return response

在 settings.MIDDLEWARES 添加该中间件的配置：

# settings.py
MIDDLEWARE = [
    --snip--
    'middlewares.users.user_middleware',
]