可插拔式后台管理系统（Django）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

1.实现效果

研究了下django admin的功能，自己实现了一个简单的可插拔式后台管理系统，方便自定义特殊的功能，而且作为一个独立单独的django app，可以整体拷贝到其他项目中作为后台数据管理系统，对数据进行增删改查和自定义操作。下图是拷贝到一个图书管理系统中的后台效果：

2.实现思路

2.1 url的设计和分发

Django自带的admin，对于不同app的不同model表，都会动态的生成类似下面的四条url，分别对应着后台数据的增删改查页面。而为了实现动态路由需要配置两处，一是在项目全局urls.py文件中urlpatterns = [ url(r'^admin/', admin.site.urls),]，二是在每个app的admin.py文件中对model表进行了注册admin.site.register(model)，这两处都涉及到了一个admin.site对象，因此我们需要实现自己的site对象即可。

查看：http://127.0.0.1:8008/admin/app01/book/

添加：http://127.0.0.1:8008/admin/app01/book/add/

更新：http://127.0.0.1:8008/admin/app01/book/1/change/

删除：http://127.0.0.1:8008/admin/app01/book/1/delete/

另外，对于django的url多级路由格式需要了解下：url(r" ",([ url(), url()], None, None)), 为一个三元元祖（[],None,None），而元祖中的列表[]又可以嵌套多个相同格式的url([],None,None)，如下面的代码实现了三条路由：

url(r'^myAdmin2/', ([ url(r'^book1/',views.index1),
url(r'^book2/',([ url(r'^change/',views.index2), url(r'^add/',views.index3)],None,None ))],
None,None),)
对应的url如下：

http://127.0.0.1:8008/myAdmin2/book1/

http://127.0.0.1:8008/myAdmin2/book2/change/

http://127.0.0.1:8008/myAdmin2/book2/add/

根据上述的思路和多级url路由，可以定义同样的路由设置，一是设置urls.py中全局路由，二是在app的admin.py文件中注册model，三是实现自己的myAdmin.site对象。对应的代码依次如下：

urls.py

from django.conf.urls import urlfrom myAdmin.service.site import site # 引入自定义的site.py 文件中生成的site单例对象
urlpatterns = [
url(r'^myAdmin/', site.urls),
]

app01/admin.py

from myAdmin.service.site import site
from app01 import models
site.register(models.Book)
site.register(models.Author)
site.register(models.Publish)

myAdmin/service/site.py

class ModelAdmin(object):
def __init__(self, model):
self.model = model
self.model_name = self.model._meta.model_name
self.app_label = self.model._meta.app_label @property
def urls(self):
return self.get_urls(), None, None def get_urls(self):
patterns = [url(r'^$', self.list_view, name='%s_%s_list'%(self.model_name,self.app_label)),
url(r'^add/$', self.add_view,name='%s_%s_add'%(self.model_name,self.app_label)),
url(r'^(.+)/change/$', self.change_view,name='%s_%s_change'%(self.model_name,self.app_label)),
url(r'^(.+)/delete/$', self.delete_view,name='%s_%s_delete'%(self.model_name,self.app_label)),
]
return patternsclass AdminSite(object):
def __init__(self):
self._registry = {} def register(self, model, admin_class=None): #对应model表注册时的site.register（）
if not admin_class:
admin_class = ModelAdmin
admin_obj = admin_class(model)
self._registry[model] = admin_obj @property
def urls(self): #对应全局路由中的site.urls
return self.get_urls(), None, None def get_urls(self):
patterns = []
for model, admin_obj in self._registry.items():
urls = url(r'^{0}/{1}/'.format(model._meta.app_label, model._meta.model_name), admin_obj.urls)
patterns.append(urls)
return patternssite = AdminSite()

在site.py代码中有三处值得注意，

1. site = AdminSite()，这里是采用了python模块的天然单例模式，由于每个app中都会采用site对象，因此在整个项目中只能有一个site对象。

2. AdminSite中的get_urls(self)函数

urls = url(r'^{0}/{1}/'.format(model._meta.app_label, model._meta.model_name), admin_obj.urls) 实现了第一级动态路由，即/app01/model/

3. ModelAdmin中的get_urls(self)函数

patterns = [url(r'^$', self.list_view, name='%s_%s_list'%(self.model_name,self.app_label)),

url(r'^add/$', self.add_view,name='%s_%s_add'%(self.model_name,self.app_label)),

url(r'^(.+)/change/$', self.change_view,name='%s_%s_change'%(self.model_name,self.app_label)),

url(r'^(.+)/delete/$', self.delete_view,name='%s_%s_delete'%(self.model_name,self.app_label)), ]

实现了第二级动态路由，即 app01/model, app01/model/add/, app01/model/id/change/, app01/model/id/delete 增删改查四条路径。

2.2 实现增删改查处理函数

在上面url设计中，在ModelAdmin类中定义了相应的处理函数，如下面self.list_view，self.add_view，self.change_view，self.delete_view，需要对其依次实现。

patterns = [url(r'^$', self.list_view, name='%s_%s_list'%(self.model_name,self.app_label)),

url(r'^add/$', self.add_view,name='%s_%s_add'%(self.model_name,self.app_label)),

url(r'^(.+)/change/$', self.change_view,name='%s_%s_change'%(self.model_name,self.app_label)),

url(r'^(.+)/delete/$', self.delete_view,name='%s_%s_delete'%(self.model_name,self.app_label)), ]

实现后的site.py代码如下：由于需要用到ModelForm类，定义了两个辅助方法get_modelform_class（）和 change_modelform（）

def get_modelform_class(self):
class Model_form(ModelForm):
class Meta:
model = self.model
fields = '__all__'
return Model_form #返回类对象 def change_modelform(self,modelform):
for item in modelform:
if isinstance(item.field, ModelChoiceField): # ModelChoiceField表示field字段对应的为外键或多对对关系
pop_item_name = item.name
item.is_pop=True #为实例动态绑定属性
item_model_name = item.field.queryset.model._meta.model_name
item_app_label = item.field.queryset.model._meta.app_label
item.pop_url = '/myAdmin/{0}/{1}/add/?pop_item_name={2}'.format(item_app_label, item_model_name,pop_item_name)
return modelform
#添加数据
def add_view(self, request):
modelform_class = self.get_modelform_class()
form = modelform_class()
form = self.change_modelform(form)
if request.method == 'POST':
form = modelform_class(request.POST)
field_obj = form.save()
# url = request.path[:-]
# print url
pop_item_name = request.GET.get('pop_item_name')
if pop_item_name:
result = {'pk':field_obj.pk,'text':str(field_obj),'pop_item_name':pop_item_name}
return render(request, 'process_pop.html', {'result':result})
return redirect(self.get_list_url())
return render(request, 'add_view.html', locals()) # 改变数据
def change_view(self, request, number):
modelform_class = self.get_modelform_class()
model_obj = self.model.objects.filter(id=number).first()
form = modelform_class(instance=model_obj)
form = self.change_modelform(form)
if request.method == 'POST':
form = modelform_class(request.POST, instance=model_obj)
form.save()
return redirect(self.get_list_url())
return render(request, 'change_view.html', locals()) # 删除数据
def delete_view(self, request, number):
model_obj = self.model.objects.get(id=number)
list_url = self.get_list_url()
edit_url = self.get_change_url(model_obj)
if request.method=='POST':
model_obj.delete()
return redirect(list_url)
return render(request, 'delete_view.html', locals())

site.py

list_view 较为复杂，上面没列出，下面单独列出代码。因为list_view界面中还支持搜索，分类和批量处理三个功能，list_view必须对这三种请求进行捕获和处理。从下面代码中可以看到：定义了两个辅助方法，get_search_condition（）和get_filter_condition（）来处理搜索和分类过滤（详细见自定义字段的实现）。搜索框和分类过滤器请求通过GET请求提交，get_search_condition（）处理搜索框提交的GET请求，将搜索条件封装成一个Q对象返回，get_filter_condition（）处理过滤器提交的GET请求，返回Q对象。actions的请求（批量处理）通过POST请求提交，将批处理函数和选定项提交到request.POST，然后list_view进行处理。实现代码如下：

#处理搜索框提交的请求
def get_search_condition(self,request):
search_connector = Q()
if request.method=='GET':
search_content = request.GET.get('search_content','')
search_connector.connector = 'or'
if search_content and self.search_field:
for field in self.search_field:
# field_obj = self.model._meta.get_field(field)
# if isinstance(field_obj,ManyToManyField) or isinstance(field_obj,ForeignKey):
# search_connector.children.append((field + '__name__contains', search_content)) #对于多对多关系,如何实现动态？
# else:
search_connector.children.append((field + '__contains', search_content))
return search_connector #处理过滤标签的<a>标签提交的请求
def get_filter_condition(self,request):
filter_connector = Q()
if request.method == 'GET':
for filter_field, value in request.GET.items():
if filter_field in self.list_filter: # 设置分页后url会出现page参数，不应做为过滤条件
filter_connector.children.append((filter_field, value))
return filter_connector#查看：显示数据
def list_view(self, request):
model = self.model
if request.method == 'POST':
choice_item = request.POST.get('choice_item')
selected_item = request.POST.getlist('selected_item')
action_func = getattr(self,choice_item)
queryset = model.objects.filter(id__in =selected_item)
action_func(queryset)
search_condition = self.get_search_condition(request)
filter_condition = self.get_filter_condition(request)
model_list = model.objects.all().filter(search_condition).filter(filter_condition)
showlist= Showlist(self,model_list,model,request) #单独抽象出一个类，用来配置前端数据的显示
return render(request, 'list_view.html', locals())

2.3 自定义字段的实现

在ModelAdmin中可以定义相应的字段，对数据管理显示界面进行设置，从而在model进行注册时能根据需求对这些字段进行更改和扩展，展示出不同的显示效果。下面定义了显示字段，过滤器，搜索和批处理等：

class ModelAdmin(object):
list_display = ('__str__',) #自定义显示的字段
list_display_links = ()#自定义超链接字段，点击进入编辑页面
list_filter = ()#自定义过滤器字段，根据该字段分类
search_field = ()#自定义搜索字段，搜索的内容和这些字段进行匹配
actions = ()#自定义批处理函数

list_display 的扩展

下面代码为list_display的实现，首先在list_display中加入默认的选择框，编辑和删除超链接，然后对用户配置的list_play进行扩展，得到完整的list_play，再进行渲染，代码如下：

# 定义默认要显式的内容，编辑，删除操作和选择框，并扩展list_display
def edit(self,model_obj=None,isHeader=False): #model_obj: 一个model表对象，isHeader是否是表格的表头字段
if isHeader:
return '操作'
return mark_safe(
'<a href="%s/change/">编辑</a>' % model_obj.pk) # 注意href="%s/change/ 和 href="/%s/change/的区别,前者为当前目录，后者为根目录 def checkbox(self,model_obj=None, isHeader=False):
if isHeader:
return '选择'
return mark_safe('<input type="checkbox" value="%s" name="selected_item"/>'%model_obj.pk) def delete(self,model_obj=None, isHeader=False):
if isHeader:
return '操作'
return mark_safe(
'<a href="%s/delete/">删除</a>' % model_obj.pk) def get_list_display(self):
new_list_display = []
new_list_display.append(ModelAdmin.checkbox)#加入选择框
new_list_display.extend(self.list_display) #加入用户配置的list_display
if not self.list_display_links:
new_list_display.append(ModelAdmin.edit) #如果用户未配置超链接字段，加入编辑操作
new_list_display.append(ModelAdmin.delete)#加入删除操作
return new_list_display

上面代码拿到了一个完整的list_display=(checkbox, '', '', exit, delete)，而对于list_display的处理和前端显示见下面Showlist 类。

actions 的扩展

和list_diaplay一样，下面代码中，在actions加入默认的批量删除函数，并扩展用户配置的actions批处理函数，拿到了一个完整的actions=(batch_delete, ), 其处理和前端显示见后面Showlist 类

#定义默认的批量删除函数，并扩展用户actions
def batch_delete(self,queryset):
queryset.delete()
batch_delete.short_description = '批量删除' def get_actions(self):
new_actions = []
new_actions.append(ModelAdmin.batch_delete) # 加入批量删除操作
new_actions.extend(self.actions)# 扩展用户配置actions
return new_actions

在实现list_view()函数时，用到了一个单独的类Showlist, 其中定义了 list_diaplay, list_play_links, list_filter, search_field 和 actions的处理和前端显示逻辑，代码如下：

class Showlist(object):
'''
需要四个参数来初始化实例：
model_config: ModelAdmin 的实例对象，决定了其相关配置项
model_list: 发送给前端的表格中要展示的数据对象（Queryset）
model：数据表对象
request：视图函数中的request参数
''' def __init__(self,model_config,model_list,model,request):
self.model_config = model_config
self.model_list = model_list
self.model = model
self.request = request # 设置分页
current_page = int(request.GET.get('page',1))
params = self.request.GET
base_url = self.request.path
all_count = self.model_list.count()
#print 'all_count',all_count
self.page = page.Pagination(current_page, all_count, base_url, params, per_page_num=4, pager_count=3,)
self.page_data = self.model_list[self.page.start:self.page.end]# 前端actions的显示数据
def get_action_desc(self):
# actions
list_actions = []
if self.model_config.get_actions():
for action in self.model_config.get_actions():
list_actions.append({
"name": action.__name__, #批处理函数的名字
"desc": action.short_description
})
return list_actions

# 前端过滤器的显示数据
def get_filter_dict(self):
filter_dict = {}
for field in self.model_config.list_filter:
params = copy.deepcopy(self.request.GET)
selection = self.request.GET.get(field, 0)
field_obj = self.model._meta.get_field(field)
if isinstance(field_obj, ForeignKey) or isinstance(field_obj, ManyToManyField): #对于多对多或外键字段的处理
data_list = field_obj.rel.to.objects.all()#field_obj.rel.to 能拿到多对多或外键字段对应的另一张model表对象
else:
data_list = self.model.objects.all().values('pk', field)
temp = []
if params.get(field): #url参数的过滤条件中，如果有该字段的过滤条件，则点击全部时应该删除该字段的过滤条件，从而显示全部数据；
del params[field]
temp.append("<a href='?%s' class='list-group-item is_selected'>全部</a>" % params.urlencode())
else:#不含有该字段的过滤条件，点击时不处理
temp.append("<a href='#' class='list-group-item'>全部</a>")
for item in data_list:
if isinstance(field_obj, ForeignKey) or isinstance(field_obj, ManyToManyField): #多对多或外键字段，拿到的为对象
id = item.pk
text = str(item)
params[field] = id #多对多或外键字段，以id做为过滤条件
else: #普通字段拿到的为字典
id = item['pk']
text = item[field]
params[field] = text #普通字段以字段名称做为过滤条件
tag_url = params.urlencode()
if selection == str(id) or selection == text: #判断此时url过滤字段中选中的条件，为其添加特殊style样式
temp.append("<a href='?%s' class='list-group-item is_selected'>%s</a>" % (tag_url, text))
else:
temp.append("<a href='?%s' class='list-group-item'>%s</a>" % (tag_url, text))
filter_dict[field_obj] = temp
return filter_dict
#前端表格表头的显示数据
def get_head_list(self):
head_list = []
for field in self.model_config.get_list_display():
if isinstance(field, str): #判断函数和字符窜
if field == '__str__':#用户未配置时默认的list_play=('__str__',)
value = self.model._meta.model_name
else:
field_obj = self.model._meta.get_field(field) # 拿到字符窜对应的field对象
value = field_obj.verbose_name # 通过拿到verbose_name 来显示中文
else:
value = field(self.model_config, isHeader=True) # 获取标题，传入isHeader, 注意此处传入的self.model_config
if value:
head_list.append(value)
return head_list
#前端表格内容的显示数据
def get_data_list(self):
data_list = []
for model_obj in self.page_data: #分页截取的某一页的数据列表
row_list = []
for field in self.model_config.get_list_display():
if isinstance(field, str): #判断是字符窜或函数
try :
field_obj = self.model_config.model._meta.get_field(field) #判断设置的显式列是否为多对多关系，处理相应的多个数据
if isinstance(field_obj, ManyToManyField):
temp_list = getattr(model_obj, field).all()
#print temp_list
ret = []
for temp in temp_list:
#print temp
ret.append(str(temp)) #转换为字符窜后进行拼接
value = ','.join(ret)
#print value
else:
value = getattr(model_obj, field) # 通过反射拿到字符窜对应的值
if field in self.model_config.list_display_links: # 判断该字段是否设置为超链接，放在此处表明了多对多关系设置在超链接列中无效
value = mark_safe('<a href="%s/change/">%s</a>' % (model_obj.pk, value))
except Exception as e:
#print e
value = getattr(model_obj, field)
else:
value = field(self.model_config, model_obj) # 获取内容，传入model_obj,不用传入isHeader
if value:
row_list.append(value)
data_list.append(row_list)
# print data_list
return data_list

2.4 增加自定义的url 路径

可以为某个model表单独增加一个url接口，来处理特殊的业务；首先需要在site.py 文件中定义接口，然后在app的admin.py注册文件中进行定义处理逻辑。在下面的代码中model表通过覆盖父类的extra_urls()函数来增加了一条url和相应的处理逻辑。

site.py定义的接口如下：

def get_urls(self): patterns = [url(r'^$', self.list_view, name='%s_%s_list'%(self.model_name,self.app_label)),
url(r'^add/$', self.add_view,name='%s_%s_add'%(self.model_name,self.app_label)),
url(r'^(.+)/change/$', self.change_view,name='%s_%s_change'%(self.model_name,self.app_label)),
url(r'^(.+)/delete/$', self.delete_view,name='%s_%s_delete'%(self.model_name,self.app_label)),
]
patterns.extend(self.extra_url())
return patterns #定义url接口，modelConfigure通过继承覆盖来配置额外的url
def extra_url(self):
return []

admin.py 定义处理逻辑如下：

class BookConfig(ModelAdmin):
# 通过下面三个函数，为book添加一条单独的url处理逻辑，实现点击id值，为title添加喜欢或不喜欢
def list_id(self,model_obj=None, isHeader=False):
if isHeader:
return 'ID'
return mark_safe('<a href="like_book/%s">%s</a>'%(model_obj.pk, model_obj.pk))
def like_book(self,request,obj_id):
model_obj = models.Book.objects.get(id = obj_id)
if '(喜欢)' not in model_obj.title:
new_title = '%s (喜欢)'%model_obj.title
else:
new_title = model_obj.title.replace('(喜欢)','')
models.Book.objects.filter(id=obj_id).update(title = new_title)
return redirect(self.get_list_url())
def extra_url(self):
temp = [url(r'like_book/(\d+)',self.like_book)]
return temp
list_display = (list_id, 'title','price','author','publish')
site.register(models.Book,BookConfig)