5、Django框架五

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware', 
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

django.middleware.security.SecurityMiddleware
        做了一些安全处理的中间件。比如设置XSS防御的请求头，比如做了http协议转为https协议的工作等；
django.contrib.sessions.middleware.SessionMiddleware
        session中间件，该中间件会给request对象添加一个处理好的session对象；
django.middleware.common.CommonMiddleware
        通用中间件，处理URL，比如baidu.com会自动的处理成www.baidu.com，或/blog/1会处理成/blog/1/自动加上反斜杠；
django.middleware.csrf.CsrfViewMiddleware
        保护中间件，在提交表单的时候会必须加入csrf_token，cookie中也会生成一个名叫csrftoken的值，也会在header中加入一个HTTP_X_CSRFTOKEN的值来放置CSRF攻击，SessionMiddleware必须出现在CsrfMiddleware之前；
django.contrib.auth.middleware.AuthenticationMiddleware
        用户授权中间件，会给request添加一个user对象的中间件，该中间件必须在sessionmiddleware后面；
django.contrib.messages.middleware.MessageMiddleware
        该中间件为消息处理中间件，主要是为了在多个模板中可以使用我们返回给模板的变量，并且简化操作；
django.middleware.clickjacking.XFrameOptionsMiddleware
        该中间件主要用于防止通过浏览器页面跨Frame出现clickjacking(欺骗点击)攻击出现；

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        response = self.get_response(request)
        return response

process_request(request)：中间件第一个执行的钩子函数，但在Django 1.11版本后，它不再是一个函数，而是get_response(request)上面的代码段，在这个代码段中，我们可以对发送过来的请求报文，做一些预处理，当然，我们也可以直接响应客户端，需要注意的是，如果该代码段中存在return语句，并且返回值是一个HttpResponse对象，将不会继续往下执行，而是直接响应客户端；
process_view(request, view_func, view_args, view_kwargs)：在执行完所有的process_request钩子函数之后，会执行该钩子函数，在该钩子函数中，我们可以拿到经过路由匹配到的视图处理函数，所以，该钩子方法，就是在正式进入视图处理函数之前，对request对象需要做的一些操作，如果该函数，返回值为None，则继续执行后面的中间件的process_view函数，如果返回HttpResponse，则不执行后续的process_view函数，也不执行视图函数，然后执行所有的process_response中间件；
process_exception(request, exception)：该钩子函数为执行视图函数的过程中如果引发异常，则按照settings.py中MIDDLEWARE_CLASSES的顺序，倒序执行process_exception方法来处理，如果返回None，继续执行下一个中间件的process_exception方法，如果返回HttpReponse对象，则该中间件上方其他中间件的process_exception方法不会被调用，一旦其中某个中间件有返回值，则调用template_response和response中间件；
process_template_response(request, response)：该钩子函数是在视图函数执行结束之后执行，但是该钩子函数的执行有一个条件，就是response实现了render方法才会执行，一旦所有的中间件的template_response被执行完，则调用render方法；
process_response(request, response)：该钩子函数为视图函数处理完成之后，响应报文到达路由系统的下一站，该钩子函数必须有返回值，且返回类型必须是HttpResponse对象；

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response
    def __call__(self, request):
        # 此处为process_request的代码段
        response = self.get_response(request)
        # 此处为process_response的代码段
        return response
    def process_view(self, request, view_func, view_args, view_kwargs):
        # 此处为process_view的代码段
    def process_exception(self, request, exception):
        # 此处为process_exception的代码段
    def process_template_response(self, request, response):
        # 此处为process_template_response的代码段
        return response

from django.views import View
class home(View):
    def get(self,request):
        pass
    def post(self,request):
        pass
    def delete(self,request):
        pass
    def put(self,request):
        pass
# urls.py
from user.views import home
urlpatterns = [
    path('', home.as_view()), # 调用这个类的as_view()方法，拿到一个被包装的视图函数
]

class View:
    http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']

    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)

    @classonlymethod
    def as_view(cls, **initkwargs):
        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError("You tried to pass in the %s method name as a "
                                "keyword argument to %s(). Don't do that."
                                % (key, cls.__name__))
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r. as_view "
                                "only accepts arguments that are already "
                                "attributes of the class." % (cls.__name__, key))

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
            self.setup(request, *args, **kwargs)
            if not hasattr(self, 'request'):
                raise AttributeError(
                    "%s instance has no 'request' attribute. Did you override "
                    "setup() and forget to call super()?" % cls.__name__
                )
            return self.dispatch(request, *args, **kwargs)
        view.view_class = cls
        view.view_initkwargs = initkwargs
        update_wrapper(view, cls, updated=())
        update_wrapper(view, cls.dispatch, assigned=())
        return view

    def setup(self, request, *args, **kwargs):
        self.request = request
        self.args = args
        self.kwargs = kwargs

    def dispatch(self, request, *args, **kwargs):
        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 http_method_not_allowed(self, request, *args, **kwargs):
        logger.warning(
            'Method Not Allowed (%s): %s', request.method, request.path,
            extra={'status_code': 405, 'request': request}
        )
        return HttpResponseNotAllowed(self._allowed_methods())

    def options(self, request, *args, **kwargs):
        response = HttpResponse()
        response['Allow'] = ', '.join(self._allowed_methods())
        response['Content-Length'] = '0'
        return response

    def _allowed_methods(self):
        return [m.upper() for m in self.http_method_names if hasattr(self, m)]

class cce:
    def __init__(self):
        self.value = 1

    def c1(self):
        cce = getattr(self, 'c2')
        return cce() # 返回cce函数的执行结果

    def c2(*args):
        return args


c1 = cce()
print(c1.c1()) # (<__main__.cce object at 0x102f19c18>,) 
# 可以看到，默认在没有传任何参数的情况下，Python解释器会加入一个self参数；

# 方式一
@method_decorator(authenticate,name="get")
class index(View):
    def get(self, request):
        return JsonResponse({"message": '欢迎!!!'})
# 方式二
class index(View):
    @method_decorator(authenticate)
    def get(self, request):
        return JsonResponse({"message": '欢迎!!!'})

def decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

class index(View):
    @decorator
    def get(self, request):
        return JsonResponse({"message": '欢迎!!!'})

# Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
SESSION_COOKIE_NAME = 'sessionid'
# Session的cookie失效日期（2周）（默认）
SESSION_COOKIE_AGE = 60 * 60 * 24 * 7 * 2
# Session的cookie保存的域名（默认）
SESSION_COOKIE_DOMAIN = None
# 是否Https传输cookie（默认）
SESSION_COOKIE_SECURE = False
# Session的cookie保存的路径（默认）
SESSION_COOKIE_PATH = '/'
# 是否Session的cookie只支持http传输（默认）
SESSION_COOKIE_HTTPONLY = True
# 是否每次请求都保存Session，默认修改之后才保存（默认）
SESSION_SAVE_EVERY_REQUEST = False
# 是否关闭浏览器使得Session过期（默认）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
# 存储session数据默认使用的模块
SESSION_ENGINE = 'django.contrib.sessions.backends.db'
# session数据的序列化类
SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer'

CACHES = {
    "default": {#default 必须加上,不然会报错
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/5",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 10000},
            "PASSWORD": "caidaye",
        }
    }
}
# session的存储配置
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 设置缓存机制为CACHES
SESSION_CACHE_ALIAS = 'default'  # CACHES的redis

set_expiry：对当前session设置过期时间；
keys：拿到所有session的session_key；
values：拿到所有session的value；
items：拿到所有session键值对儿；
get：获取指定session_key的value；
clear_expired：删除所有已过期的session；
exists：判断指定的session_key是否存在；
delete：删除指定session_key对应的值；
clear：删除当前这个请求对应的session数据；

from distutils.core import setup
import glob

setup(
    name="blog",
    version="0.0.1",
    author="cce",
    author_email="mail0426@163.com",
    url="blog.doorta.com",
    description="A simple blog site",
    packages=["blog", "user", "utils"],
    py_modules=["manage"],
    data_files=glob.glob("user/templates/*.html") + ["requirements.txt"],
)

# python3.5 setup.py sdist