python笔记(Django 自定义stark组件)

常用ORM几种模式

1. 切片操作 Book.objects.all()[0:8]

2. 迭代操作

   for obj in Book.objects.all():
       print(obj.属性)
   

3. 惰性查询

   ret=Book.objects.all()
   
   # for i in ret:
   #     print(i)
   #
   # Book.objects.create(title="java",publishDate="2012-12-12",price=12,publish_id=1)
   #
   # for i in ret:
   #     print(i)
   

4. 缓存机制

   # ret=Book.objects.all().exists()
   # if ret:
   #     print("OK")
   
   
   # ret=Book.objects.all().iterator()
   # print(type(ret))
   # for i in ret:
   #     print(i)
   # Book.objects.create(title="hello2",publishDate="2012-12-12",price=12,publish_id=1)
   #
   # for i in ret:
   #     print(i)
   

一、配置stark组件

1. 创建stark应用，在settings.py中注册stark应用
   1、stark APP专门用于存放自定义组件的核心代码。

   manage.py@stark_demo > startapp stark
   

   2、在settings.py文件注册stark:

   INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'app01.apps.App01Config',
   'stark.apps.StarkConfig',
   ]
   

2. 项目启动加载每一个app下的所有stark文件
   在stark项目的apps.py文件加上下面的代码，ready函数的作用是让Django在启动时自动扫描每一个app下面的stark.py文件

   from django.apps import AppConfig
   from django.utils.module_loading import autodiscover_modules
        
   class StarkConfig(AppConfig):
       name = 'stark'
       # 程序启动时，扫描app下得指定文件（stark.py）并执行
       def ready(self):
           autodiscover_modules('stark')   
   

3. app01/models.py中创建模型

   class UserInfo(models.Model):
       name=models.CharField(max_length=32)
       age=models.IntegerField()
    
       def __str__(self):
           return self.name
   class Book(models.Model):
       title=models.CharField(max_length=32)
    
       def __str__(self):
           return self.title
   

   执行数据迁移和创建超级用户操作：

   makemigrations
   migrate
   createsuperuser 
   

4. admin.py配置

   from django.contrib import admin
   # Register your models here.
   from .models import *
    
   class UserAdmin(admin.ModelAdmin):
       list_display = ["pk",'name','age']
       list_filter = ['name','age']
    
       # 定制action具体方法
       def func(self,request,queryset):
           queryset.update(age=44)
    
       func.short_description = "批量初始化操作"
       actions = [func]
    
   admin.site.register(UserInfo, UserAdmin)
   admin.site.register(Book)
   

二、开发自己的stark组件

1. 首先创建一个Python包，创建一个stark.py文件

   

2. stark_che/service/stark.py（单例）

   class ModelStark(object):
       list_display=[]
    
       def __init__(self,model,site):
           self.model=model
           self.site=site
    
    
   class StarkSite(object):
       def __init__(self):
           self._registry = {}
    
       def register(self, model, stark_class=None, **options):
           if not stark_class:
               # 如果注册的时候没有自定义配置类,执行
               stark_class = ModelStark   # 配置类
    
           # 将配置类对象加到_registry字典中，键为模型类
           self._registry[model] = stark_class(model, self)   # _registry={'model':stark_class(model)}
    
   site = StarkSite()
   

   在使用admin组件的时候，是在我们注册时候调用一个单例对象site进行注册。stark中同样生成了一个site单例对象。然后在app01的stark文件导入：

   from stark.service.stark import site
   

   通过单例对象site调用注册方法，所以需要在StarkSite类创建一个register方法。

3. app01/stark.py

   from app01 import models
   from stark_che.service.stark import site, ModelStark
    
   # 自定义配置类
   class UserConfig(ModelStark):
       pass
    
   site.register(models.UserInfo, UserConfig)
   site.register(models.Book)
   

4. 设计url

   1、编写urls.py并查看admin的url源码
   　Django项目建起来之后就会自动创建一个url文件，如：其中admin的url就已经配置好了

   from django.contrib import admin
   from django.urls import path
   from django.conf.urls import url
   from stark.service.stark import site
   		
       urlpatterns = [
           path('admin/', admin.site.urls),
           # path('stark/', site.urls),
           url(r'^stark_che/', site.urls),
       ]
   

   查看admin.site.urls源码，发现urls方法有property装饰器：

   class AdminSite:
       ...
       @property
       def urls(self):
           return self.get_urls(), 'admin', self.name
   

   urls方法有property装饰器，会将函数装饰成一个属性，它会在项目的启动的时候就执行，将内部的url进行分发，生成url的方法就是get_urls()。
   return三个值以元组的形式返回 ([], None, None )。

   2、自定义url（stark_che/service/stark.py）

   from django.conf.urls import url
   from django.shortcuts import HttpResponse,render
    
   class ModelStark(object):
       """定制配置类"""
       list_display = []
    
       def __init__(self, model, site):
           self.model = model
           self.site = site
    
       def add(self, request):
           return HttpResponse("add")
    
       def delete(self, request, id):
           return HttpResponse("delete")
    
       def change(self, request, id):
           return HttpResponse("change")
    
       def list_view(self, request):
           return HttpResponse("list_view")
    
       def get_urls_2(self):
           temp = []
           temp.append(url(r"^add/", self.add))
           temp.append(url(r"^(\d+)/delete/", self.delete))
           temp.append(url(r"^(\d+)/change/", self.change))
           temp.append(url(r"^$", self.list_view))
           return temp
    
       @property
       def urls_2(self):
           return self.get_urls_2(), None, None  # [], None, None
    
   class StarkSite(object):
       """site单例类"""
       def __init__(self):
           self._registry = {}
    
       def register(self, model, stark_class=None, **options):
           """注册"""
           if not stark_class:
               # 如果注册的时候没有自定义配置类,执行
               stark_class = ModelStark   # 配置类
    
           # 将配置类对象加到_registry字典中，键为模型类
           self._registry[model] = stark_class(model, self)   # _registry={'model':admin_class(model)}
    
       def get_urls(self):
           """构造一层url"""
           temp = []
           for model, stark_class_obj in self._registry.items():
               # model:一个模型表
               # stark_class_obj:当前模型表相应的配置类对象
    
               model_name = model._meta.model_name
               app_label = model._meta.app_label
    
               # 分发增删改查
               temp.append(url(r"^%s/%s/" % (app_label, model_name), stark_class_obj.urls_2))
               """
                  path('app01/userinfo/',UserConfig(Userinfo,site).urls2),
                  path('app01/book/',ModelStark(Book,site).urls2),
               """
           return temp
    
       @property
       def urls(self):
           return self.get_urls(), None, None
    
   site = StarkSite()    # 单例对象
   

   注意：

   （1）StarkSite是单例类，site是单例对象，放在里面的变量都是相同的，无法定制任何信息。因此不能把增删改查和get_urls_2等函数都放在StarkSite类中。

   （2）用户可以自定制配置页面，所以调用配置类 stark_class_obj.urls_2

   # 分发增删改查
   temp.append(url(r"^%s/%s/" % (app_label, model_name), stark_class_obj.urls_2))
   

   （3）self._registry拿到所有的注册对象，注意遍历拿到的model和stark_class_obj

   def get_urls(self):
       """构造一层url"""
       temp = []
       for model, stark_class_obj in self._registry.items():  
           # model:一个模型表
           # stark_class_obj:当前模型表相应的配置类对象
   

   （4）不同的model表，显示不同的url
   
   （5）记住：self.model是用户当前访问的模型表

   （6）stark路由分发流程
   

三、实现Stark组件的增删该查

1. 找到查看路径
   

2. 到对应视图函数

   app01/stark.py
stark_che/srvice/stark.py/ModelStark类(查看视图函数）
   到对应的数据获取类（若自定义了list_display用自己的，若未定义就用默认的）
   

    ModelStark类
   

   

3. 添加数据
   

   bfield.field.queryset.model._meta.model_name  #获取模型名称
   bfield.field.queryset.model._meta.app_label       #获取所在app名称
   

   ADD HTLM界面
   

4. 删除函数
   

    url = self.get_list_url()
   

   

   _url = reverse("%s_%s_list" % (app_label, model_name))   #反向查询
   

5. 编辑函数

   
   get_modelform_class()
   自己定义Modelform
   

6. 过滤显示

   
   
   

7. 搜索过滤

   
   
   

8. 分页实现

   分页组件

   """
   自定义分页组件
   
   """
   
   class Pagination(object):
       def __init__(self, current_page, all_count, base_url,params, per_page_num=8, pager_count=11, ):
           """
           封装分页相关数据
           :param current_page: 当前页
           :param all_count:    数据库中的数据总条数
           :param per_page_num: 每页显示的数据条数
           :param base_url: 分页中显示的URL前缀
           :param pager_count:  最多显示的页码个数
           """
           try:
               current_page = int(current_page)
           except Exception as e:
               current_page = 1
   
           if current_page < 1:
               current_page = 1
   
           self.current_page = current_page
   
           self.all_count = all_count
           self.per_page_num = per_page_num
   
           self.base_url = base_url
   
           # 总页码
           all_pager, tmp = divmod(all_count, per_page_num)
           if tmp:
               all_pager += 1
           self.all_pager = all_pager
   
           self.pager_count = pager_count  # 最多显示页码数
           self.pager_count_half = int((pager_count - 1) / 2)
   
           import copy
           params = copy.deepcopy(params)
           params._mutable = True
           self.params = params  # self.params : {"page":77,"title":"python","nid":1}
   
   
       @property
       def start(self):
           return (self.current_page - 1) * self.per_page_num
   
   
       @property
       def end(self):
           return self.current_page * self.per_page_num
   
   
       def page_html(self):
           # 如果总页码 < 11个：
           if self.all_pager <= self.pager_count:
               pager_start = 1
               pager_end = self.all_pager + 1
           # 总页码  > 11
           else:
               # 当前页如果<=页面上最多显示(11-1)/2个页码
               if self.current_page <= self.pager_count_half:
                   pager_start = 1
                   pager_end = self.pager_count + 1
   
               # 当前页大于5
               else:
                   # 页码翻到最后
                   if (self.current_page + self.pager_count_half) > self.all_pager:
                       pager_start = self.all_pager - self.pager_count + 1
                       pager_end = self.all_pager + 1
   
                   else:
                       pager_start = self.current_page - self.pager_count_half
                       pager_end = self.current_page + self.pager_count_half + 1
   
           page_html_list = []
           self.params["page"] = 1
           first_page = '<li><a href="%s?%s">首页</a></li>' % (self.base_url, self.params.urlencode(),)
           page_html_list.append(first_page)
   
           if self.current_page <= 1:
               prev_page = '<li class="disabled"><a href="#">上一页</a></li>'
           else:
               self.params["page"] = self.current_page - 1
               prev_page = '<li><a href="%s?%s">上一页</a></li>' % (self.base_url, self.params.urlencode(),)
   
           page_html_list.append(prev_page)
   
           for i in range(pager_start, pager_end):
               #  self.params  : {"page":77,"title":"python","nid":1}
   
               self.params["page"] = i  # {"page":72,"title":"python","nid":1}
               if i == self.current_page:
                   temp = '<li class="active"><a href="%s?%s">%s</a></li>' % (self.base_url, self.params.urlencode(), i,)
               else:
                   temp = '<li><a href="%s?%s">%s</a></li>' % (self.base_url, self.params.urlencode(), i,)
               page_html_list.append(temp)
   
           if self.current_page >= self.all_pager:
               next_page = '<li class="disabled"><a href="#">下一页</a></li>'
           else:
               self.params["page"] = self.current_page + 1
               next_page = '<li><a href="%s?%s">下一页</a></li>' % (self.base_url, self.params.urlencode(),)
           page_html_list.append(next_page)
   
           self.params["page"] = self.all_pager
           last_page = '<li><a href="%s?%s">尾页</a></li>' % (self.base_url, self.params.urlencode(),)
           page_html_list.append(last_page)
   
           return ''.join(page_html_list)
   

   

9. 自定义action