पायथन डीआरएफ सीरियलाइज़र संबंध: नेस्टेड ऑब्जेक्ट सीरियलाइज़ेशन में महारत हासिल करना

जैंगो रेस्ट फ्रेमवर्क (DRF) वेब एपीआई बनाने के लिए एक शक्तिशाली और लचीली प्रणाली प्रदान करता है। एपीआई विकास का एक महत्वपूर्ण पहलू डेटा मॉडल के बीच संबंधों को संभालना है, और DRF सीरियलाइज़र नेस्टेड ऑब्जेक्ट्स को सीरियलाइज़ और डीसीरियलाइज़ करने के लिए मजबूत तंत्र प्रदान करते हैं। यह मार्गदर्शिका DRF सीरियलाइज़र में संबंधों को प्रबंधित करने के विभिन्न तरीकों की पड़ताल करती है, जिसमें व्यावहारिक उदाहरण और सर्वोत्तम अभ्यास शामिल हैं।

सीरियलाइज़र संबंधों को समझना

संबंधपरक डेटाबेस में, संबंध यह परिभाषित करते हैं कि विभिन्न तालिकाएँ या मॉडल कैसे जुड़े हुए हैं। DRF सीरियलाइज़र को एपीआई खपत के लिए डेटाबेस ऑब्जेक्ट्स को JSON या अन्य डेटा प्रारूपों में परिवर्तित करते समय इन संबंधों को प्रतिबिंबित करने की आवश्यकता होती है। हम तीन प्राथमिक प्रकार के संबंधों को कवर करेंगे:

• ForeignKey (वन-टू-मेनी): एक एकल ऑब्जेक्ट कई अन्य ऑब्जेक्ट्स से संबंधित होता है। उदाहरण के लिए, एक लेखक कई किताबें लिख सकता है।
• ManyToManyField (मेनी-टू-मेनी): कई ऑब्जेक्ट कई अन्य ऑब्जेक्ट्स से संबंधित होते हैं। उदाहरण के लिए, कई लेखक कई किताबों पर सहयोग कर सकते हैं।
• OneToOneField (वन-टू-वन): एक ऑब्जेक्ट विशिष्ट रूप से दूसरे ऑब्जेक्ट से संबंधित होता है। उदाहरण के लिए, एक उपयोगकर्ता प्रोफ़ाइल अक्सर एक उपयोगकर्ता खाते से वन-टू-वन लिंक्ड होती है।

ForeignKey के साथ बेसिक नेस्टेड सीरियलाइज़ेशन

आइए ForeignKey संबंध को सीरियलाइज़ करने के एक साधारण उदाहरण से शुरू करें। इन मॉडलों पर विचार करें:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    country = models.CharField(max_length=50, default='USA') # Adding country field for international context

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')
    publication_date = models.DateField()

    def __str__(self):
        return self.title

`Book` मॉडल को उसके संबंधित `Author` डेटा के साथ सीरियलाइज़ करने के लिए, हम एक नेस्टेड सीरियलाइज़र का उपयोग कर सकते हैं:

from rest_framework import serializers

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'country']

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True) # Changed from PrimaryKeyRelatedField

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

इस उदाहरण में, `BookSerializer` में एक `AuthorSerializer` फ़ील्ड शामिल है। `read_only=True` `author` फ़ील्ड को रीड-ओनली बनाता है, जिससे बुक एंडपॉइंट के माध्यम से लेखक के संशोधन को रोका जा सके। यदि आपको लेखक की जानकारी के साथ किताबें बनाने या अपडेट करने की आवश्यकता है, तो आपको राइट ऑपरेशंस को अलग तरीके से संभालना होगा (नीचे देखें)।

अब, जब आप एक `Book` ऑब्जेक्ट को सीरियलाइज़ करते हैं, तो JSON आउटपुट में बुक डेटा के भीतर लेखक का पूरा विवरण नेस्टेड होगा:

{
    "id": 1,
    "title": "The Hitchhiker's Guide to the Galaxy",
    "author": {
        "id": 1,
        "name": "Douglas Adams",
        "country": "UK"
    },
    "publication_date": "1979-10-12"
}

ManyToManyField संबंधों का सीरियलाइज़ेशन

आइए एक `ManyToManyField` संबंध पर विचार करें। मान लीजिए हमारे पास एक `Category` मॉडल है और एक किताब कई श्रेणियों से संबंधित हो सकती है।

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

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='books')
    categories = models.ManyToManyField(Category, related_name='books')
    publication_date = models.DateField()

    def __str__(self):
        return self.title

हम `serializers.StringRelatedField` या `serializers.PrimaryKeyRelatedField` का उपयोग करके श्रेणियों को सीरियलाइज़ कर सकते हैं, या एक नेस्टेड सीरियलाइज़र बना सकते हैं।

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = ['id', 'name']

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    categories = CategorySerializer(many=True, read_only=True) # many=True is essential for ManyToManyField

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'categories', 'publication_date']

`ManyToManyField` को सीरियलाइज़ करते समय `many=True` तर्क महत्वपूर्ण है। यह सीरियलाइज़र को श्रेणी ऑब्जेक्ट्स की एक सूची की अपेक्षा करने के लिए कहता है। आउटपुट इस तरह दिखेगा:

{
    "id": 1,
    "title": "Pride and Prejudice",
    "author": {
        "id": 2,
        "name": "Jane Austen",
        "country": "UK"
    },
    "categories": [
        {
            "id": 1,
            "name": "Classic Literature"
        },
        {
            "id": 2,
            "name": "Romance"
        }
    ],
    "publication_date": "1813-01-28"
}

OneToOneField संबंधों का सीरियलाइज़ेशन

`OneToOneField` संबंधों के लिए, दृष्टिकोण ForeignKey के समान है, लेकिन उन मामलों को संभालना महत्वपूर्ण है जहां संबंधित ऑब्जेक्ट मौजूद नहीं हो सकता है।

from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile')
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True, default='Global') # Added location for international context

    def __str__(self):
        return self.user.username

class UserProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = UserProfile
        fields = ['id', 'bio', 'location']

class UserSerializer(serializers.ModelSerializer):
    profile = UserProfileSerializer(read_only=True)

    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'profile']

आउटपुट इस प्रकार होगा:

{
    "id": 1,
    "username": "johndoe",
    "email": "john.doe@example.com",
    "profile": {
        "id": 1,
        "bio": "Software Engineer.",
        "location": "London, UK"
    }
}

राइट ऑपरेशंस को संभालना (बनाना और अपडेट करना)

उपरोक्त उदाहरण मुख्य रूप से रीड-ओनली सीरियलाइज़ेशन पर केंद्रित हैं। संबंधित ऑब्जेक्ट्स को बनाने या अपडेट करने की अनुमति देने के लिए, आपको अपने सीरियलाइज़र में `create()` और `update()` विधियों को ओवरराइड करने की आवश्यकता है।

नेस्टेड ऑब्जेक्ट्स बनाना

मान लीजिए आप एक साथ एक नई किताब और लेखक बनाना चाहते हैं।

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

    def create(self, validated_data):
        author_data = validated_data.pop('author')
        author = Author.objects.create(**author_data)
        book = Book.objects.create(author=author, **validated_data)
        return book

`create()` विधि में, हम लेखक डेटा निकालते हैं, एक नया `Author` ऑब्जेक्ट बनाते हैं, और फिर `Book` ऑब्जेक्ट बनाते हैं, इसे नए बनाए गए लेखक के साथ जोड़ते हैं।

महत्वपूर्ण: आपको `author_data` में संभावित सत्यापन त्रुटियों को संभालने की आवश्यकता होगी। यदि लेखक डेटा अमान्य है तो आप एक try-except ब्लॉक का उपयोग कर सकते हैं और `serializers.ValidationError` बढ़ा सकते हैं।

नेस्टेड ऑब्जेक्ट्स को अपडेट करना

इसी तरह, एक किताब और उसके लेखक दोनों को अपडेट करने के लिए:

class BookSerializer(serializers.ModelSerializer):
    author = AuthorSerializer()

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

    def update(self, instance, validated_data):
        author_data = validated_data.pop('author', None)

        if author_data:
            author = instance.author
            for attr, value in author_data.items():
                setattr(author, attr, value)
            author.save()

        for attr, value in validated_data.items():
            setattr(instance, attr, value)
        instance.save()

        return instance

`update()` विधि में, हम मौजूदा लेखक को पुनः प्राप्त करते हैं, प्रदान किए गए डेटा के आधार पर उसके गुणों को अपडेट करते हैं, और फिर किताब के गुणों को अपडेट करते हैं। यदि `author_data` प्रदान नहीं किया गया है (जिसका अर्थ है कि लेखक अपडेट नहीं हो रहा है), तो कोड लेखक अपडेट अनुभाग को छोड़ देता है। `validated_data.pop('author', None)` में `None` डिफ़ॉल्ट उन मामलों को संभालने के लिए महत्वपूर्ण है जहां अपडेट अनुरोध में लेखक डेटा शामिल नहीं है।

`PrimaryKeyRelatedField` का उपयोग करना

नेस्टेड सीरियलाइज़र के बजाय, आप संबंधित ऑब्जेक्ट की प्राइमरी कुंजी का उपयोग करके संबंधों को दर्शाने के लिए `PrimaryKeyRelatedField` का उपयोग कर सकते हैं। यह तब उपयोगी होता है जब आपको केवल संबंधित ऑब्जेक्ट की आईडी को संदर्भित करने की आवश्यकता होती है और आप पूरे ऑब्जेक्ट को सीरियलाइज़ नहीं करना चाहते हैं।

class BookSerializer(serializers.ModelSerializer):
    author = serializers.PrimaryKeyRelatedField(queryset=Author.objects.all())

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

अब, `author` फ़ील्ड में लेखक की आईडी होगी:

{
    "id": 1,
    "title": "1984",
    "author": 3,  // Author ID
    "publication_date": "1949-06-08"
}

बनाने और अपडेट करने के लिए, आप अनुरोध डेटा में लेखक की आईडी पास करेंगे। `queryset=Author.objects.all()` सुनिश्चित करता है कि प्रदान की गई आईडी डेटाबेस में मौजूद है।

`HyperlinkedRelatedField` का उपयोग करना

`HyperlinkedRelatedField` संबंधित ऑब्जेक्ट के एपीआई एंडपॉइंट के हाइपरलिंक का उपयोग करके संबंधों को दर्शाता है। यह हाइपरमीडिया एपीआई (HATEOAS) में आम है।

class BookSerializer(serializers.ModelSerializer):
    author = serializers.HyperlinkedRelatedField(view_name='author-detail', read_only=True)

    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'publication_date']

`view_name` तर्क उस दृश्य का नाम निर्दिष्ट करता है जो संबंधित ऑब्जेक्ट के लिए अनुरोधों को संभालता है (उदाहरण के लिए, `author-detail`)। आपको इस दृश्य को अपनी `urls.py` फ़ाइल में परिभाषित करना होगा।

आउटपुट में लेखक के विवरण एंडपॉइंट को इंगित करने वाला एक URL शामिल होगा:

{
    "id": 1,
    "title": "Brave New World",
    "author": "http://example.com/api/authors/4/",
    "publication_date": "1932-01-01"
}

उन्नत तकनीकें और विचार

• `depth` विकल्प: `ModelSerializer` में, आप ForeignKey संबंधों के लिए एक निश्चित गहराई तक नेस्टेड सीरियलाइज़र को स्वचालित रूप से बनाने के लिए `depth` विकल्प का उपयोग कर सकते हैं। हालांकि, यदि संबंध जटिल हैं तो `depth` का उपयोग करने से प्रदर्शन संबंधी समस्याएं हो सकती हैं, इसलिए आमतौर पर सीरियलाइज़र को स्पष्ट रूप से परिभाषित करने की सलाह दी जाती है।
• `SerializerMethodField`: संबंधित डेटा के लिए कस्टम सीरियलाइज़ेशन लॉजिक बनाने के लिए `SerializerMethodField` का उपयोग करें। यह तब उपयोगी होता है जब आपको डेटा को एक विशिष्ट तरीके से प्रारूपित करने या गणना किए गए मानों को शामिल करने की आवश्यकता होती है। उदाहरण के लिए, आप स्थानीयकरण के आधार पर लेखक का पूरा नाम विभिन्न क्रमों में प्रदर्शित कर सकते हैं। कई एशियाई संस्कृतियों के लिए, पारिवारिक नाम दिए गए नाम से पहले आता है।
• प्रतिनिधित्व को अनुकूलित करना: संबंधित डेटा का प्रतिनिधित्व कैसे किया जाता है, इसे अनुकूलित करने के लिए अपने सीरियलाइज़र में `to_representation()` विधि को ओवरराइड करें।
• प्रदर्शन अनुकूलन: जटिल संबंधों और बड़े डेटासेट के लिए, डेटाबेस क्वेरी को अनुकूलित करने और डेटाबेस हिट की संख्या को कम करने के लिए select_related और prefetch_related जैसी तकनीकों का उपयोग करें। यह वैश्विक उपयोगकर्ताओं को सेवा देने वाले एपीआई के लिए विशेष रूप से महत्वपूर्ण है जिनकी कनेक्शन गति धीमी हो सकती है।
• शून्य मानों को संभालना: इस बात का ध्यान रखें कि आपके सीरियलाइज़र में शून्य मानों को कैसे संभाला जाता है, खासकर वैकल्पिक संबंधों से निपटते समय। यदि आवश्यक हो तो अपने सीरियलाइज़र फ़ील्ड में `allow_null=True` का उपयोग करें।
• सत्यापन: डेटा अखंडता सुनिश्चित करने के लिए मजबूत सत्यापन लागू करें, खासकर संबंधित ऑब्जेक्ट्स को बनाते या अपडेट करते समय। व्यावसायिक नियमों को लागू करने के लिए कस्टम वैलिडेटर का उपयोग करने पर विचार करें। उदाहरण के लिए, किसी पुस्तक की प्रकाशन तिथि भविष्य में नहीं होनी चाहिए।
• अंतर्राष्ट्रीयकरण और स्थानीयकरण (i18n/l10n): विचार करें कि आपका डेटा विभिन्न भाषाओं और क्षेत्रों में कैसे प्रदर्शित होगा। उपयोगकर्ता के स्थानीयकरण के लिए दिनांक, संख्या और मुद्राओं को उचित रूप से प्रारूपित करें। अपने मॉडल और सीरियलाइज़र में अंतर्राष्ट्रीयकरण योग्य स्ट्रिंग संग्रहीत करें।

सीरियलाइज़र संबंधों के लिए सर्वोत्तम अभ्यास

• सीरियलाइज़र को केंद्रित रखें: प्रत्येक सीरियलाइज़र को एक विशिष्ट मॉडल या डेटा के एक निकट संबंधी सेट को सीरियलाइज़ करने के लिए जिम्मेदार होना चाहिए। अत्यधिक जटिल सीरियलाइज़र बनाने से बचें।
• स्पष्ट सीरियलाइज़र का उपयोग करें: `depth` विकल्प पर बहुत अधिक निर्भर रहने से बचें। सीरियलाइज़ेशन प्रक्रिया पर अधिक नियंत्रण रखने के लिए प्रत्येक संबंधित मॉडल के लिए स्पष्ट सीरियलाइज़र परिभाषित करें।
• पूरी तरह से परीक्षण करें: यह सत्यापित करने के लिए यूनिट परीक्षण लिखें कि आपके सीरियलाइज़र डेटा को सही ढंग से सीरियलाइज़ और डीसीरियलाइज़ कर रहे हैं, खासकर जटिल संबंधों से निपटते समय।
• अपने एपीआई का दस्तावेजीकरण करें: अपने एपीआई एंडपॉइंट्स और उन डेटा प्रारूपों को स्पष्ट रूप से दस्तावेजीकृत करें जिनकी वे अपेक्षा करते हैं और लौटाते हैं। इंटरैक्टिव एपीआई दस्तावेज़ उत्पन्न करने के लिए स्वैगर या ओपनएपीआई जैसे टूल का उपयोग करें।
• एपीआई संस्करण पर विचार करें: जैसे-जैसे आपका एपीआई विकसित होता है, मौजूदा क्लाइंट्स के साथ संगतता बनाए रखने के लिए संस्करण का उपयोग करें। यह आपको पुराने अनुप्रयोगों को प्रभावित किए बिना बड़े बदलाव पेश करने की अनुमति देता है।
• प्रदर्शन की निगरानी करें: अपने एपीआई के प्रदर्शन की निगरानी करें और सीरियलाइज़र संबंधों से संबंधित किसी भी बाधा की पहचान करें। डेटाबेस क्वेरी और सीरियलाइज़ेशन लॉजिक को अनुकूलित करने के लिए प्रोफाइलिंग टूल का उपयोग करें।

निष्कर्ष

जैंगो रेस्ट फ्रेमवर्क में सीरियलाइज़र संबंधों में महारत हासिल करना मजबूत और कुशल वेब एपीआई बनाने के लिए आवश्यक है। विभिन्न प्रकार के संबंधों और DRF सीरियलाइज़र में उपलब्ध विभिन्न विकल्पों को समझकर, आप नेस्टेड ऑब्जेक्ट्स को प्रभावी ढंग से सीरियलाइज़ और डीसीरियलाइज़ कर सकते हैं, राइट ऑपरेशंस को संभाल सकते हैं, और प्रदर्शन के लिए अपने एपीआई को अनुकूलित कर सकते हैं। यह सुनिश्चित करने के लिए कि यह वैश्विक दर्शकों के लिए सुलभ है, अपने एपीआई को डिज़ाइन करते समय अंतर्राष्ट्रीयकरण और स्थानीयकरण पर विचार करना याद रखें। पूरी तरह से परीक्षण और स्पष्ट दस्तावेज़ आपके एपीआई की दीर्घकालिक रखरखाव और उपयोगिता सुनिश्चित करने की कुंजी हैं।