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 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
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))
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...
<1> Charger et exécuter cycliquement les fichiers admin.py dans toutes les applications enregistrées
def autodiscover(): autodiscover_modules('admin', register_to=site)
<2> Exécuter le code
#admin.py class BookAdmin(admin.ModelAdmin): list_display = ("title",'publishDate', 'price') admin.site.register(Book, BookAdmin) admin.site.register(Publish)
<3> 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
<4> 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 !
<5> 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
<6> 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!