Analyse des Django-Administrator-Quellcodes (mit Beispielen)

Der Inhalt dieses Artikels befasst sich mit der Analyse des Django-Administrator-Quellcodes (mit Beispielen). Ich hoffe, dass er für Sie hilfreich ist.

Singleton-Muster

Singleton-Muster ist ein häufig verwendetes Software-Designmuster. Der Hauptzweck dieses Musters besteht darin, sicherzustellen, dass nur eine Instanz einer bestimmten Klasse existiert. Singleton-Objekte sind praktisch, wenn Sie möchten, dass nur eine Instanz einer bestimmten Klasse im gesamten System angezeigt wird.

Zum Beispiel werden die Konfigurationsinformationen eines Serverprogramms in einer Datei gespeichert und der Client liest die Konfigurationsdateiinformationen über eine AppConfig-Klasse. Wenn der Inhalt der Konfigurationsdatei während der Ausführung des Programms an vielen Stellen verwendet werden muss, müssen also an vielen Stellen Instanzen des AppConfig-Objekts erstellt werden, was zur Existenz mehrerer AppConfig-Instanzobjekte führt im System, was zu einer erheblichen Verschwendung von Speicherressourcen führt, insbesondere wenn die Konfigurationsdatei viel Inhalt enthält. Tatsächlich hoffen wir, dass bei einer Klasse wie AppConfig nur ein Instanzobjekt vorhanden ist, während das Programm ausgeführt wird.

In Python können wir verschiedene Methoden verwenden, um das Singleton-Muster zu implementieren:

• Verwenden Sie __new__()

• Verwenden Sie Module

• Verwenden Sie Dekoratoren

• Verwenden Sie Metaklassen

1. Verwenden Sie die Methode __new__()

Um nur eine Instanz der Klasse anzuzeigen, können wir __new__() verwenden, um den Erstellungsprozess der Instanz zu steuern. Der Code lautet wie folgt:

__new__() Methode Verwendet zum Erstellen von Instanzobjekten

Methode __init__() wird zum Initialisieren von Instanzobjekten verwendet

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
class Singleton(object):
    _instance = None

    def __new__(cls, *args, **kwargs):
        print(1)
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

    def __init__(self, name, age):
        print(2)
        self.name = name
        self.age = age
if __name__ == '__main__':
    p1 = Person("djb", 18)
    p2 = Person("djb", 18)

    print(p1 == p2)
    print(id(p1), id(p2))

    print("=" * 120)

    s1 = Singleton("djb", 18)
    s2 = Singleton("djb", 18)
    print(s1 == s2)
    print(id(s1), id(s2))

2 Verwenden Sie die Modulmethode

Tatsächlich ist Pythons Modul ein natürlicher Singleton-Modus. Denn beim ersten Import des Moduls wird eine .pyc-Datei generiert. Beim zweiten Import wird die .pyc-Datei direkt geladen, ohne dass der Modulcode erneut ausgeführt werden muss. Daher müssen wir nur die relevanten Funktionen und Daten in einem Modul definieren, um ein Singleton-Objekt zu erhalten.

Wenn wir wirklich eine Singleton-Klasse wollen, können wir Folgendes in Betracht ziehen:

class Singleton(object):    
def __init__(self, name, age):
        self.name = name
        self.age = age
p1 = Singleton("djb", 18)

Verwenden Sie den folgenden Code, um es zu testen:

from singleton import p1

print(id(p1))
print(p1.name)
p1.name = "Bob"

from singleton import p1

print(id(p1))
print(p1.name)

Überprüfen Sie die verbleibenden zwei Informationen selbst. ..

Admin-Ausführungsprozess

<1> Zyklisch die admin.py-Dateien in allen registrierten Apps laden und ausführen

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

<2>Ausführungscode

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

<3> admin.site

Was hier angewendet wird, ist ein Singleton-Modus der AdminSite-Klasse. Führen Sie jede admin.site in aus Jede App ist ein Objekt

<4> Führen Sie die Registrierungsmethode aus

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

class ModelAdmin(BaseModelAdmin):pass
def register(self, model_or_iterable, admin_class=None, **options):
    if not admin_class:
            admin_class = ModelAdmin
    # Instantiate the admin class to save in the registry
    self._registry[model] = admin_class(model, self)

Hier ist die Registrierung beendet!

<5> URL-Konfiguration des Admins

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

e

<6> Erweiterte Anwendung der url()-Methode

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

Erweiterte Optimierung

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'^Xadmin/', ([
                    url(r'^test01/', test01),
                    url(r'^test02/', test02),

                    ],None,None)),
]

Das obige ist der detaillierte Inhalt vonAnalyse des Django-Administrator-Quellcodes (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!