16 Häufige fortgeschrittene Django-Fragen

Beim Übergang von der Django-Entwicklung für Anfänger zur fortgeschrittenen Entwicklung stoßen Entwickler oft auf komplexe und herausfordernde Probleme. Dieser Artikel stellt 16 häufige Fragen in der fortgeschrittenen Django-Entwicklung zusammen und bietet Antworten mit reichhaltigen Beispielen, um Entwicklern zu helfen, fortgeschrittene Django-Entwicklungstechniken zu beherrschen.

1. Wie optimiert man die Abfrageleistung von Django-Modellen?

Die Datenbankabfrageleistung ist in Django-Projekten entscheidend. Unsachgemäße Abfragen können bei großen Datenmengen zu Leistungsengpässen führen.

Verwendung von select_related und prefetch_related select_related behandelt ForeignKey- und OneToOneField-Beziehungen, indem es die Datenbankabfragezeiten durch SQL-JOIN-Operationen reduziert. prefetch_related behandelt ManyToManyField- und umgekehrte ForeignKey-Beziehungen, indem es zusätzliche Abfragen durchführt und Ergebnisse auf Python-Ebene zusammenführt.

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

# Optimieren von Abfragen mit select_related
books = Book.objects.select_related('author').all()
for book in books:
    print(book.title, book.author.name)

class Tag(models.Model):
    name = models.CharField(max_length=50)
    books = models.ManyToManyField(Book)

# Optimieren von Abfragen mit prefetch_related
tags = Tag.objects.prefetch_related('books').all()
for tag in tags:
    for book in tag.books.all():
        print(tag.name, book.title)

Rationaler Einsatz von Indizes Das Hinzufügen von Indizes zu Modellfeldern kann Abfragen beschleunigen. Indizes können mit db_index=True in Felddefinitionen hinzugefügt werden.

class Product(models.Model):
    name = models.CharField(max_length=100, db_index=True)
    price = models.DecimalField(max_digits=8, decimal_places=2)

2. Wie implementiert man asynchrone Views in Django?

Django unterstützt seit Version 3.1 asynchrone Views, was die Verarbeitungseffizienz für E/A-gebundene Aufgaben effektiv verbessert.

import asyncio
from django.http import JsonResponse
from django.views.decorators.http import async_only

@async_only
async def async_view(request):
    await asyncio.sleep(2)  # Simulieren asynchroner Operationen
    data = {'message': 'This is an async view'}
    return JsonResponse(data)

Konfigurieren Sie zusätzlich einen ASGI-Server (z. B. uvicorn), der Asynchronität in settings.py unterstützt.

3. Wie verwaltet man Datenbanktransaktionen in Django?

Datenbanktransaktionen stellen sicher, dass eine Reihe von Datenbankoperationen entweder alle erfolgreich sind oder alle fehlschlagen.

from django.db import transaction
from.models import Account

@transaction.atomic
def transfer_funds(sender, receiver, amount):
    with transaction.atomic():
        sender.balance -= amount
        receiver.balance += amount
        sender.save()
        receiver.save()

Im obigen Code stellt der @transaction.atomic-Dekorator sicher, dass Operationen innerhalb der Funktion transfer_funds innerhalb einer einzigen Transaktion abgeschlossen werden. Wenn eine save-Operation fehlschlägt, wird die gesamte Transaktion zurückgerollt.

4. Wie konfiguriert man Caching in Django?

Django bietet mehrere Caching-Methoden, wie z. B. In-Memory-Caching, Datei-Caching und Datenbank-Caching.

Cache-Konfiguration Konfigurieren Sie das Caching in settings.py (Beispiel mit In-Memory-Caching):

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

Verwendung von Caching

from django.core.cache import cache

def get_cached_data(key):
    data = cache.get(key)
    if data is None:
        data = calculate_data()  # Angenommen, dies ist eine Datenabruffunktion
        cache.set(key, data, 60)  # Cache für 60 Sekunden
    return data

5. Wie passt man das Django-Benutzerauthentifizierungssystem an?

Das in Django integrierte Benutzerauthentifizierungssystem erfüllt möglicherweise nicht immer die Projektanforderungen, was eine Anpassung erforderlich macht.

from django.contrib.auth.models import AbstractBaseUser, BaseUserManager
from django.db import models

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None):
        if not email:
            raise ValueError('Users must have an email address')
        user = self.model(
            email=self.normalize_email(email),
        )
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password):
        user = self.create_user(
            email=email,
            password=password,
        )
        user.is_admin = True
        user.save(using=self._db)
        return user

class CustomUser(AbstractBaseUser):
    email = models.EmailField(
        verbose_name='email address',
        max_length=255,
        unique=True,
    )
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)

    objects = CustomUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = []

    def __str__(self):
        return self.email

    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True

    @property
    def is_staff(self):
        return self.is_admin

Setzen Sie dann AUTH_USER_MODEL = 'your_app_name.CustomUser' in settings.py.

6. Wie behandelt man Cross-Origin-Anforderungen in Django?

Cross-Origin-Probleme treten auf, wenn sich das Frontend und das Django-Backend in verschiedenen Domänen befinden. Die Bibliothek django-cors-headers kann dies beheben.

Installieren Sie die Bibliothek: pip install django-cors-headers
Konfigurieren Sie in settings.py:

INSTALLED_APPS = [
   ...
    'corsheaders',
   ...
]

MIDDLEWARE = [
   ...
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
   ...
]

CORS_ALLOWED_ORIGINS = [
    "https://example.com",
]

7. Wie verwendet man Signale in Django?

Django-Signale ermöglichen die Ausführung von benutzerdefiniertem Code, wenn bestimmte Ereignisse auftreten.

from django.db.models.signals import post_save
from django.dispatch import receiver
from.models import Order, OrderNotification

@receiver(post_save, sender=Order)
def create_order_notification(sender, instance, created, **kwargs):
    if created:
        OrderNotification.objects.create(order=instance, message='New order created')

Der obige Code erstellt eine entsprechende OrderNotification nach dem Speichern des Modells Order, wenn es sich um eine neue Bestellung handelt.

8. Wie implementiert man Datei-Uploads in Django?

Die Implementierung von Datei-Uploads erfordert entsprechende Einstellungen in Modellen, Views und Templates.

Modelldefinition

from django.db import models

class UploadedFile(models.Model):
    file = models.FileField(upload_to='uploads/')
    uploaded_at = models.DateTimeField(auto_now_add=True)

View-Handling

from django.shortcuts import render, redirect
from.forms import UploadFileForm

def upload_file(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            form.save()
            return redirect('file_list')
    else:
        form = UploadFileForm()
    return render(request, 'upload.html', {'form': form})

Template-Code

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
</head>

<body>
    <form method="post" enctype="multipart/form-data">
        {% csrf_token %}
        {{ form.as_p }}
        <input type="submit" value="Upload">
    </form>
</body>

</html>

9. Wie schreibt man Unit-Tests in Django?

Django bietet ein Test-Framework zum Schreiben von Unit-Tests.

from django.test import TestCase
from.models import Book

class BookModelTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        Book.objects.create(title='Test Book', author='Test Author')

    def test_book_title(self):
        book = Book.objects.get(id=1)
        self.assertEqual(book.title, 'Test Book')

Führen Sie Tests mit dem Befehl python manage.py test aus.

10. Wie implementiert man eine Aufgabenwarteschlange in Django?

Celery kann verwendet werden, um Aufgabenwarteschlangen in Django zur Verarbeitung asynchroner Aufgaben zu implementieren.

Installieren Sie Celery: pip install celery
Erstellen Sie eine Datei celery.py im Projektstammverzeichnis:

import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')

app = Celery('your_project')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

Importieren Sie die Celery-App in __init__.py:

from.celery import app as celery_app

__all__ = ('celery_app',)

Definieren Sie Aufgaben:

from celery import shared_task

@shared_task
def send_email_task(to_email, subject, message):
    # Logik zum Senden von E-Mails
    pass

11. Wie implementiert man mehrsprachige Unterstützung in Django?

Django verfügt über integrierte mehrsprachige Unterstützung.

Konfigurieren Sie Sprachen in settings.py:

LANGUAGE_CODE = 'en-us'

USE_I18N = True

USE_L10N = True

LANGUAGES = [
    ('en', 'English'),
    ('zh-hans', 'Simplified Chinese'),
]

LOCALE_PATHS = [
    os.path.join(BASE_DIR, 'locale'),
]

Verwenden Sie Übersetzungen in Templates:

{% load i18n %}
<!DOCTYPE html>
<html lang="{{ LANGUAGE_CODE }}">
<head>
    <title>{% trans "My Page" %}</title>
</head>
<body>
    <p>{% trans "Welcome to my site" %}</p>
</body>
</html>

Führen Sie python manage.py makemessages -l zh-hans aus, um Übersetzungsdateien zu generieren, bearbeiten Sie den Übersetzungsinhalt und führen Sie python manage.py compilemessages aus, um die Übersetzungsdateien zu kompilieren.

12. Wie richtet man Logging in Django ein?

Vernünftiges Logging hilft bei der Fehlerbehebung. Konfigurieren Sie das Logging in settings.py:

LOGGING = {
   'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'root': {
        'handlers': ['console'],
        'level': 'DEBUG',
    },
}

Verwenden Sie Logging im Code:

import logging

logger = logging.getLogger(__name__)

def my_view(request):
    try:
        # Geschäftslogik
        pass
    except Exception as e:
        logger.error(f"An error occurred: {e}", exc_info=True)

13. Wie implementiert man API-Versioning in Django?

API-Versioning ist erforderlich, wenn sich APIs weiterentwickeln. Dies kann mit Bibliotheken wie drf-nested-routers mit Django REST framework erreicht werden.

from rest_framework.routers import DefaultRouter
from.views import v1, v2

router_v1 = DefaultRouter()
router_v1.register('users', v1.UserViewSet)

router_v2 = DefaultRouter()
router_v2.register('users', v2.UserViewSet)

urlpatterns = [
    path('api/v1/', include(router_v1.urls)),
    path('api/v2/', include(router_v2.urls)),
]

14. Wie stärkt man die Django-Sicherheit?

Um Sicherheitslücken zu vermeiden, müssen Django-Projekte sicherheitstechnisch gehärtet werden.

Setzen Sie sicherheitsrelevante settings.py-Parameter

SECRET_KEY = 'your_secret_key'
DEBUG = False
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
X_FRAME_OPTIONS = 'DENY'

Verhindern Sie SQL-Injection Verwenden Sie Djangos ORM für Abfragen, um eine direkte SQL-Stringverkettung zu vermeiden.
Verhindern Sie Cross-Site Scripting (XSS) Django-Templates maskieren Variablen standardmäßig, um die Ausführung schädlicher Skripte zu verhindern.

15. Wie verwendet man WebSockets in Django?

Die Bibliothek channels ermöglicht WebSocket-Funktionalität in Django.

Installieren Sie channels: pip install channels
Konfigurieren Sie in settings.py:

ASGI_APPLICATION = 'your_project.asgi.application'

CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',
        'CONFIG': {
           "hosts": [('127.0.0.1', 6379)],
        },
    },
}

Definieren Sie einen consumer zur Behandlung von WebSocket-Verbindungen:

from channels.generic.websocket import AsyncWebsocketConsumer
import json

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        await self.accept()

    async def receive(self, text_data):
        text_data_json = json.loads(text_data)
        message = text_data_json['message']
        await self.send(text_data=json.dumps({'message': message}))

    async def disconnect(self, close_code):
        pass

16. Wie analysiert man die Code-Performance in Django?

Die Bibliothek django-debug-toolbar erleichtert die Analyse der Code-Performance.

Installieren Sie die Bibliothek: pip install django-debug-toolbar
Konfigurieren Sie in settings.py:

INSTALLED_APPS = [
   ...
    'debug_toolbar',
   ...
]

MIDDLEWARE = [
   ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
   ...
]

INTERNAL_IPS = [
    '127.0.0.1',
]

Nach der Aktivierung wird am unteren Rand der Seite eine Debug-Toolbar angezeigt, die Leistungskennzahlen wie die Anzahl der Datenbankabfragen und die Ausführungszeit anzeigt.