Wat is modelovererving in Django?

Modelovererving is een Django ORM-functie waarmee ontwikkelaars hiërarchische relaties tussen databasemodellen kunnen creëren. Het maakt hergebruik van code, uitbreidbaarheid en een schonere codebasis mogelijk door gebruik te maken van de principes van objectgeoriënteerd programmeren.

Of u nu een complexe webtoepassing bouwt of aan een kleiner project werkt, modelovererving kan aanzienlijke voordelen bieden, zoals het verminderen van redundantie en het waarborgen van consistent gedrag.

Soorten modelovererving in Django

Django biedt ondersteuning voor drie soorten modelovererving:

1. Abstracte basisklassen.
2. Overerving met meerdere tabellen.
3. Proxy-modellen.

Elk van deze soorten modelovererving heeft voordelen en u gebruikt ze voor specifieke doeleinden.

Abstracte basisklassen

Abstracte basisklassen bieden een manier om gemeenschappelijke velden en methoden te definiëren die meerdere modellen kunnen overnemen. Als u bijvoorbeeld twee modellen hebt die vergelijkbare velden delen, kunt u een abstracte basisklasse gebruiken om de vergelijkbare velden te definiëren. Kijk eens naar dit voorbeeld:

klasKlant(modellen. Model):
 naam = modellen. CharField (max_length=50)
 e-mail = modellen. E-mailVeld()
 klant_id = modellen. IntegerVeld() 
klasVerkoper(modellen. Model):
 naam = modellen. CharField (max_length=50)
 e-mail = modellen. E-mailVeld()
 seller_id = modellen. IntegerVeld()

Het bovenstaande codefragment definieert twee Django-modellen: Klant En Verkoper. Deze modellen delen twee gemeenschappelijke velden, namelijk naam En e-mailen. Om deze redundantie te voorkomen, kunt u een apart model maken om de gemeenschappelijke velden in te bewaren Klant En Verkoper modellen en maak het abstract.

klasGebruikers informatie(modellen. Model):
 naam = modellen. CharField (max_length=50)
 e-mail = modellen. E-mailVeld()
klasMeta:
 samenvatting = WAAR

Het bovenstaande codefragment definieert een nieuw model en stelt de abstract toeschrijven aan WAAR. Dit betekent dat het model abstract is en dat Django geen tabel in de database maakt.

Je kunt de Klant En Verkoper modellen zoals deze:

klasKlant(Gebruikers informatie):
 klant_id = modellen. IntegerVeld() 
klasVerkoper(Gebruikers informatie):
 seller_id = modellen. IntegerVeld()

In het bovenstaande codefragment is de Klant En Verkopers modellen erven van de Gebruikers informatie model in plaats van modellen. Model.

U kunt uw modellen bekijken in het beheerderspaneel door ze te registreren in uw admin.py bestand als volgt:

van .modellen importeren Klant, verkoper
admin.site.register (Klant)
admin.site.register (Verkoper)

Migreer uw modi en start uw ontwikkelingsserver door het volgende uit te voeren op een opdrachtregel:

python manage.py makemigrations \
 && python manage.py migreren \
 && python manage.py runserver

Navigeer naar uw beheerderssite en log in met uw superuser-gegevens. U zou alle drie de velden voor elk model moeten zien.

In dit voorbeeld heeft Django een tabel gemaakt voor de Klant En Verkoper modellen. Je ziet dat de Gebruikers informatie model heeft geen tabel omdat het abstract is.

Overerving met meerdere tabellen

U kunt overerving met meerdere tabellen gebruiken wanneer het bovenliggende model naast het onderliggende model ook als tabel in de database moet bestaan.

In tegenstelling tot abstracte overerving van basisklassen, waarbij het bovenliggende model geen tabel in de database is, maakt overerving van meerdere tabellen een tabel voor het bovenliggende model.

Bij overerving met meerdere tabellen neemt het onderliggende model alle velden en methoden over van het bovenliggende model en voegt het de specifieke velden toe. Buitenlandse sleutels helpen bij het opzetten van de model relatie tussen ouder- en kindmodellen.

Hier is een voorbeeld van overerving met meerdere tabellen:

klasPersoon(modellen. Model):
 voornaam = modellen. CharField (max_length=100)
 achternaam = modellen. CharField (max_length=100)
defkrijg_naam(zelf):
opbrengstF"{self.first_name}{zelf.achternaam}"
klasMeta:
 samenvatting = WAAR
klasMedewerker(Persoon):
 werknemer_id = modellen. CharField (max_length=20)
 afdeling = modellen. CharField (max_length=100)
 salaris = modellen. FloatVeld()
 dob = modellen. Datumveld()
klasManager(Medewerker):
 titel = modellen. CharField (max_length=100)

Dit codefragment definieert drie modellen. Het eerste model, genaamd Persoon, is abstract. Het definieert alleen de voor- en achternaam van een persoon.

Het tweede model, genaamd Medewerker, erft de velden van Persoon maar definieert aanvullende velden. De Medewerker model is niet abstract, dus het zal zijn tabel in de database hebben.

Het uiteindelijke model, genaamd Manager, erft de velden van de Medewerker model en voegt een veld toe met de naam titel.

De relatie tussen de Medewerker En Manager modellen wordt genoemd Overerving met meerdere tabellen. Migreer uw modellen, registreer ze in admin.py, start uw server en navigeer naar het beheerderspaneel. Je zou twee tabellen moeten zien die door Django zijn gemaakt.

Wanneer u een nieuwe manager probeert toe te voegen, zult u merken dat deze alle velden van de Medewerker model en een eigen aangepast veld.

Proxy-modellen

Met een proxymodel kunt u een nieuw model maken dat voortbouwt op een bestaand model zonder een nieuwe databasetabel te maken. Bij dit soort modelovererving delen de proxy- en originele modellen dezelfde tabel. Met behulp van proxymodellen kunt u bijvoorbeeld aangepaste modellen maken en standaardbeheerders wijzigen.

U kunt een proxymodel maken door toe te voegen proxy=Waar in de Meta klas. Hier is een voorbeeld:

klasProxyModel(basismodel):
klasMeta:
 volmacht = WAAR

Typisch gebruik van een proxymodel is geschikt wanneer er een basismodel bestaat en er behoefte is om een ​​gespecialiseerde versie ervan te maken met toegevoegde functionaliteit. Hier is een eenvoudig voorbeeld:

klasNa(modellen. Model):
 titel = modellen. CharField (max_length=30)
 auteur = modellen. CharField (max_length=30)
def__str__(zelf):
opbrengst zelf.titel
klasProxyPost(Na):
klasMeta:
 volmacht = WAAR

Dit codefragment definieert twee modellen: Na En Mijn post. De Na model definieert twee velden voor titel en auteur. De ProxyPost model erft van de Na model.

Migreer de bovenstaande modellen en voeg een nieuwe post toe aan de tabel die is gemaakt voor de Na model.

Nadat je het bericht hebt toegevoegd, open je het Proxy-berichten tafel. Je zou het bericht moeten vinden dat je aan de hebt toegevoegd Na tafel erin.

De wijzigingen die u aanbrengt in berichten in de Proxy-berichten table heeft invloed op de corresponderende post in de Na tafel en vice versa. Dit bewijst dat ze echt dezelfde tafel delen.

U kunt de str() methode van het proxymodel:

klasProxyPost(Na):
klasMeta:
 volmacht = WAAR
 bestellen = ["titel"]
def__str__(zelf):
opbrengst zelf.auteur

Met deze wijziging, een ProxyPost's tekenreeksrepresentatie is de auteur, niet de titel. De volgorde van het proxymodel is ook op titel in plaats van op het standaard ID-veld.

Houd er bij het gebruik van proxy-modellen rekening mee dat u geen aangepaste velden aan uw proxy-model kunt toevoegen. De primaire use-case van proxy-modellen is wanneer u wilt dat één model meerdere gedragingen ondersteunt.

Proxymodellen helpen u het gedrag van een bestaand model te wijzigen zonder de velden of onderliggende databasetabelstructuur te wijzigen.

Gebruik modelovererving voor herbruikbaarheid van code en organisatiestructuur

Door de verschillende technieken van modelovererving te gebruiken, kunt u eenvoudig herbruikbare en georganiseerde code voor uw project maken.

Modelovererving vermijdt overbodige code en verbetert de onderhoudbaarheid en schaalbaarheid van uw code. Het maakt het ook gemakkelijk om door uw code te navigeren, waardoor een efficiënte samenwerking tussen ontwikkelingsteams wordt bevorderd.

Naast modelovererving biedt Django sjabloonovererving, wat een geweldige manier is om sjablonen voor uw projecten te beheren en te organiseren.