django-admin效果仿写,stark 自定义组件之增删改

 

如下代码都是在同一个类ModelSubject里面写的封装好的方法,

首先是铺垫:

 # 获取展示页面的url
    def get_stand_url(self):
        stand_url = reverse('%s_standlist' % self.namespace)
        return stand_url

    # 获取编辑页面的url
    def get_edit_url(self, obj):
        edit_url = reverse('%s_edit' % self.namespace, args=(obj.pk,))
        return edit_url

    # 获取删除页面的url
    def get_dele_url(self, obj):
        dele_url = reverse('%s_dele' % self.namespace, args=(obj.pk,))
        return dele_url

    # 获取增加页面的url
    def get_add_url(self):
        add_url = reverse('%s_add' % self.namespace)
        return add_url

 

然后是url路径:

url(r'^stark/', site.urls)  # 这一句几乎没有改动过

 

 # ModelForm校验添加和编辑页面
    def get_modelform_class(self):
        from django.forms import widgets

        class AllModelForm(ModelForm):
            class Meta:
                model = self.model
                fields = '__all__'
        if not self.model_form_class:  # 这里的model_form_class在上面被定义了默认是None,
            # 我们的分发下去的App里面自定义的file文件里面注册model类的时候实例化出来的对象,在注册的时候传过来的这个变量
            return AllModelForm
        else:
            return self.model_form_class

 

class ModelSubject(object):
    """
    我们在这里模拟admin源码里面的ModelAdmin,
    """
    list_display = ["__str__"]  # 我们在这里给空列表里面加上"__str__",它就相当于是一个默认值,
    model_form_class = None  # 为下面我们判断用户是否有自定义ModelForm校验方式而做铺垫
    list_display_links = []  # 为我们后面用户是否有自定义可跳转字段做铺垫
    # 就像我们的函数里面有默认值的参数一样,如果有传参就使用我们的自定义传参,如果没有传参就使用我们默认的参数也就是这个字符串,
    # 这里是为了给我们后面的代码做铺垫,我们的目的是在我们的数据展示页面里面默认就会把复选框和编辑还有删除按钮都加上,
    # 在这里把空列表里面添加上一个默认的字符串,是为了我们后面往该列表里面添加默认固定数据也就是复选框和编辑删除按钮做铺垫

    # 静态内置方法
    def __init__(self, model, site):
        self.model = model  # 当我们生成一个实例化对象的时候需要把model这个参数传进来,
        # 必须要传,它是位置参数,然后我们所传入的那个model就是我们在models.py里面定义的每一个表名也就是类名
        self.site = site
        self.namespace = '{}_{}'.format(self.model._meta.app_label, self.model._meta.model_name)
        #

 

  # ModelForm校验数据添加页面
    def add_view(self, request):
        FormClass = self.get_modelform_class()
        if request.method == 'GET':
            form = FormClass()
            return render(request, 'file/add.html', {'form': form})
        else:
            data_list = FormClass(data=request.POST)
            if data_list.is_valid():
                data_list.save()
                return redirect(self.get_stand_url())
            else:
                return render(request, 'file/add.html', {'form': data_list})

    # ModelForm校验数据编辑页面
    def edit_view(self, request, id):
        edit_list = self.model.objects.filter(pk=id).first()
        FormClass = self.get_modelform_class()
        if request.method == 'GET':
            data_list = FormClass(instance=edit_list)
            return render(request, 'file/edit.html', {'form': data_list})
        else:
            data_list = FormClass(data=request.POST, instance=edit_list)
        if data_list.is_valid():
            data_list.save()
            return redirect(self.get_stand_url())
        else:
            return render(request, 'file/edit.html', {'form': data_list})

    # 数据删除页面
    def dele_view(self, request, id):
        del_obj = self.model.objects.filter(pk=id).first()
        if request.method == 'GET':
            stand_url = self.get_stand_url()
            return render(request, 'file/dele.html', {'del_obj': del_obj, 'list_url': stand_url})
        else:
            del_obj.delete()

            return redirect(self.get_stand_url())

 

 

还有一个小功能,我们的admin里面可以让用户自定义显示的表格字段,那些字段可以变成a标签包裹着的能够跳转的字段样式,这里我们只需要很简短的几行代码即可实现:

 

 # 展示页面默认显示按钮被存放的列表
    def get_list_display(self):
        new_li = []
        new_li.extend(self.list_display)  # 我们这里的extend是把它后面的列表里面的数据都取出来放到我们自己的这个列表里面来
        if not self.list_display_links:  # 这里的list_display_links就是我们上面在类里面定义的静态属性的值,在这里被调用,要两处相呼应上,否则会报错
            new_li.append(ModelSubject.edit)  # &&& 跟如下同样特征的代码块相呼应我们在这里使用类名去调用函数名,得到的是一个函数的方法,
        # 函数如果有参数是需要我们传参数的;但是我们如果使用self去调用的话,self就是实例化出来的对象,
        # 而我们的对象去调用函数方法的时候就不需要去传自己了也就是self,
        new_li.append(ModelSubject.dele)
        new_li.insert(0, ModelSubject.checkbox)  # 把checkbox放到第一个位置，使用insert插入到索引为0
        

 

 

还有在展示的时候要做一点点处理:

 # 展示页面
    def stand_li(self, request):
        # print(self.model)
        # 所以我们在这里可以获取到当前的url里面的表名,然后直接使用orm语句即可得到当前表格的所有信息

        # 生成表头数据
        # ['id','title','price',edit]
        header_list = []
        for field in self.get_list_display():
            if callable(field):
                ret = field(self, is_header=True)
                header_list.append(ret)
            else:
                if field == '__str__':  # 这里是判断我们的list_display列表里面是否有我们自定义传入的值,如果没有的话,
                    # 就是直接等于我们在静态属性里面设定的那个默认的'__str__',也就是说如果这一步判断成立,
                    # 那么就证明我们的用户没有自定义展示的字段,我们就需要自己给浏览器一个字段去展示,那个字段就是我们这里所设定的那个大写的表名
                    header_list.append(self.model._meta.model_name.upper())  # 我们这里的操作是
                else:
                    obj = self.model._meta.get_field(field)  # 我们的list_display里面是一个个的字符串,
                    # 把字符串放到get_field里面来可以把我们的字符串转换成类对象,
                    header_list.append(obj.verbose_name)  # 我们这里的verbose_name在model里面是内置方法,
                    # 我们的verbose_name本质上是对我们的字段进行描述的,比如我们的book里面的title可以在字段约束里面设
                    # verbose_name='书名',类似于这样,把它变成中文,然后我们在前端HTML模板里面渲染的时候就可以渲染出来中文了,
                    # 而不是使用默认的英文,当然了我们如果不设置verbose_name的值那么就使用默认的title作为字段名传到浏览器

        # 生成表单数据列表
        ret = self.model.objects.all()
        # print('self.list_display', self.list_display)
        data_list = []
        for obj in ret:  # 我们遍历这个queryset集合得到的obj是它的每一个对象
            temp = []
            for field in self.get_list_display():  # 我们遍历list_display得到每一个字符串
                if callable(field):
                    # res = field(obj)  # @@@更上面的特殊标识的代码块相呼应
                    res = field(self, obj)  # &&& 这里跟上面同样标识的代码块相呼应的,上面我们使用的类名去调用函数名,
                    # 得到的是一个函数,这里就是给所调用的函数传参的,self,和obj都是我们传给函数的参数;
                    # 如果我们使用self这个对象去调用函数名的方法的话,就不需要再传一个self作为参数进去了,我们两种方法都可以,需要对应上即可
                else:
                    res = getattr(obj, field)  # 使用getattr方法去判断该对象是否具有,field属性方法,
                    # getattr里面需要两个参数(类对象,字符串属性方法)
                    if field in self.list_display_links:  # 我们这里是判断表单里面的字段是否在links表格里面被自定义作为可跳转标签,
                        # 如果答案是肯定的,那么我们就需要把a标签给拼出来
                        res = mark_safe("<a href='%s'>%s</a>" % (self.get_edit_url(obj), res))
                temp.append(res)
            data_list.append(temp)

        # print('data_list', data_list)

        """
        我们最终得到的数据类型是如下格式:列表套着列表
        [
        使用orm语句得到的每一个类对象,有几个表格就有几个对象
        ]
        list_display=['id','title',]
        [
        [1,'python',<a>编辑</a>],
        [2,'java',<a>编辑</a>],
        ]
        """
        add_url = self.get_add_url()
    
        return render(request, 'file/hello.html', locals())

 

我们在其他的App程序里面要使用list_display_links就像下面这样用:

from file.tool.tag import site, ModelSubject
from .models import *
from django.forms import ModelForm


class BookConfig(ModelSubject):
     list_display_links = ['title']
site.register(Book, BookConfig)

 

前端模板的增删改:

我们的增加和编辑页面是几乎一样的,我们就写一个自定义标签,在各自的页面上引用一套即可

自定义标签页面(使用的include方法):

<div class="container">
    <div class="row">
        <div class="col-md-8">

            <form action="" method="post" novalidate>
                {% csrf_token %}
                {% for i in form %}
                    <div class="form-group">
                        <label for="">{{ i.label }}</label>
                        <div class="input_style">{{ i }}
                            <span class="error">{{ i.errors.0 }}</span>
                        </div>
                    </div>
                {% endfor %}

                <div class="form-group">
                    <p><input type="submit" class="btn btn-primary"></p>
                </div>

            </form>
        </div>
    </div>
</div>

 

增加页面:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
    <link rel="stylesheet" href="/static/css/base.input.css">
    <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>
    <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
    <title>Title</title>
</head>
<body>
<h3>添加数据</h3>

{% include 'file/base_form.html' %}

</body>
</html>

 

编辑页面:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
    <link rel="stylesheet" href="/static/css/base.input.css">
    <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>
    <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>
    <title>Title</title>
</head>
<body>
<h3>编辑数据</h3>

{% include 'file/base_form.html' %}

</body>
</html>

 

删除页面:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
    <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.js"></script>
    <script src="https://cdn.bootcss.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>

    <title>Title</title>
</head>
<body>

<table class="table table-hover">
    <thead>
    <tr>
        <th>

        </th>
    </tr>
    </thead>
    <tbody>
    <tr>
        <td class="warning">{{ del_obj }}</td>
    </tr>
    </tbody>
</table>

<form action="" method="post">
    {% csrf_token %}
    <input type="submit" class="btn btn-danger" value="确认删除?">
    <a href="{{ list_url }}"></a>
</form>

</body>
</html>

 

还有静态文件配置:

.form-group .input_style input{
    display:block;
    width:100%;
    height:34px;
    padding:6px 12px;
    font-size:14px;
    line-height: 1.42857143;
    color:#555;
    background-color:#fff;
    background-image:none;
    border:1px solid #ccc;
    border-radius:4px;
    -webkit-box-shadow:inset 0 1px 1px rgba(0,0,0, .075);
    box-shadow:inset 0 1px rgba(0,0,0, .075);
    -webkit-transition:border-color
    ease-in-out .15s, -webkit-box-shadow ease-in-out .15s;
    -o-transition:border-color ease-in-out .15s, box-shadow ease-in-out .15s;
    transition: border-color ease-in-out .15s, box-shadow ease-in-out .15s;
}

.error{
    color:red;
}

 

 

我们最核心的组件就是在一个django项目里面创建一个App,然后这个App里面不写views视图函数,在里面要建立一个文件夹,然后里面建立一个文件,这个文件里面就是我们的组件的核心代码块,它的功能就是仿照着我们的django-admin里面的功能去实现的,

下面就是核心代码块:

from django.conf.urls import url
from django.shortcuts import HttpResponse, render, redirect, reverse
from django.utils.safestring import mark_safe
from one.models import *
from two.models import *
from django.forms import ModelForm  # 这个ModelForm里面封装了很强大的功能,要把源码过一遍


class ModelSubject(object):
    """
    我们在这里模拟admin源码里面的ModelAdmin,
    """
    list_display = ["__str__"]  # 我们在这里给空列表里面加上"__str__",它就相当于是一个默认值,
    model_form_class = None  # 为下面我们判断用户是否有自定义ModelForm校验方式而做铺垫
    list_display_links = []  # 为我们后面用户是否有自定义可跳转字段做铺垫
    # 就像我们的函数里面有默认值的参数一样,如果有传参就使用我们的自定义传参,如果没有传参就使用我们默认的参数也就是这个字符串,
    # 这里是为了给我们后面的代码做铺垫,我们的目的是在我们的数据展示页面里面默认就会把复选框和编辑还有删除按钮都加上,
    # 在这里把空列表里面添加上一个默认的字符串,是为了我们后面往该列表里面添加默认固定数据也就是复选框和编辑删除按钮做铺垫

    # 静态内置方法
    def __init__(self, model, site):
        self.model = model  # 当我们生成一个实例化对象的时候需要把model这个参数传进来,
        # 必须要传,它是位置参数,然后我们所传入的那个model就是我们在models.py里面定义的每一个表名也就是类名
        self.site = site
        self.namespace = '{}_{}'.format(self.model._meta.app_label, self.model._meta.model_name)
        # self.app_model_name = (self.model._meta.app_label, self.model._meta.model_name)  # 这里写得跟上面一句是一样的效果,
        # 这里调用的时候需要有两个%s,因为这里是一个元祖,而我们上面的namespace是一个字符串,不是一个元祖,所以只需要一个%s即可,调用的时候就这点区别
    # 我们这里的namespace是因为会频繁使用到所以就把它作为一个内置静态属性写入到这里,其他地方如果要调用它就直接使用self.namespace即可
    # .format的方法:'{}_{}'.format(a,b)

    # 获取展示页面的url
    def get_stand_url(self):
        stand_url = reverse('%s_standlist' % self.namespace)
        return stand_url

    # 获取编辑页面的url
    def get_edit_url(self, obj):
        edit_url = reverse('%s_edit' % self.namespace, args=(obj.pk,))
        return edit_url

    # 获取删除页面的url
    def get_dele_url(self, obj):
        dele_url = reverse('%s_dele' % self.namespace, args=(obj.pk,))
        return dele_url

    # 获取增加页面的url
    def get_add_url(self):
        add_url = reverse('%s_add' % self.namespace)
        return add_url

    # 展示页面默认附带的编辑按钮
    def edit(self, obj=None, is_header=False):
        if is_header:
            return '操作'
        return mark_safe('<a href="%s">编辑</a>' % reverse('%s_edit' % self.namespace, args=(obj.pk,)))

    # 展示页面默认附带的删除按钮
    def dele(self, obj=None, is_header=False):
        if is_header:
            return '删除'
        return mark_safe("<a href='%s'>删除</a>" % reverse('%s_dele' % self.namespace, args=(obj.pk,)))

    # 展示页面附带的默认复选框
    def checkbox(self, obj=None, is_header=False):
        if is_header:
            return mark_safe("<input id='action-toggle' type='checkbox'>")
        return mark_safe("<input type='checkbox' values='%s'>" % obj.pk)

    # 展示页面默认显示按钮被存放的列表
    def get_list_display(self):
        new_li = []
        new_li.extend(self.list_display)  # 我们这里的extend是把它后面的列表里面的数据都取出来放到我们自己的这个列表里面来
        if not self.list_display_links:
            new_li.append(ModelSubject.edit)  # &&& 跟如下同样特征的代码块相呼应我们在这里使用类名去调用函数名,得到的是一个函数的方法,
        # 函数如果有参数是需要我们传参数的;但是我们如果使用self去调用的话,self就是实例化出来的对象,
        # 而我们的对象去调用函数方法的时候就不需要去传自己了也就是self,
        new_li.append(ModelSubject.dele)
        new_li.insert(0, ModelSubject.checkbox)  # 把checkbox放到第一个位置，使用insert插入到索引为0
        """
        # @@@ 跟下面特殊标识的代码块相呼应
        new_li.append(self.edit)
        new_li.append(self.dele)
        new_li.insert(0,self.checkbox)
        """
        return new_li

    # 展示页面
    def stand_li(self, request):
        # print(self.model)
        # 所以我们在这里可以获取到当前的url里面的表名,然后直接使用orm语句即可得到当前表格的所有信息

        # 生成表头数据
        # ['id','title','price',edit]
        header_list = []
        for field in self.get_list_display():
            if callable(field):
                ret = field(self, is_header=True)
                header_list.append(ret)
            else:
                if field == '__str__':  # 这里是判断我们的list_display列表里面是否有我们自定义传入的值,如果没有的话,
                    # 就是直接等于我们在静态属性里面设定的那个默认的'__str__',也就是说如果这一步判断成立,
                    # 那么就证明我们的用户没有自定义展示的字段,我们就需要自己给浏览器一个字段去展示,那个字段就是我们这里所设定的那个大写的表名
                    header_list.append(self.model._meta.model_name.upper())  # 我们这里的操作是
                else:
                    obj = self.model._meta.get_field(field)  # 我们的list_display里面是一个个的字符串,
                    # 把字符串放到get_field里面来可以把我们的字符串转换成类对象,
                    header_list.append(obj.verbose_name)  # 我们这里的verbose_name在model里面是内置方法,
                    # 我们的verbose_name本质上是对我们的字段进行描述的,比如我们的book里面的title可以在字段约束里面设
                    # verbose_name='书名',类似于这样,把它变成中文,然后我们在前端HTML模板里面渲染的时候就可以渲染出来中文了,
                    # 而不是使用默认的英文,当然了我们如果不设置verbose_name的值那么就使用默认的title作为字段名传到浏览器

        # 生成表单数据列表
        ret = self.model.objects.all()
        # print('self.list_display', self.list_display)
        data_list = []
        for obj in ret:  # 我们遍历这个queryset集合得到的obj是它的每一个对象
            temp = []
            for field in self.get_list_display():  # 我们遍历list_display得到每一个字符串
                if callable(field):
                    # res = field(obj)  # @@@更上面的特殊标识的代码块相呼应
                    res = field(self, obj)  # &&& 这里跟上面同样标识的代码块相呼应的,上面我们使用的类名去调用函数名,
                    # 得到的是一个函数,这里就是给所调用的函数传参的,self,和obj都是我们传给函数的参数;
                    # 如果我们使用self这个对象去调用函数名的方法的话,就不需要再传一个self作为参数进去了,我们两种方法都可以,需要对应上即可
                else:
                    res = getattr(obj, field)  # 使用getattr方法去判断该对象是否具有,field属性方法,
                    # getattr里面需要两个参数(类对象,字符串属性方法)
                    if field in self.list_display_links:  # 我们这里是判断表单里面的字段是否在links表格里面被自定义作为可跳转标签,
                        # 如果答案是肯定的,那么我们就需要把a标签给拼出来
                        res = mark_safe("<a href='%s'>%s</a>" % (self.get_edit_url(obj), res))
                temp.append(res)
            data_list.append(temp)

        # print('data_list', data_list)

        """
        我们最终得到的数据类型是如下格式:列表套着列表
        [
        使用orm语句得到的每一个类对象,有几个表格就有几个对象
        ]
        list_display=['id','title',]
        [
        [1,'python',<a>编辑</a>],
        [2,'java',<a>编辑</a>],
        ]
        """
        add_url = self.get_add_url()

        # 生成分页器
        path = request.path_info
        page_num = request.GET.get('page')
        from file.utensil.page import MyPage
        page = MyPage(page_num, len(data_list), path)
        page_html = page.page_html()
        return render(request, 'file/hello.html',
                      {'data_list': data_list[page.start:page.end],
                       'page_html': page_html, 'header_list': header_list, 'add_url': add_url})
        # return render(request, 'file/hello.html', locals())

    """
    元类,
    
    我们定义了类之后,可以用这个类创建出实例对象,这里的大前提是我们要先有类才能有实例化对象,
    那么,问题来了,我们如果想创建类呢,就需要根据metaclass来创建出类,所以,先定义metaclass,然后创建类,所以连接起来就是我们要先定义metaclass,
    就可以创建类,最后再实例化出来对象,所以,metaclass允许你创建类或者修改类,换句话说,我们可以把类看做是metaclass创建出来的"实例",
    
    
    这里面都是啥意思啊,都怎么用啊,对比着我们的ModelForm,这下面的代码块是把ModelForm里面的东西都写活了,
    def _get_modelform(self):
        labels = self.labels if self.labels else None
        error_message = self.error_form if self.error_form else None
        widgets = self.wdigets if self.wdigets else None
        meta_config = type('Meta', (), {
            'model': self.model,
            'fields': '__all__',
            'labels': labels,
            'error_messages': error_message,
            'widgets': widgets
        })
    """

    # ModelForm校验添加和编辑页面
    def get_modelform_class(self):
        from django.forms import widgets

        class AllModelForm(ModelForm):
            class Meta:
                model = self.model
                fields = '__all__'
        if not self.model_form_class:  # 这里的model_form_class在上面被定义了默认是None,
            # 我们的分发下去的App里面自定义的file文件里面注册model类的时候实例化出来的对象,在注册的时候传过来的这个变量
            return AllModelForm
        else:
            return self.model_form_class

    # ModelForm校验数据添加页面
    def add_view(self, request):
        FormClass = self.get_modelform_class()
        if request.method == 'GET':
            form = FormClass()
            return render(request, 'file/add.html', {'form': form})
        else:
            data_list = FormClass(data=request.POST)
            if data_list.is_valid():
                data_list.save()
                return redirect(self.get_stand_url())
            else:
                return render(request, 'file/add.html', {'form': data_list})

    # ModelForm校验数据编辑页面
    def edit_view(self, request, id):
        edit_list = self.model.objects.filter(pk=id).first()
        FormClass = self.get_modelform_class()
        if request.method == 'GET':
            data_list = FormClass(instance=edit_list)
            return render(request, 'file/edit.html', {'form': data_list})
        else:
            data_list = FormClass(data=request.POST, instance=edit_list)
        if data_list.is_valid():
            data_list.save()
            return redirect(self.get_stand_url())
        else:
            return render(request, 'file/edit.html', {'form': data_list})

    # 数据删除页面
    def dele_view(self, request, id):
        del_obj = self.model.objects.filter(pk=id).first()
        if request.method == 'GET':
            stand_url = self.get_stand_url()
            return render(request, 'file/dele.html', {'del_obj': del_obj, 'list_url': stand_url})
        else:
            del_obj.delete()

            return redirect(self.get_stand_url())

    # 获取url,此为第二次分发
    def get_urls(self):
        temp = []
        temp.append(url(r'^$', self.stand_li, name='%s_standlist' % self.namespace))
        temp.append(url(r'^(\d+)/dele/', self.dele_view, name='%s_dele' % self.namespace))
        temp.append(url(r'^(\d+)/edit/', self.edit_view, name='%s_edit' % self.namespace))
        temp.append(url(r'^add/', self.add_view, name='%s_add' % self.namespace))
        return temp

    @property
    def urls(self):
        return self.get_urls()


class Stark(object):
    """
    我们这里面的功能是可以跟上面的类写到一起去的,但是我们为了功能解耦,所以就分开写了,这里的主要功能就是
    生成registry的字典,把键值对生成,然后我们最终的结果是要得到一个实例化对象,供我们后面的程序调用,这里的类才是主要的,核心的代码块
    而我们上面的那个ModelSubject是辅助我们这里的功能,它之所以分发出去是为了便于扩展其他的功能,我们的自定义样式,
    还有很多的方法和参数,就像我们的admin里面的ModelAdmin一样,长达1400多行代码,单独把它分离出去便于功能的扩展
    """

    def __init__(self):
        self._registry = {}  # 这里是定义一个私有属性,就是为了避免被子类修改

    # 注册model表
    def register(self, model, model_config=None):  # 我们是仿照着admin的源码写的组件,这里的model_config默认值是None,
        # 我们在传参的时候,如果给它传值,那么就使用我们传入的值替换掉这个None
        # 它的源码里面有这几个参数,我们也要按照顺序把这几个参数加进来
        if not model_config:
            model_config = ModelSubject  # 我们这里的model_config我们上面的类ModelSubject实例化出来的对象,
            # 它是上面的类所实例化出来的对象,这一句写得明明白白的,这大白话再看不懂就真是白学了,
        self._registry[model] = model_config(model, self)

    # 获取url,第一次分发
    def get_urls(self):
        li = []
        for model, model_config in self._registry.items():  # 我们在这里所循环的model_config就是
            # 我们往上数第四行所实例化出来的那个model_config,它是上面的ModelSubject这个类所实例化出来对象,
            model_name = model._meta.model_name  # 这里的._meta.model_name是获取字符串格式的类名,
            app_label = model._meta.app_label  # 这里的._meta.app_labe获取的是字符串格式的App名,都是为了跟url做匹配,
            sli = url(r'%s%s/' % (app_label, model_name), (model_config.urls, None, None))  # 我们这里的model_config,
            # 它后面的.urls是在调用一个私有方法,我们的私有方法就是使用.urls来调用,不用加上括号,
            # 因为有@property这个装饰器在里面起到的作用,然后我们需要找到model_config这个实例对象是哪个类生成的,
            # 然后找到该类所拥有的方法,从里面找到urls,届时,那个urls就是我们在这里调用的那个urls了,
            # 所以关键的点就是我们的model_config,老师讲课的时候一再地强调过这个model_config从何而来,这个是关键,
            li.append(sli)
        return li

    # 我们最终的数据结构就是这样的,嵌套多层
    # [
    # url(
    # r'',(
    # [
    # (url(r'',views.add)),
    # (url(r'',views.edit)),
    # ],
    # none,none)
    # )
    # ]
    @property
    def urls(self):
        return self.get_urls(), None, None


site = Stark()

 

我们的组件App里面有一个apps.py文件

from django.apps import AppConfig
from django.utils.module_loading import autodiscover_modules


class FileConfig(AppConfig):
    name = 'file'

    def ready(self):
        autodiscover_modules('file')  # 这里是自动扫描的意思,系统会自动把所有名字带file的文件都加载出来,
        # 扫描即加载的意思,这个名字就是随意起的,但是前提是你必须要对应上才可以,文件名和文件夹的名字,我们要想使用我们自己写的组件就需要在所有要使用它的App里面建立一个文件,文件名要是我们上面的类里面的静态属性name的值才可以,否则都不能用这个name的属性值就是调用的接口

然后就是我们的各个其他的App里面要使用我们自定义的组件的就在指定文件名的文件里面写即可

 

class BookConfig(ModelSubject):
     list_display = ['id', 'title']
    list_display_links = ['title']
site.register(Book)

 

我们来整理一下逻辑:我们先看一下我们的admin里面的源码实现逻辑,我们的admin里面就只有一个admin.site的url,然后它就可以实现我们所有已经注册表格的增删改查功能,我们要使用同样的方法也是一句话就实现我们的所有表格的增删改查功能,所以url的配置是最关键的一环,没有它一切都是徒劳,

我们在admin的源码里面可以看到它定义了一个类然后用这个类实例化出来的对象命名为site,它调用了一个resister方法,就可以达到注册表格的效果,我们也先这样写,然后把源码里面的register的核心代码copy过来,再把与之相关联的url的生成代码逻辑拿过来用,然后这个实例化出来的对象就形成了,再把延展性的功能都搭建起来,就可以一步一步走下去了,