Django-admin管理工具

時間 2019-11-11

原文原文鏈接

admin組件的使用

Django 提供了基於 web 的管理工具。javascript

Django 自動管理工具是 django.contrib 的一部分。你能夠在項目的 settings.py 中的 INSTALLED_APPS 看到它：css

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    "app01"
]

django.contrib是一套龐大的功能集，它是Django基本代碼的組成部分。html

1. 激活管理工具java

一般咱們在生成項目時會在 urls.py 中自動設置好，python

from django.conf.urls import url
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),

]

當這一切都配置好後，Django 管理工具就能夠運行了。git

2. 使用管理工具web

啓動開發服務器，而後在瀏覽器中訪問 http://127.0.0.1:8000/admin/，獲得登錄界面，你能夠經過命令 python manage.py createsuperuser 來建立超級用戶。django

爲了讓 admin 界面管理某個數據模型，咱們須要先註冊該數據模型到 admin設計模式

from django.db import models

# Create your models here.

class Author(models.Model):

    name=models.CharField( max_length=32)
    age=models.IntegerField()

    def __str__(self):
        return self.name

class Publish(models.Model):

    name=models.CharField( max_length=32)
    email=models.EmailField()

    def __str__(self):
        return self.name

class Book(models.Model):

    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)

    publisher=models.ForeignKey(to="Publish")
    authors=models.ManyToManyField(to='Author')

    def __str__(self):
        return self.title

models

3. admin的定製瀏覽器

在admin.py中只須要講Mode中的某個類註冊，便可在Admin中實現增刪改查的功能，如：

admin.site.register(models.UserInfo)

可是，這種方式比較簡單，若是想要進行更多的定製操做，須要利用ModelAdmin進行操做，如：

方式一：
    class UserAdmin(admin.ModelAdmin):
        list_display = ('user', 'pwd',)
 
    admin.site.register(models.UserInfo, UserAdmin) # 第一個參數能夠是列表
     
 
方式二：
    @admin.register(models.UserInfo)                # 第一個參數能夠是列表
    class UserAdmin(admin.ModelAdmin):
        list_display = ('user', 'pwd',)

列表的意思就是能夠同時註冊，以避免代碼重複

ModelAdmin中提供了大量的可定製功能，如

1. list_display，列表時，定製顯示的列。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    list_display = ('user', 'pwd', 'xxxxx')

2. list_display_links，列表時，定製列能夠點擊跳轉到當前對象編輯頁面。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    list_display = ('user', 'pwd', 'xxxxx')
    list_display_links = ('pwd',)

3. list_filter，列表時，定製右側快速篩選，能夠組合篩選。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    list_display = ('user', 'pwd', 'xxxxx')
    list_filter=('pub_date','title')

4. list_select_related，列表時，連表查詢是否自動select_related。

5. list_editable，列表時，能夠編輯的列。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    list_display = ('title', 'price', 'pub_date') 
    list_editable=('price',)

6. search_fields，列表時，模糊搜索的功能。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    search_fields = ('user', 'pwd')
    會在頁面產生一個搜索框，搜索的字段爲user,pwd字段，能夠模糊匹配

7. date_hierarchy，列表時，對Date和DateTime類型進行搜索。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    date_hierarchy = 'ctime'

8 inlines，詳細頁面，若是有其餘表和當前表作FK，那麼詳細頁面能夠進行動態增長和刪除。

class BookInline(admin.StackedInline):
    extra = 0
    model = Book  # 書籍 的表

class PublishAdmin(admin.ModelAdmin):
    list_display=("name",)
    inlines =[BookInline,] # 關聯 書籍，要建立在一上面，才能建立更多的書籍

9 action，列表時，定製action中的操做。

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
 
    # 定製Action行爲具體方法
    def func(self, request, queryset):
        print(self, request, queryset)
        print(request.POST.getlist('_selected_action'))
 
    func.short_description = "中文顯示自定義Actions"
    actions = [func, ]
 
    # Action選項都是在頁面上方顯示
    actions_on_top = True
    # Action選項都是在頁面下方顯示
    actions_on_bottom = False
 
    # 是否顯示選擇個數
    actions_selection_counter = True

10 定製HTML模板.

add_form_template = None
change_form_template = None
change_list_template = None
delete_confirmation_template = None
delete_selected_confirmation_template = None
object_history_template = None

change_list_template = "my_change_list.html"

{% extends "admin/base_site.html" %}
{% load i18n admin_urls static admin_list %}

{% block extrastyle %}

    <h1>yuAN</h1>
    
    
  {{ block.super }}
  <link rel="stylesheet" type="text/css" href="{% static "admin/css/changelists.css" %}" />
  {% if cl.formset %}
    <link rel="stylesheet" type="text/css" href="{% static "admin/css/forms.css" %}" />
  {% endif %}
  {% if cl.formset or action_form %}
    <script type="text/javascript" src="{% url 'admin:jsi18n' %}"></script>
  {% endif %}
  {{ media.css }}
  {% if not actions_on_top and not actions_on_bottom %}
    <style>
      #changelist table thead th:first-child {width: inherit}
    </style>
  {% endif %}
{% endblock %}

{% block extrahead %}
{{ block.super }}
{{ media.js }}
{% endblock %}

{% block bodyclass %}{{ block.super }} app-{{ opts.app_label }} model-{{ opts.model_name }} change-list{% endblock %}

{% if not is_popup %}
{% block breadcrumbs %}
<div class="breadcrumbs">
<a href="{% url 'admin:index' %}">{% trans 'Home' %}</a>
&rsaquo; <a href="{% url 'admin:app_list' app_label=cl.opts.app_label %}">{{ cl.opts.app_config.verbose_name }}</a>
&rsaquo; {{ cl.opts.verbose_name_plural|capfirst }}
</div>
{% endblock %}
{% endif %}

{% block coltype %}flex{% endblock %}

{% block content %}
  <div id="content-main">
    {% block object-tools %}
        <ul class="object-tools">
          {% block object-tools-items %}
            {% if has_add_permission %}
            <li>
              {% url cl.opts|admin_urlname:'add' as add_url %}
              <a href="{% add_preserved_filters add_url is_popup to_field %}" class="addlink">
                {% blocktrans with cl.opts.verbose_name as name %}Add {{ name }}{% endblocktrans %}
              </a>
            </li>
            {% endif %}
          {% endblock %}
        </ul>
    {% endblock %}
    {% if cl.formset.errors %}
        <p class="errornote">
        {% if cl.formset.total_error_count == 1 %}{% trans "Please correct the error below." %}{% else %}{% trans "Please correct the errors below." %}{% endif %}
        </p>
        {{ cl.formset.non_form_errors }}
    {% endif %}
    <div class="module{% if cl.has_filters %} filtered{% endif %}" id="changelist">
      {% block search %}{% search_form cl %}{% endblock %}
      {% block date_hierarchy %}{% date_hierarchy cl %}{% endblock %}

      {% block filters %}
        {% if cl.has_filters %}
          <div id="changelist-filter">
            <h2>{% trans 'Filter' %}</h2>
            {% for spec in cl.filter_specs %}{% admin_list_filter cl spec %}{% endfor %}
          </div>
        {% endif %}
      {% endblock %}

      <form id="changelist-form" method="post"{% if cl.formset.is_multipart %} enctype="multipart/form-data"{% endif %} novalidate>{% csrf_token %}
      {% if cl.formset %}
        <div>{{ cl.formset.management_form }}</div>
      {% endif %}

      {% block result_list %}
          {% if action_form and actions_on_top and cl.show_admin_actions %}{% admin_actions %}{% endif %}
          {% result_list cl %}
          {% if action_form and actions_on_bottom and cl.show_admin_actions %}{% admin_actions %}{% endif %}
      {% endblock %}
      {% block pagination %}{% pagination cl %}{% endblock %}
      </form>
    </div>
  </div>
{% endblock %}

my_change_list.html

11 raw_id_fields，詳細頁面，針對FK和M2M字段變成以Input框形式

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    raw_id_fields = ('FK字段', 'M2M字段',)

12 fields，詳細頁面時，顯示字段的字段

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    fields = ('user',)

13 exclude，詳細頁面時，排除的字段

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    exclude = ('user',)

14 readonly_fields，詳細頁面時，只讀字段

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    readonly_fields = ('user',)

15 fieldsets，詳細頁面時，使用fieldsets標籤對數據進行分割顯示

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    fieldsets = (
        ('基本數據', {
            'fields': ('user', 'pwd', 'ctime',)
        }),
        ('其餘', {
            'classes': ('collapse', 'wide', 'extrapretty'),  # 'collapse','wide', 'extrapretty'
            'fields': ('user', 'pwd'),
        }),
    )

16 詳細頁面時，M2M顯示時，數據移動選擇（方向：上下和左右）

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    filter_vertical = ("m2m字段",) # 或filter_horizontal = ("m2m字段",)

17 ordering，列表時，數據排序規則

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    ordering = ('-id',)
    或
    def get_ordering(self, request):
        return ['-id', ]

18. radio_fields，詳細頁面時，使用radio顯示選項（FK默認使用select）

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    radio_fields = {'publish':admin.VERTICAL}

19 form = ModelForm，用於定製用戶請求時候表單驗證，默認都是英文的錯誤

class myform(ModelForm):
    class Meta:
        model = Book
        fields = '__all__'
        error_messages = {
            'title':{'required':'不能爲空　'}
        }

class bookadmin(admin.ModelAdmin):
    list_display =  ('title','price','pub_date',)

form = myform

admin.site.register(Book,bookadmin)

20 empty_value_display = "列數據爲空時，顯示默認值"

@admin.register(models.UserInfo)
class UserAdmin(admin.ModelAdmin):
    empty_value_display = "列數據爲空時，默認顯示"
 
    list_display = ('user','pwd','up')
 
    def up(self,obj):
        return obj.user
    up.empty_value_display = "指定列數據爲空時，默認顯示"

admin源碼解析

1 單例模式

單例模式（Singleton Pattern）是一種經常使用的軟件設計模式，該模式的主要目的是確保某一個類只有一個實例存在。當你但願在整個系統中，某個類只能出現一個實例時，單例對象就能派上用場。

好比，某個服務器程序的配置信息存放在一個文件中，客戶端經過一個 AppConfig 的類來讀取配置文件的信息。若是在程序運行期間，有不少地方都須要使用配置文件的內容，也就是說，不少地方都須要建立 AppConfig 對象的實例，這就致使系統中存在多個 AppConfig 的實例對象，而這樣會嚴重浪費內存資源，尤爲是在配置文件內容不少的狀況下。事實上，相似 AppConfig 這樣的類，咱們但願在程序運行期間只存在一個實例對象。

在 Python 中，咱們能夠用多種方法來實現單例模式：

使用模塊
使用 __new__
使用裝飾器（decorator）
使用元類（metaclass）

1.1 使用模塊

其實，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()

1.2 使用__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)

補充，靜態方法，類方法（也能夠建立單例模式）

class Foo(object):
    _instance = None  # 類屬性

    def __init__(self, name):
        self.name = name

    @classmethod     # 類方法   cls == foo
    def instance(cls, *args, **kwargs):
        if not cls._instance:    # 若是爲空
            obj = cls(*args, **kwargs)   # 實例化
            cls._instance = obj  # 賦予類屬性
        return Foo._instance # _instance == cls(*args, **kwargs) == foo(*args,**kwargs) == 就是本身

    @staticmethod    # 靜態方法
    def static(name):
        print(name)
        return name


# 單例模式，由於類屬性在編譯的時候會加載到內存 (類屬性構造)
# obj1 = Foo.instance('alex')
# obj2 = Foo.instance('alex')
# print(id(obj1), id(obj2))


# 靜態方法
# Foo.static('alex')  # 靜態方法脫離類，外部能夠直接經過類調用，不須要實例化，傳參也跟類沒有關係，至關於普通函數
# obj = Foo('egon')   # 實例化
# print(obj.static('alex'))   # 經過實例化調用，再給個參數，這樣顯得不論不類



class Singleton(object):
    _instance = None  # 類屬性
    def __new__(cls, *args, **kwargs):
        if not cls._instance:  # 若是爲None
            cls._instance = super(Singleton, cls).__new__(cls, *args ,**kwargs)    # Singleton 父類，cls子類__(cls,*args,**kwargs)
        return cls._instance
    
# 單例模式，同上面相同（new方法）
# ret1 = Singleton()
# print(ret1._instance)  # <__main__.Singleton object at 0x1023089e8>
# ret2 = Singleton()
# print(ret2._instance)

1.3 使用裝飾器

咱們知道，裝飾器（decorator）能夠動態地修改一個類或函數的功能。這裏，咱們也可使用裝飾器來裝飾某個類，使其只能生成一個實例，代碼以下：

from functools import wraps

def singleton(cls):
    instances = {}
    @wraps(cls)
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance

@singleton
class MyClass(object):
    a = 1

在上面，咱們定義了一個裝飾器 singleton，它返回了一個內部函數 getinstance，該函數會判斷某個類是否在字典 instances 中，若是不存在，則會將 cls 做爲 key，cls(*args, **kw) 做爲 value 存到 instances 中，不然，直接返回 instances[cls]。

1.4 使用metaclass

元類（metaclass）能夠控制類的建立過程，它主要作三件事：

攔截類的建立
修改類的定義
返回修改後的類

使用元類實現單例模式的代碼以下：

class Singleton(type):
    def __init__(self,name,bases,class_dict):
        super(Singleton,self).__init__(name,bases,class_dict)
        self._instance=None
    def __call__(self,*args,**kwargs):
        if self._instance is None:
            self._instance=super(Singleton,self).__call__(*args,**kwargs)
        return self._instance
if __name__=='__main__':
    class A(object):
        __metaclass__=Singleton      
    a=A()
    b=A()
    print id(a),id(b)

id是相同的。

例子中咱們構造了一個Singleton元類，並使用__call__方法使其可以模擬函數的行爲。構造類A時，將其元類設爲Singleton，那麼建立類對象A時，行爲發生以下：

A=Singleton(name,bases,class_dict),A其實爲Singleton類的一個實例。

建立A的實例時，A()=Singleton(name,bases,class_dict)()=Singleton(name,bases,class_dict).__call__()，這樣就將A的全部實例都指向了A的屬性_instance上，這種方法與方法1實際上是相同的。

admin執行流程

1. 循環加載執行全部已經註冊的app中的admin.py文件，點擊admin源碼能夠看到以下函數，記得必須在settings裏面註冊項目

def autodiscover():
    autodiscover_modules('admin', register_to=site)

2. 執行代碼，檢測到註冊，就要執行代碼

＃admin.py
class BookAdmin(admin.ModelAdmin):
    list_display = ("title",'publishDate', 'price')
admin.site.register(Book, BookAdmin) 
admin.site.register(Publish)

3. admin.site

這裏應用的是一個單例模式，對於AdminSite類的一個單例模式，執行的每個app中的每個admin.site都是一個對象

4 執行register方法，點擊register裏面看到以下代碼

admin.site.register(Book, BookAdmin) 
admin.site.register(Publish)

class ModelAdmin(BaseModelAdmin):pass

def register(self, model_or_iterable, admin_class=None, **options):
　　self._registry={}
   if not admin_class:
           admin_class = ModelAdmin
   # Instantiate the admin class to save in the registry
   self._registry[model] = admin_class(model, self) # self就是admin.site，admin.site._registry[book]=ModelAdmin(book,)增長了簡直對
　　若是註冊的爲多個，就會往字典裏面加，一個表對象一個值，爲了這個對象增長了樣式，樣式爲這個value

思考：在每個app的admin .py中加上

print(admin.site._registry)   ＃ 執行結果？單例模式，產生一個對象

5 admin的URL配置，點擊site能夠看到get_urls函數

urlpatterns = [
    url(r'^admin/', admin.site.urls),
]

class AdminSite(object):
    
     def get_urls(self):
        from django.conf.urls import url, include
      
        urlpatterns = []

        # Add in each model's views, and create a list of valid URLS for the
        # app_index
        valid_app_labels = []
        for model, model_admin in self._registry.items():
            urlpatterns += [
                url(r'^%s/%s/' % (model._meta.app_label, model._meta.model_name), include(model_admin.urls)),
            ]
            if model._meta.app_label not in valid_app_labels:
                valid_app_labels.append(model._meta.app_label)

        return urlpatterns

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

6 url()方法的擴展應用，

from django.shortcuts import HttpResponse
def test01(request):
    return HttpResponse("test01")

def test02(request):
    return HttpResponse("test02")

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^yuan/', ([
                    url(r'^test01/', test01),
                    url(r'^test02/', test02),

                    ],None,None)),

]

擴展優化

from django.conf.urls import url,include
from django.contrib import admin

from django.shortcuts import HttpResponse

def change_list_view(request):
    return HttpResponse("change_list_view")
def add_view(request):
    return HttpResponse("add_view")
def delete_view(request):
    return HttpResponse("delete_view")
def change_view(request):
    return HttpResponse("change_view")

def get_urls():

    temp=[
        url(r"^$".format(app_name,model_name),change_list_view),
        url(r"^add/$".format(app_name,model_name),add_view),
        url(r"^\d+/del/$".format(app_name,model_name),delete_view),
        url(r"^\d+/change/$".format(app_name,model_name),change_view),
    ]

    return temp


url_list=[]

for model_class,obj in admin.site._registry.items():

    model_name=model_class._meta.model_name     ### model對象名字
    app_name=model_class._meta.app_label　　　　　## 項目名稱

    # temp=url(r"{0}/{1}/".format(app_name,model_name),(get_urls(),None,None))
    temp=url(r"{0}/{1}/".format(app_name,model_name),include(get_urls()))
    url_list.append(temp)

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^yuan/', (url_list,None,None)),
]

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。