पायथन DRF सिरीयलायझर संबंध: नेस्टेड ऑब्जेक्ट सिरीयलायझेशनमध्ये प्राविण्य मिळवा

Django REST Framework (DRF) वेब API तयार करण्यासाठी एक शक्तिशाली आणि लवचिक प्रणाली प्रदान करते. API डेव्हलपमेंटचा एक महत्त्वाचा भाग म्हणजे डेटा मॉडेलमधील संबंध हाताळणे आणि DRF सिरीयलायझर्स नेस्टेड ऑब्जेक्ट्स सिरीयलाईझ आणि डिसेरीयलाईझ करण्यासाठी मजबूत यंत्रणा देतात. हे मार्गदर्शक DRF सिरीयलायझर्समधील संबंध व्यवस्थापित करण्याचे विविध मार्ग शोधते, व्यावहारिक उदाहरणे आणि सर्वोत्तम पद्धती प्रदान करते.

सिरीयलायझर संबंध समजून घेणे

रिलेशनल डेटाबेसमध्ये, संबंध वेगवेगळ्या टेबल्स किंवा मॉडेल कसे जोडलेले आहेत हे परिभाषित करतात. API वापरासाठी डेटाबेस ऑब्जेक्ट्स JSON किंवा इतर डेटा फॉरमॅटमध्ये रूपांतरित करताना DRF सिरीयलायझर्सना हे संबंध प्रतिबिंबित करणे आवश्यक आहे. आम्ही संबंधांचे तीन प्राथमिक प्रकार कव्हर करू:

• 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') # आंतरराष्ट्रीय संदर्भासाठी देश फील्ड जोडले

    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

त्याच्या संबंधित `Author` डेटासह `Book` मॉडेल सिरीयलाईझ करण्यासाठी, आम्ही नेस्टेड सिरीयलायझर वापरू शकतो:

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) # PrimaryKeyRelatedField मधून बदलले

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

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

आता, जेव्हा आपण `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) # ManyToManyField साठी many=True आवश्यक आहे

    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') # आंतरराष्ट्रीय संदर्भासाठी स्थान जोडले

    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"
    }
}

Write ऑपरेशन्स (Create आणि Update) हाताळणे

वरील उदाहरणे प्रामुख्याने रीड-ओनली सिरीयलायझेशनवर लक्ष केंद्रित करतात. संबंधित ऑब्जेक्ट्स तयार किंवा अद्यतनित करण्यास अनुमती देण्यासाठी, आपल्याला आपल्या सिरीयलायझरमध्ये `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` वापरू शकता. हे उपयुक्त आहे जेव्हा आपल्याला फक्त संबंधित ऑब्जेक्टच्या ID चा संदर्भ देण्याची आवश्यकता असते आणि संपूर्ण ऑब्जेक्ट सिरीयलाईझ करायचा नाही.

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

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

आता, `author` फील्डमध्ये लेखकाचा ID असेल:

{
    "id": 1,
    "title": "1984",
    "author": 3,  // लेखक ID
    "publication_date": "1949-06-08"
}

तयार करण्यासाठी आणि अद्यतनित करण्यासाठी, आपण विनंती डेटामध्ये लेखकाचा ID पास कराल. `queryset=Author.objects.all()` हे सुनिश्चित करते की प्रदान केलेला ID डेटाबेसमध्ये अस्तित्वात आहे.

`HyperlinkedRelatedField` वापरणे

`HyperlinkedRelatedField` संबंधित ऑब्जेक्टच्या API एंडपॉइंटवर हायपरलिंक्स वापरून संबंध दर्शवते. हे हायपरमीडिया API मध्ये सामान्य आहे (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 सारख्या तंत्रांचा वापर करा. जागतिक स्तरावर वापरकर्त्यांना सेवा देणाऱ्या API साठी हे विशेषतः महत्वाचे आहे ज्यांचे कनेक्शन धीमे असू शकतात.
• शून्य मूल्ये हाताळणे: आपल्या सिरीयलायझर्समध्ये शून्य मूल्ये कशी हाताळली जातात याबद्दल जागरूक रहा, विशेषत: पर्यायी संबंधांशी व्यवहार करताना. आवश्यक असल्यास आपल्या सिरीयलायझर फील्डमध्ये `allow_null=True` वापरा.
• प्रमाणीकरण: डेटा अखंडता सुनिश्चित करण्यासाठी मजबूत प्रमाणीकरण अंमलात आणा, विशेषत: संबंधित ऑब्जेक्ट्स तयार करताना किंवा अद्यतनित करताना. व्यवसाय नियम लागू करण्यासाठी सानुकूल व्हॅलिडेटर वापरण्याचा विचार करा. उदाहरणार्थ, पुस्तकाची प्रकाशन तारीख भविष्यात नसावी.
• आंतरराष्ट्रीयकरण आणि स्थानिकीकरण (i18n/l10n): आपला डेटा वेगवेगळ्या भाषा आणि प्रदेशांमध्ये कसा प्रदर्शित केला जाईल याचा विचार करा. वापरकर्त्याच्या लोकेलसाठी योग्यरित्या तारखा, संख्या आणि चलने स्वरूपित करा. आपल्या मॉडेल आणि सिरीयलायझर्समध्ये आंतरराष्ट्रीय करण्यायोग्य स्ट्रिंग्ज साठवा.

सिरीयलायझर संबंधांसाठी सर्वोत्तम पद्धती

• सिरीयलायझर्स केंद्रित ठेवा: प्रत्येक सिरीयलायझर एका विशिष्ट मॉडेल किंवा डेटाच्या जवळच्या संबंधित संचास सिरीयलाईझ करण्यासाठी जबाबदार असावा. जास्त जटिल सिरीयलायझर्स तयार करणे टाळा.
• स्पष्ट सिरीयलायझर्स वापरा: `depth` पर्यायावर जास्त अवलंबून राहणे टाळा. सिरीयलायझेशन प्रक्रियेवर अधिक नियंत्रण ठेवण्यासाठी प्रत्येक संबंधित मॉडेलसाठी स्पष्ट सिरीयलायझर्स परिभाषित करा.
• चाचणी पूर्णपणे करा: आपले सिरीयलायझर्स डेटा योग्यरित्या सिरीयलाईझ आणि डिसेरीयलाईझ करत आहेत हे सत्यापित करण्यासाठी युनिट चाचण्या लिहा, विशेषत: जटिल संबंधांशी व्यवहार करताना.
• आपल्या API चे दस्तऐवजीकरण करा: आपल्या API एंडपॉइंट्स आणि ते कोणत्या डेटा फॉरमॅटची अपेक्षा करतात आणि परत करतात याचे स्पष्टपणे दस्तऐवजीकरण करा. इंटरएक्टिव्ह API दस्तऐवजीकरण तयार करण्यासाठी Swagger किंवा OpenAPI सारखी साधने वापरा.
• API आवृत्तीकरणाचा विचार करा: जसा तुमचा API विकसित होतो, तसतसे विद्यमान क्लायंटशी सुसंगतता राखण्यासाठी आवृत्तीकरण वापरा. हे आपल्याला जुन्या ऍप्लिकेशन्सवर परिणाम न करता ब्रेकिंग बदल सादर करण्यास अनुमती देते.
• कार्यक्षमतेचे परीक्षण करा: आपल्या API च्या कार्यक्षमतेचे परीक्षण करा आणि सिरीयलायझर संबंधांशी संबंधित कोणतेही अडथळे ओळखा. डेटाबेस क्वेरी आणि सिरीयलायझेशन लॉजिक ऑप्टिमाइझ करण्यासाठी प्रोफाइलिंग साधनांचा वापर करा.

निष्कर्ष

मजबूत आणि कार्यक्षम वेब API तयार करण्यासाठी Django REST Framework मध्ये सिरीयलायझर संबंधांमध्ये प्रभुत्व मिळवणे आवश्यक आहे. विविध प्रकारचे संबंध आणि DRF सिरीयलायझर्समध्ये उपलब्ध असलेले विविध पर्याय समजून घेऊन, आपण नेस्टेड ऑब्जेक्ट्स प्रभावीपणे सिरीयलाईझ आणि डिसेरीयलाईझ करू शकता, write ऑपरेशन्स हाताळू शकता आणि कार्यक्षमतेसाठी आपले API ऑप्टिमाइझ करू शकता. जागतिक प्रेक्षकांसाठी ते प्रवेशयोग्य आहे याची खात्री करण्यासाठी आपले API डिझाइन करताना आंतरराष्ट्रीयकरण आणि स्थानिकीकरणाचा विचार करण्याचे लक्षात ठेवा. API ची दीर्घकालीन देखभाल क्षमता आणि उपयोगिता सुनिश्चित करण्यासाठी संपूर्ण चाचणी आणि स्पष्ट दस्तऐवजीकरण हे महत्त्वाचे आहे.