【Django使用】4大模块50页md文档,第4篇：Django请求与响应和cookie与session

INSTALLED_APPS = [
     ...
     # 默认导入了django自带的session模块
     'django.contrib.sessions',
 ]
​
 MIDDLEWARE = [
     ...
     # 开启session中间件
     'django.contrib.sessions.middleware.SessionMiddleware',
 ]

request.session['键']=值

request.session.get('键', 默认值)

# 删除一个sessoin键值对（注意：键不存在会报错 `KeyError`）
  
  
del request.session['键']
​
# 清除当前访问用户所有的session数据
request.session.flush()  # 删除一条表记录
request.session.clear()  # 清空字段中的session键值对数据

request.session.set_expiry(value)

  * 如果value是一个整数，则 session数据 将在value秒没有活动后过期
  * 如果value为0，则 session数据 将在用户 **关闭浏览器时过期**
  * 如果value为None，则 session数据 将在 **2周后过期**

# url配置
  
  
  url(r'^set_session$', views.set_session),
  url(r'^get_session$', views.get_session),
​
  # 视图函数
  def set_session(request):
      """保存session键值对数据"""
      request.session['user_id'] = 10
      request.session['user_name'] = 'admin'
      return HttpResponse('保存session成功')
​
  def get_session(request):
      """读取session键值对数据"""
      user_id = request.session.get('user_id')
      user_name = request.session.get('user_name')
      text = 'user_id = %s, user_name = %s' % (user_id, user_name)
      return HttpResponse(text)

pip install django-redis==4.8.0

# django项目的缓存配置
  
  
 CACHES = {
     "default": {
         "BACKEND": "django_redis.cache.RedisCache",
         "LOCATION": "redis://127.0.0.1:6379/1",
         "OPTIONS": {
             "CLIENT_CLASS": "django_redis.client.DefaultClient",
                 "PASSWORD": ""
         }
     }
 }
​
 # session数据缓存到Redis中
 SESSION_ENGINE = "django.contrib.sessions.backends.cache"
 SESSION_CACHE_ALIAS = "default"

# url配置
  
  
  urlpatterns = [
      url(r'^post$', views.post),            # 显示发帖界面
      url(r'^do_post$', views.do_post),      # 执行发帖操作
  ]
​
  # 视图
  def post(request):
      """get请求： 显示发帖界面"""
      return render(request, 'post.html')
​
  def do_post(request):
      """post请求： 执行发帖操作"""
      title = request.POST.get('title')
      content = request.POST.get('content')
      return HttpResponse('发帖：title=%s, content=%s' % (title, content))

# url配置
  
  
  urlpatterns = [
      url(r'^post$', views.post),            # 发帖功能
  ]
​
  # 视图
  def post(request):
      """发帖功能"""
      if request.method == 'GET':
          # get请求： 显示发帖界面
          return render(request, 'post.html')
      else:
          # post请求： 执行发帖操作
          title = request.POST.get('title')
          content = request.POST.get('content')
          return HttpResponse('发帖：title=%s, content=%s' % (title, content))

urlpatterns = [
    ...
​
    # 类视图注册
​
    url(r'^post2$', views.PostView.as_view()),
]
​

@classonlymethod
def as_view(cls, **initkwargs):
    """
    Main entry point for a request-response process.
    """
    ...省略代码...
​
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
        self.request = request
        self.args = args
        self.kwargs = kwargs
        # 调用dispatch方法，按照不同请求方式调用不同请求方法
        return self.dispatch(request, *args, **kwargs)
​
    ...省略代码...
​
    # 返回真正的函数视图
    return view
​
def dispatch(self, request, *args, **kwargs):
    # Try to dispatch to the right method; if a method doesn't exist,
    # defer to the error handler. Also defer to the error handler if the
    # request method isn't on the approved list.
    if request.method.lower() in self.http_method_names:
        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    else:
        handler = self.http_method_not_allowed
    return handler(request, *args, **kwargs)

def check_ip(view_fun):
     """装饰器：禁止黑名单ip访问"""
     def wrapper(request, *args, **kwargs):
         # 在视图函数执行前做额外的操作：
         # 禁止ip黑名单访问
         IP = request.META.get('REMOTE_ADDR')
         if IP in ['192.168.210.160']:
             return HttpResponse('IP禁止访问')
         return view_fun(request, *args, **kwargs)
     return wrapper

@check_ip
 def post(request):
     """GET请求： 显示发帖界面"""
     return render(request, 'post.html')

urlpatterns = [
     ...
     # 发帖功能
     url(r'^post$', check_ip(views.post))
 ]

```python
urlpatterns = [
    ...
    # 发帖功能
    url(r'^post2$', check_ip(views.PostView.as_view()))
]

​
​
​
**方案二：在类视图中添加**
​
注意：**不能直接给类视图的方法添加装饰器**，需要使用**method_decorator**将其转换为适用于类视图方法的装饰器。
​
```python
  
  
# 方式二
  
  
  
  
# @method_decorator(check_ip, name='get')  # 为特定的请求方法添加
  
  
  
  
# @method_decorator(check_ip, name='dispatch')    # 为所有的请求方法添加
  
  
class PostView(View):
​
    # 给所有的http方法都添加装饰器
    # @method_decorator(check_ip)
    def dispatch(self, request, *args, **kwargs):
        return super().dispatch(request, *args, **kwargs)
​
    # 方式一
    @method_decorator(check_ip)
    def get(self, request):
        """get请求：显示发帖界面"""
        return render(request, 'post2.html')
​
    def post(self, request):
        """post请求：执行发帖操作"""
        # 代码简略
        return HttpResponse('处理发帖操作')

class ListModelMixin(object):
    """
    list扩展类
    """
    def list(self, request, *args, **kwargs):
        print('查询多条数据')
        ...
​
class CreateModelMixin(object):
    """
    create扩展类
    """
    def create(self, request, *args, **kwargs):
        print('新增一条数据')
        ...
​
class DepartmentView(CreateModelMixin, ListModelMixin, View):
    """
    同时继承两个扩展类，复用list和create方法
    """
    def get(self, request):
        self.list(request)
        ...
​
    def post(self, request):
        self.create(request)
        ...
​
class EmployeeView(CreateModelMixin, View):
    """
    继承CreateModelMixin扩展类，复用create方法
    """
    def post(self, request):
        self.create(request)
        ...

class MyMiddleware(MiddlewareMixin):
​
     def __init__(self, get_response=None):
         super().__init__(get_response)
         print('init')
​
     def process_request(self, request):
         print('before 视图')
         # 注意：可以返回None或者response对象，如果返回response对象，则视图函数就不会再执行了
​
     def process_response(self, request, response):
         print('after 视图')
         return response

MIDDLEWARE = [
     'django.middleware.security.SecurityMiddleware',
     ...
​
     'middlewares.MyMiddleware',  # 注册中间件
 ]

def index(request):
     print('==index==')
     return HttpResponse('hello django')

init
 before 视图
 ==index==
 after 视图

class MiddlewareMixin(object):
    def __init__(self, get_response=None):
        self.get_response = get_response
        super(MiddlewareMixin, self).__init__()
​
    def __call__(self, request):
        response = None
        if hasattr(self, 'process_request'):
            response = self.process_request(request)
        if not response:
            response = self.get_response(request)
        if hasattr(self, 'process_response'):
            response = self.process_response(request, response)
        return response

class MyMiddleware2(MiddlewareMixin):
​
     def __init__(self, get_response=None):
         super().__init__(get_response)
         print('init 2')
​
     def process_request(self, request):
         print('before 视图 2')
​
     def process_response(self, request, response):
         print('after 视图 2')
         return response

MIDDLEWARE = [
     'django.middleware.security.SecurityMiddleware',
     ...
     'middlewares.MyMiddleware',  # 注册中间件
     'middlewares.MyMiddleware2',  
 ]

before 视图
 before 视图 2
 ==index==
 after 视图 2
 after 视图