Analyse du code source de l'administrateur Django (avec exemples)

Le contenu de cet article concerne l'analyse du code source de l'administrateur Django (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Singleton Pattern

Singleton Pattern est un modèle de conception de logiciel couramment utilisé. L'objectif principal de ce modèle est de garantir qu'une seule instance d'une certaine classe existe. Les objets Singleton sont utiles lorsque vous souhaitez qu'une seule instance d'une certaine classe apparaisse dans l'ensemble du système.

Par exemple, les informations de configuration d'un programme serveur sont stockées dans un fichier et le client lit les informations du fichier de configuration via une classe AppConfig. Si le contenu du fichier de configuration doit être utilisé à plusieurs endroits lors de l'exécution du programme, c'est-à-dire que des instances de l'objet AppConfig doivent être créées à plusieurs endroits, ce qui conduira à l'existence de plusieurs objets d'instance AppConfig. dans le système, ce qui gaspillera sérieusement les ressources mémoire, surtout lorsque le fichier de configuration contient beaucoup de contenu. En fait, pour une classe comme AppConfig, nous espérons qu'un seul objet instance existe pendant l'exécution du programme.

En Python, nous pouvons utiliser diverses méthodes pour implémenter le modèle singleton :

• Utiliser __new__()

• Utilisez des modules

• Utilisez des décorateurs

• Utilisez des métaclasses

1 Utilisez la méthode __new__().

Afin de ne faire apparaître qu'une seule instance de la classe, on peut utiliser __new__() pour contrôler le processus de création de l'instance. Le code est le suivant :

Méthode __new__() utilisée. pour créer des objets d'instance

La méthode __init__() est utilisée pour initialiser les objets d'instance

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. Utilisez la méthode module

En fait, les modules Python sont des modes singletons naturels , car lorsque le module est importé pour la première fois, un fichier .pyc sera généré. Lors de sa deuxième importation, le fichier .pyc sera chargé directement sans réexécuter le code du module. Par conséquent, il suffit de définir les fonctions et les données pertinentes dans un module pour obtenir un objet singleton.

Si nous voulons vraiment une classe singleton, pensez à faire ceci :

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

Testez-la avec le code suivant :

from singleton import p1

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

from singleton import p1

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

Le reste Deux façons de vérifier le informations vous-même...

processus d'exécution de l'administrateur

f35d6e602fd7d0f0edfa6f7d103c1b57 Charger et exécuter cycliquement les fichiers admin.py dans toutes les applications enregistrées

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

2cc198a1d5eb0d3eb508d858c9f5cbdb Exécuter le code

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

5bdf4c78156c7953567bb5a0aef2fc53 admin.site

Un mode singleton est appliqué ici, pour la classe AdminSite Un mode singleton, chaque admin .site dans chaque application exécutée est un objet

23889872c2e8594e0f446a471a78ec4c Exécutez la méthode d'enregistrement

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)

ici, l'inscription est terminée !

43ad812d3a971134e40facaca816c822 Configuration de l'URL de l'administrateur

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

efbfa0de8737dc86eae413541a49df20 Application étendue de la méthode 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'^Xadmin/', ([
                    url(r'^test01/', test01),
                    url(r'^test02/', test02),

                    ],None,None)),
]

Optimisation étendue

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
    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'^Xadmin/', (url_list,None,None)),
]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!