Django 之admin源码

复习单列，sql  orm

 

不管用什么都是基于httpRespone

url控制器，

Django框架的设计模式借鉴了MVC框架的思想，也是分成三部分，来降低各个部分之间的耦合性。

MTV  

  templates  view  models

Model(模型)：负责业务对象与数据库的对象(ORM)

       Template(模版)：负责如何把页面展示给用户

       View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

此外，Django还有一个urls分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

 

2,AJAX

    ----------------contentType  上传文件指定False（编码格式）

3 forms 组件    局部钩子，全局钩子

4，cookie，session，

 Session

1. 浏览器请求来了之后，服务端给你分配一个序号（口令）

 

2. 浏览器收到响应之后，把得到的口令保存在 cookie

 

3. 浏览器携带着刚才得到的口令，再次发送请求

 

4. 服务端拿到口令，去后端根据口令找对应的数据（大字典

     session 依赖cookie  。cookie保存在浏览器，session保存在服务端

    session好处，客服端只有cookie的值，没有用户的信息

 

 

 

 

           request.sesion["name"]="egon"（走的流程）

         生成随机字符串

看中间件：

 

只是在内存中间，没有更新到数据库，如果没有return

 

5，用户认证组件

6，中间件：应用场景：限制访问的频率

 

wsgiref 代替web服务器部署（把一堆字符串解析--》request（中间件））

浏览器只解析，html  css   js（页面看到的东西不一定是服务器发来的）如果不加safe

 

request发请求怎么到服务器？

点击确定就

‘’

 post/index   HTTP/1.1

''''''''

请求体里面怎么放name，password？

服务器怎么解？

必须按照一种格式解 （form有3种格式）

Json

form-data

application/x-www-form-urlencoded（默认）

……所以我们在请求头告诉服务器用什么编码 content-Type=默认按这种解（form表单）

Name=yuan&pwd=123

 

Ajax 和form表单一样的格式

如果用ajax发json格式 contentType

要保证contentType  和内容换成一致

 

 

下面一种是json格式

 

不能骗浏览器，ajax里面要改成这样

后端收到的为空，为什么？

 

 

query对象里面有没有关键request.post只解析application/x-www-form-urlencoded

只是不解析

request.body 可以拿到所有原信息

所以我们序列化

 

 

补充：

https://www.cnblogs.com/yuanchenqi/articles/9070966.html

https://www.cnblogs.com/yuanchenqi/articles/8323452.html

‘’

 

admin管理工具

    list_display = ["title","price","publishDate"]（列表时，定制显示的列。）

    list_filter = ["publish","authors"]  （列表时，定制右侧快速筛选。）

    search_fields=["price","title"]      （列表时，模糊搜索的功能）

    search_field：添加搜索框

https://www.cnblogs.com/yuanchenqi/articles/8323452.html  其他详见

admin源码解析

单例模式

单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。当你希望在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场。

比如，某个服务器程序的配置信息存放在一个文件中，客户端通过一个 AppConfig 的类来读取配置文件的信息。如果在程序运行期间，有很多地方都需要使用配置文件的内容，也就是说，很多地方都需要创建 AppConfig 对象的实例，这就导致系统中存在多个 AppConfig 的实例对象，而这样会严重浪费内存资源，尤其是在配置文件内容很多的情况下。事实上，类似 AppConfig 这样的类，我们希望在程序运行期间只存在一个实例对象。

在 Python 中，我们可以用多种方法来实现单例模式：

• 使用模块
• 使用 __new__
• 使用装饰器（decorator）
• 使用元类（metaclass）

（1）使用 __new__

为了使类只能出现一个实例，我们可以使用 __new__ 来控制实例的创建过程，代码如下：

 

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  

class MyClass(Singleton):  
    a = 1

 

在上面的代码中，我们将类的实例和一个类变量 _instance 关联起来，如果 cls._instance 为 None 则创建实例，否则直接返回 cls._instance。

执行情况如下：

 

>>> one = MyClass()
>>> two = MyClass()
>>> one == two
True
>>> one is two
True
>>> id(one), id(two)
(4303862608, 4303862608)

 

（2）使用模块

其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：

# mysingleton.py
class My_Singleton(object):
    def foo(self):
        pass
 
my_singleton = My_Singleton()

将上面的代码保存在文件 mysingleton.py 中，然后这样使用：

from mysingleton import my_singleton
 
my_singleton.foo()

 

 

一个类只有一个实例对象

只要有一个类，每一个类对象不一样，只有实例化对象地址才是一样的

类的继承

class Base(object):
    def __init__(self,val):
        self.val = val

def func(self):
        self.test()
        print(self.val)

def test(self):
        print("Base.test")

class Foo(Base):
    def test(self):
        print("FOO.test")

# def func(self):
    #     print(self.val,666)
    #有就执行自己的，没有就执行父类的
class Bar(object):
    def __init__(self):
        self._register = {}

def regiter(self,a,b=None):
        if not b:
            b=Base
        self._register[a] = b(a)  #函数，类，对象

obj = Bar()  #实例化就会去执行它自己的__init__方法，并获取到一个对象b,b就可以调用里面的属性和方法了
obj.regiter(1,Foo)
obj.regiter(2)
print(obj._register)  #{1: <__main__.Foo object at 0x0000000002213160>, 2: <__main__.Base object at 0x0000000002213198>}
#obj._register[1] == Foo(1)
obj._register[1].func()  #Foo的对象  打印结果：FOO.test       1
obj._register[2].func()  #Base的对象  打印结果：Base.test     2

 

 

单例模式：单例模式是一个设计模式，就是单个实例共用一个对象

s1.py

class Foo(object):
    def test(self):
        print("123")

v = Foo()
#v是Foo的实例

s2.py

 

from s1 import v as v1
print(v1,id(v1))  #<s1.Foo object at 0x0000000002221710> 35788560

from s1 import v as v2
print(v1,id(v2))   #<s1.Foo object at 0x0000000002221710> 35788560

# 两个的内存地址是一样的
# 文件加载的时候，第一次导入后，再次导入时不会再重新加载。

 

举例二：

class Singleton:
    def __new__(cls, *args, **kw):
        '''__new__是一个构造方法，self就是他构造的'''
        if not hasattr(cls, '_instance'):
            orig = super(Singleton, cls)
            cls._instance = orig.__new__(cls, *args, **kw)
        return cls._instance

one = Singleton()
two = Singleton()
print(one,two)   #他们两个的地址一样
# print(id(one),id(two))
one.name = 'alex'
print(two.name)

来自 <http://www.cnblogs.com/haiyan123/p/8034430.html>

 

 

 

admin执行流程

admin

    1 使用

2 源码

  （1）启动

       执行每一个app下的admin.py 文件

   autodiscover_modules('admin', register_to=site)

  （2）注册

        class AdminSite(object):

     def __init__(self, name='admin'):

                       self._registry = {}

     def register(self, model_or_iterable, admin_class=None, **options):

      if not admin_class:

                             admin_class = ModelAdmin   # 配置类

 

  self._registry[model] = admin_class(model, self)

  

  # {Book:BookConfig(Book),Publish:ModelAdmin(Publish)}

 

        site=AdminSite()

 

 

##########

 

class BookConfig(ModelAdmin):

      list_display=["",]

 

admin.site.register(Book,BookConfig)

 

admin.site.register(Publish)

 

 

 

 {

 <class 'django.contrib.auth.models.Group'>: <django.contrib.auth.admin.GroupAdmin object at 0x00000256B97EF9E8>,

 <class 'django.contrib.auth.models.User'>: <django.contrib.auth.admin.UserAdmin object at 0x00000256B9825438>,

 <class 'app01.models.Book'>: <app01.admin.BookConfig object at 0x00000256B983C080>,

 <class 'app01.models.Publish'>: <app01.admin.PublishConfig object at 0x00000256B983C128>

 }