模仿admin写一个类似功能的组件，叫做stark
admin流程之启动
单例模式
单例：只允许一个类实例化出一个对象
使用 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
egon=Animal()
alex=Animal()
wupeiqi=Animal()
print(id(egon))
print(id(alex))
print(id(wupeiqi))
#三者完全相同
在上面的代码中，我们将类的实例和一个类变量 _instance 关联起来， 如果 cls._instance 为 None 则创建实例，否则直接返回 cls._instance。
使用模块
其实，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()
启动
（settings---->installapp------>admin）
def autodiscover():autodiscover_modules('admin', register_to=site)
admin流程之注册
admin.site : 单例对象
class AdminSite():
def __init__(self, name='admin'):
self._registry = {}
#model就是表对象（Book），admin_class就是表的配置类（BookConfig）
def register(self, model, admin_class=None, **options):
if not admin_class:
#配置类
admin_class = ModelAdmin
self._registry[model] = admin_class(model, self)
site=AdminSite()
admin.site.register(Book,BookConfig)
admin.site.register(Book) # site._registry:{Book:ModelAdmin(Book)}
admin.site.register(Publish) # site._registry:{Book:ModelAdmin(Book),Publish:ModelAdmin(Publish)}
#site._registry:{模型类:该模型类的配置类对象,........}
知识点：url分发扩展
url()方法的扩展应用
from django.shortcuts import HttpResponse
url(r'^index/', index), # 一旦匹配成功， index(request)
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^yuan/', ([
url(r'^test01/', ([
url(r'^test1_1/', test01),
url(r'^test1_2/', test01),
],None,None)),
url(r'^test02/', test02),
url(r'^test03/', test03),
],None,None)),
]
格式，元祖里面是一个列表+None+None
admin流程之设计url
admin中：
from app01 import models
admin.site.register(models.Book)
admin.site.register(models.Publish)
admin.site.register(models.Author)
urls.py中：
from django.conf.urls import url
from django.contrib import admin
from django.shortcuts import render, HttpResponse, redirect
def list_view(request):
return HttpResponse("list_view")
def change(request, id):
return HttpResponse("change")
def delete(request, id):
return HttpResponse("delete")
def add(request):
return HttpResponse("add")
def get_urls2():
temp = [
url("^add/$", add),
url("^$", list_view),
url("^(\d+)/change/$", change),
url("^(\d+)/delete/$", delete)
]
return temp
def get_urls():
temp = []
print("_registry==>", admin.site._registry.items())
#{Book:ModelAdmin(Book),....}
#(<class 'app01.models.Book'>, <django.contrib.admin.options.ModelAdmin object at 0x00000234441F99B0>)
#Django启动会先加载settings，因此_registry中有值
for model, model_class_obj in admin.site._registry.items():
app_name = model._meta.app_label
#model._meta.app_label可以获取当前model所在app的名字
model_name = model._meta.model_name
#model._meta.model_name可以获得当前model的名称字符串
#用stark+app的名字+模型表的名字
#举例：http://127.0.0.1:8000/stark/app01/book/02/change/
temp.append(url(r"%s/%s/" % (app_name, model_name), (get_urls2(), None, None)))
return temp
urlpatterns = [
url(r'^admin/', admin.site.urls),
# [
# url(r'^test01/', test01),
# url(r'^test02/', test02),
# ]
url(r"^stark",(get_urls(),None,None))
]
最终url示例:
^stark auth/group/
^stark auth/user/
^stark app01/book/ ^add/$
^stark app01/book/ ^$
^stark app01/book/ ^(\d+)/change/$
^stark app01/book/ ^(\d+)/delete/$
^stark app01/publish/
^stark app01/author/
知识点回顾
函数和实例方法的区别
class Animal():
def running(self):
print("running...")
#从实例对象调
alex = Animal()
#alex会作为self参数传进去
alex.running()
#结果：
#running...
#当做函数调，必须传个参数
Animal.running(123)
#结果：
#running...
合并列表
temp = []
temp.append(1)
l = [2, 3, 4]
temp.extend(l)
print(temp)
#结果：
[1, 2, 3, 4]
根据字符串名称拿字段对象和数据
Model _meta API 它提供的方法可用于: 检索模型的所有字段实例 按名称检索模型的单个字段实例
from django.contrib.auth.models import User
# A field on the model
User._meta.get_field('username')
<django.db.models.fields.CharField: username>
# A field from another model that has a relation with the current model
User._meta.get_field('logentry')
<ManyToOneRel: admin.logentry>
按名称(字符串)检索模型的单个字段实例
filter_field_obj = self.model._meta.get_field(filter_field)
print("filter_field_obj==>", filter_field_obj)
得到app01.Book.publish和app01.Book.authors
拿对象下面的数据 .rel .to 来自于ForeignKey和ManyToManyField这俩类 .rel可以看到对象的数据类型，加上.to可以拿到对象下面的数据，.to只对一对一，一对多，多对多有效
print(filter_field_obj.rel.to)
结果：
< class 'app01.models.Publish'>
< class 'app01.models.Author'>
data_list = filter_field_obj.rel.to.objects.all()
print(filter_field_obj.rel.to)
结果：
< QuerySet[ < Publish: 图灵新知 >, < Publish: dzm >, < Publish: 老男孩出版社 >] >
< QuerySet[ < Author: egon >, < Author: alex >] >
获取字段对象的中文名
from app01.models import Book
#price是book表中一个字段对象
obj = Book._meta.get_field("price")
obj.verbose_name
结果：
'价格'
没有单独设置verbose_name时，则返回英文名，若想使用中文名则要在models定义verbose_name 例：
class Book(models.Model):
nid = models.AutoField(primary_key=True, verbose_name="编号")
title = models.CharField(max_length=32, verbose_name="名称")
price = models.DecimalField(max_digits=5, decimal_places=2, verbose_name="价格")
总结：自制Admin组件
这里我们叫它Stark
从访问说起：下面的思路是模拟Django原生Admin的写法
url流程
1.urls.py中：
from stark.service.sites import site
urlpatterns = [
# url(r"^stark",(get_urls(),None,None))
url(r'^stark/', site.urls)
]
2.site是StarkSite这个类的实例化结果，如下面
site = StarkSite()
3.site调用urls，返回的是get_urls中的temp列表
model的注册
在app01目录下面有stark.py文件 我们在这个文件中对model进行注册 在Django启动的时候会遍历每个app中是否有stark.py文件（settings中设置的），找到后会运行， 因此里面的内容在Django启动时就运行过了
1.site.register(Book) 注册Book表 2.register方法会执行：
self._registry[model] = admin_class(model, self)
3.也就是向_registry = {}这个字典中添加了如上内容 内容简单理解为：{Book:ModelStark(Book)},这里的键Book是model对象 此时_registry = {}中就有了内容
访问，url分发开始
1.循环_registry = {},使用site._registry.items()分别得到表的对象和配置类 2.用表对象得到app的名字和表的名字，由此拼出一级分发 3.二级分发用配置类调用urls2得出 配置类对象是ModelStark(Book) 接下来我们去找ModelStark这个类来看一下
class ModelStark()就是默认的配置类，如果注册表的时候没有自定义配置类则走这里， 同时自定义配置类也要继承ModelStark作为父类 在这个类下面：
class ModelStark(): #配置类
list_display = ["__str__", ]
def __init__(self, model, site):
self.model = model
这个self.model = model是关键，谁调用的它self.model就是那个表对象 如果是Book的话，那么self.model = Book
我们回到urls2
urls2返回值构建了一个return self.get_urls2(), None, None的格式 我们再去找get_urls2()这个函数 get_urls2和urls2都是class ModelStark下面的方法
get_urls2里面负责处理二级分发 这里举例访问到视图函数list_view中
def list_view(self, request):
data_list = self.model.objects.all()
此时model是Book，所以可以进行查询
self.model是谁
注：在视图函数中self.model到底是谁？这里是原生Admin组件写法的关键 这要看self是谁，一层一层往上找，最后会找到model_class_obj.urls2 model_class_obj来自于site._registry循环结果中的配置类，配置类是stark.py中注册的一个个模型的配置类 循环到谁就是谁调用urls2，self.model也就是那个对应的模型对象
注：我们无法确定用户访问那个url，因此提前准备好所有url，此时访问book，后面的model就是book，因此可以拿到相应数据
表单数据之多对多字段的处理
方法1 使用函数
在stark.py的BookConfig类中再增加一个函数
def display_atuhors(self, obj=None, is_header=False):
#判断is_header有没有值，有值的话就表示这是标题行，直接返回一个固定标题名
if is_header:
return "作者"
s = []
#obj是传过来的一个个的对象<Book: go语言第二版>, <Book: linux>,
#把这个对象中authors字段所有的内容循环起来分别添加到一个列表中
for author in obj.authors.all():
s.append(author.name)
return ",".join(s)
list_display = ["nid", "title", "price", "publish", display_atuhors,]
方法2
通过判断是不是多对多函数来做处理
data_list = self.model.objects.all()
for obj in data_list:
temp = []
#循环需要显示的字段
for field in self.list_display:
#判断这个字段是不是字符串
if isinstance(field, str):
try:
#引入ManyToManyField
from django.db.models.fields.related import ManyToManyField
#获取相应名称字段的对象
field_obj = self.model._meta.get_field(field) #注意，这里没法找出__str__，因此会报错
#判断这个对象是不是多对多
if isinstance(field_obj, ManyToManyField):
l = []
#利用反射，循环obj.field.all()，例如<Book: Book object>.authors,再加上.all()取这个对象下authors字段的全部内容
for i in getattr(obj, field).all():
#把循环结果添加到l列表
l.append(str(i)) #l==> ['egon', 'alex']
#用逗号把列表里面的元素拼起来
val = ",".join(l)
except Exception as e:
val = getattr(obj, field)
#添加到temp列表
temp.append(val)
