Django的视图层

视图层views#

1.小白必会三板斧
① HttpResponse
② render
③ redirect
django视图函数必须要给返回一个HttpResponse对象

其实render和redirect都是继承自HttpResponse

​ 前后端分离
​ 前端一个人干(前端转成自定义对象)
​ JSON.stringify() json.dumps()
​ JSON.parse() json.loads()
​ 后端另一个干(python后端用字典)
​ 只要涉及到数据交互,一般情况下都是用的json格式
​ 后端只负责产生接口,前端调用该接口能拿到一个大字典
​ 后端只需要写一个接口文档 里面描述字典的详细信息以及参数的传递

2.JsonReponse

Copy

from django.http import JsonResponse
def index(request):
        data = {'name':'我从未见过如此厚颜无耻之人','password':123}
        l = [1,2,3,4,5,6,7,8]
        # res = json.dumps(data,ensure_ascii=False)
        # return HttpResponse(res)
        # return JsonResponse(data,json_dumps_params={'ensure_ascii':False})
        return JsonResponse(l,safe=False)  # 如果返回的不是字典 只需要修改safe参数为false即可

3.上传文件

form表单上传文件需要注意的事项
1.enctype需要由默认的urlencoded变成formdata
2.method需要由默认的get变成post
(目前还需要考虑的是 提交post请求需要将配置文件中的csrf中间件注释)

如果form表单上传文件 后端需要在request.FILES获取文件数据 而不再是POST里面

Copy

request.method
request.GET
request.POST
request.FILES
request.path  # 只获取url后缀 不获取?后面的参数
request.get_full_path()  # 后缀和参数全部获取

Django视图层

视图函数包含FBV和CBV
FBV就是我们平常写的函数 类似于面向函数式编程
CBV基于类的视图 类似于面向对象编程
视图函数并不是只能有函数,还能有类

url中

url(r'^index/', view.MyIndex.as_view())

views中

from django.views import View
    
    class MyIndex(View):
        def get(self):
            return HttpResponse('我是get方法')
        def post(self):
            return HttpResponse('我是post方法')
    
        1.从url入手
        url(r'^login/',views.MyLogin.as_view())  
        由于函数名加括号执行优先级最高,所以这一句话一写完会立刻执行as_view()方法
        @classonlymethod
        def as_view(cls, **initkwargs):  # cls就是我们自己的写的类 MyLogin
            def view(request, *args, **kwargs):
                self = cls(**initkwargs)  # 实例化产生MyLogin的对象  self = MyLogin(**ininkwargs)
                if hasattr(self, 'get') and not hasattr(self, 'head'):
                    self.head = self.get
                self.request = request
                self.args = args
                self.kwargs = kwargs
                # 上面的几句话都仅仅是在给对象新增属性
                return self.dispatch(request, *args, **kwargs)  # dispatch返回什么 浏览器就会收到什么
                # 对象在查找属性或者方法的时候 你一定要默念 先从对象自己这里找  然后从产生对象的类里面找  最后类的父类依次往后
            return view

通过源码发现url匹配关系可以变形成
url(r'^login/',views.view) # FBV和CBV在路由匹配上是一致的 都是url后面跟函数的内存地址

2.当浏览器中输入login 会立刻触发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.
                    # 我们先以GET为例
                    if request.method.lower() in self.http_method_names:  # 判断当前请求方法是否在默认的八个方法内
                        # 反射获取我们自己写的类产生的对象的属性或者方法
                        # 以GET为例  handler = getattr(self,'get','取不到报错的信息')
                        # handler = get(request)
                        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
                    else:
                        handler = self.http_method_not_allowed
                    return handler(request, *args, **kwargs)  # 直接调用我们自己的写类里面的get方法
            # 源码中先通过判断请求方式是否符合默认的八个请求方法 然后通过反射获取到自定义类中的对应的方法执行

django settings源码

前提:
1.django除了暴露给用户一个settings.py配置文件之外 自己内部还有一个全局的配置文件
2.我们在使用配置文件的时候 可以直接直接导入暴露给用户的settings.py也可以使用django全局的配置文件 并且后者居多
from django.conf import settings
3.django的启动入口是manage.py

　　　　　　　 import os
            import sys

            if __name__ == "__main__":
                # django在启动的时候 就会往全局的大字典中设置一个键值对  值是暴露给用户的配置文件的路径字符串
                os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day54.settings")

            class Settings(object):
                def __init__(self, settings_module):  # settings_module = 'day54.settings'
                    # update this dict from global settings (but only for ALL_CAPS settings)
                    for setting in dir(global_settings):  # django全局配置文件
                        # dir获取django全局配置文件中所有的变量名
                        if setting.isupper():  # 判断文件中的变量名是否是大写 如果是大写才会执行/生效
                            setattr(self, setting, getattr(global_settings, setting))  # 给settings对象设置键值对
                            # 给settings对象设置键值对  settings[配置文件中大写的变量名] = 配置文件中大写的变量名所对应的值

                    # store the settings module in case someone later cares
                    self.SETTINGS_MODULE = settings_module  # 'day54.settings'

                    mod = importlib.import_module(self.SETTINGS_MODULE)  # mod = 模块settings(暴露给用户的配置文件)
                    for setting in dir(mod):  # for循环获取暴露给用户的配置文件中所有的变量名
                        if setting.isupper():  # 判断变量名是否是大写
                            setting_value = getattr(mod, setting)  # 获取大写的变量名所对应的值
                            setattr(self, setting, setting_value)  # 给settings对象设置键值对
                            """
                            d = {}
                            d['username'] = 'jason'
                            d['username'] = 'egon'
                            用户如果配置了就用用户的
                            用户如果没有配置就用系统默认的
                            其实本质就是利用字典的键存在就是替换的原理 实现了用户配置就用用户的用户没配置就用默认的
                            """
                
            class LazySettings(LazyObject):
                    def _setup(self, name=None):
                        # os.environ你可以把它看成是一个全局的大字典
                        settings_module = os.environ.get(ENVIRONMENT_VARIABLE)  # 从大字典中取值键为DJANGO_SETTINGS_MODULE所对应的值:day54.settings
                        # settings_module = 'day54.settings'
                        self._wrapped = Settings(settings_module)  # Settings('day54.settings')
                        
                
            settings = LazySettings()  # 单例模式