Django REST Framework ViewSets: API എൻഡ്‌പോയിന്റ് ഓർഗനൈസേഷൻ മാസ്റ്ററിംഗ് ചെയ്യുക

ആധുനിക വെബ് ഡെവലപ്‌മെൻ്റിൽ, ശക്തവും നന്നായി ചിട്ടപ്പെടുത്തിയതുമായ API-കൾ നിർമ്മിക്കുന്നത് നിർണായകമാണ്. Django REST Framework (DRF) എന്നത് Django ഉപയോഗിച്ച് RESTful API-കൾ നിർമ്മിക്കുന്നതിനുള്ള ശക്തമായ ടൂൾകിറ്റാണ്. API എൻഡ്‌പോയിന്റുകൾ നിർമ്മിക്കുന്നതിന് DRF വിവിധ ടൂളുകൾ വാഗ്ദാനം ചെയ്യുമ്പോൾ, ViewSet-കൾ ബന്ധപ്പെട്ട കാഴ്‌ചകളെ ഒരൊറ്റ ക്ലാസ്സിലേക്ക് ഓർഗനൈസുചെയ്യാനുള്ള മികച്ച മാർഗ്ഗം നൽകുന്നു, ഇത് കൂടുതൽ വൃത്തിയുള്ളതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ കോഡിലേക്ക് നയിക്കുന്നു. ഈ സമഗ്രമായ ഗൈഡ് ViewSet-കളെക്കുറിച്ച് വിശദമായി പര്യവേക്ഷണം ചെയ്യും, അവയുടെ ഗുണങ്ങൾ, ഉപയോഗം, വിപുലമായ കസ്റ്റമൈസേഷൻ ടെക്നിക്കുകൾ എന്നിവ ഉൾക്കൊള്ളുന്നു.

എന്താണ് ViewSet-കൾ?

ഒരു ViewSet എന്നത് ഒരു ക്ലാസ് അടിസ്ഥാനമാക്കിയുള്ള കാഴ്ചയാണ്, അത് list, create, retrieve, update, കൂടാതെ destroy പോലുള്ള സാധാരണ പ്രവർത്തനങ്ങൾക്കായി നടപ്പാക്കലുകൾ നൽകുന്നു. ഓരോ പ്രവർത്തനത്തിനും പ്രത്യേക കാഴ്‌ചകൾ നിർവചിക്കുന്നതിനുപകരം, ഒരു ViewSet അവയെ ഒരൊറ്റ ക്ലാസ്സിൽ സംയോജിപ്പിക്കുന്നു, API ഘടന ലളിതമാക്കുകയും കോഡ് ഡ്യൂപ്ലിക്കേഷൻ കുറയ്ക്കുകയും ചെയ്യുന്നു. മോഡൽ അടിസ്ഥാനമാക്കിയുള്ള API-കളിൽ പ്രവർത്തിക്കുമ്പോൾ ViewSet-കൾ പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്, അവിടെ ഈ സാധാരണ പ്രവർത്തനങ്ങൾ സാധാരണയായി ആവശ്യമാണ്. ഒരു പ്രത്യേക ഉറവിടത്തിലെ പ്രവർത്തനങ്ങളുടെ ലോജിക്കൽ ഗ്രൂപ്പിംഗായി ViewSet-നെക്കുറിച്ച് ചിന്തിക്കുക.

ViewSet-കൾ ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനങ്ങൾ

• കോഡ് വീണ്ടും ഉപയോഗിക്കാനുള്ള സാധ്യത: സാധാരണ API ലോജിക് ഒരൊറ്റ ക്ലാസ്സിൽ ഉൾക്കൊള്ളിച്ച് ViewSet-കൾ കോഡ് വീണ്ടും ഉപയോഗിക്കുന്നതിന് പ്രോത്സാഹിപ്പിക്കുന്നു. ഇത് അധികപ്പറ്റുകൾ കുറയ്ക്കുകയും കോഡ് പരിപാലിക്കാൻ എളുപ്പമാക്കുകയും ചെയ്യുന്നു.
• ലളിതമായ റൂട്ടിംഗ്: ഒരൊറ്റ URL പ്രിഫിക്സിന് കീഴിൽ ബന്ധപ്പെട്ട കാഴ്‌ചകളെ ഗ്രൂപ്പുചെയ്യുന്നതിലൂടെ ViewSet-കൾ റൂട്ടിംഗ് ലളിതമാക്കുന്നു. ഇത് വൃത്തിയുള്ളതും കൂടുതൽ ചിട്ടപ്പെടുത്തിയതുമായ URL ഘടനയിലേക്ക് നയിക്കുന്നു.
• കുറഞ്ഞ ബോയിലർപ്ലേറ്റ്: സാധാരണ API പ്രവർത്തനങ്ങൾക്കായി സ്ഥിരസ്ഥിതി നടപ്പാക്കലുകൾ നൽകുന്നതിലൂടെ ViewSet-കൾ ബോയിലർപ്ലേറ്റ് കോഡ് കുറയ്ക്കുന്നു. ഇത് ഡെവലപ്പർമാരെ അവരുടെ ആപ്ലിക്കേഷന് പ്രത്യേകമായ കസ്റ്റം ലോജിക് നടപ്പിലാക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ അനുവദിക്കുന്നു.
• മെച്ചപ്പെട്ട റീഡബിലിറ്റി: ബന്ധപ്പെട്ട കാഴ്‌ചകളെ ഒരൊറ്റ ക്ലാസ്സിലേക്ക് ഓർഗനൈസ് ചെയ്യുന്നതിലൂടെ ViewSet-കൾ കോഡ് റീഡബിലിറ്റി മെച്ചപ്പെടുത്തുന്നു. ഇത് API ഘടന മനസ്സിലാക്കാനും നാവിഗേറ്റ് ചെയ്യാനും എളുപ്പമാക്കുന്നു.
• സ്ഥിരത: ഒരു സാധാരണ ഓപ്പറേഷൻ, കൺവെൻഷനുകൾ എന്നിവ നടപ്പിലാക്കുന്നതിലൂടെ APIയിലുടനീളം സ്ഥിരത ഉറപ്പാക്കാൻ ViewSet-കൾ സഹായിക്കുന്നു. ഇത് APIയെ കൂടുതൽ പ്രവചനാതീതവും ഉപയോഗിക്കാൻ എളുപ്പവുമാക്കുന്നു.

ViewSet-കളുടെ അടിസ്ഥാന ഉപയോഗം

ഉൽപ്പന്നങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു API നിർമ്മിക്കാൻ ViewSet-കൾ ഉപയോഗിക്കുന്നതിൻ്റെ ലളിതമായ ഉദാഹരണത്തിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം. ആദ്യം, ഒരു മോഡൽ നിർവചിക്കുക:

            # models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return self.name

            

              
                Copy
              
            
          

അടുത്തതായി, Product മോഡലിനായി ഒരു സീരിയലൈസർ നിർവചിക്കുക:

            # serializers.py
from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = '__all__'

            

              
                Copy
              
            
          

ഇപ്പോൾ, Product മോഡലിനായി ഒരു ViewSet ഉണ്ടാക്കുക:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

            

              
                Copy
              
            
          

അവസാനമായി, URL റൂട്ടിംഗ് കോൺഫിഗർ ചെയ്യുക:

            # urls.py
from django.urls import path, include
from rest_framework import routers
from . import views

router = routers.DefaultRouter()
router.register(r'products', views.ProductViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

            

              
                Copy
              
            
          

ഈ കോൺഫിഗറേഷൻ ഇനിപ്പറയുന്ന API എൻഡ്‌പോയിന്റുകൾ സ്വയമേവ സൃഷ്ടിക്കും:

• /products/ (GET: list, POST: create)
• /products/{id}/ (GET: retrieve, PUT: update, PATCH: partial_update, DELETE: destroy)

ModelViewSet എല്ലാ സാധാരണ CRUD പ്രവർത്തനങ്ങൾക്കും സ്ഥിരസ്ഥിതി നടപ്പാക്കലുകൾ നൽകുന്നു. ViewSet പ്രവർത്തിപ്പിക്കേണ്ട ഒബ്‌ജക്റ്റുകളുടെ കൂട്ടം queryset ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു, കൂടാതെ ഡാറ്റ സീരിയലൈസ് ചെയ്യുന്നതിനും ഡീസെരിയലൈസ് ചെയ്യുന്നതിനും ഉപയോഗിക്കേണ്ട സീരിയലൈസർ serializer_class ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു.

ViewSet-കളുടെ തരങ്ങൾ

വ്യത്യസ്ത ഉപയോഗ കേസുകൾക്ക് അനുയോജ്യമായ നിരവധി അന്തർനിർമ്മിത ViewSet ക്ലാസുകൾ DRF നൽകുന്നു:

• ViewSet: എല്ലാ ViewSet-കൾക്കുമുള്ള അടിസ്ഥാന ക്ലാസ്. ഇത് അഭ്യർത്ഥനകളും പ്രതികരണങ്ങളും കൈകാര്യം ചെയ്യുന്നതിനുള്ള അടിസ്ഥാന ഇൻഫ്രാസ്ട്രക്ചർ നൽകുന്നു.
• ReadOnlyModelViewSet: റീഡ്-ഒൺലി പ്രവർത്തനങ്ങൾ (list, retrieve) നൽകുന്ന ഒരു ViewSet. ഡാറ്റ വീണ്ടെടുക്കാൻ മാത്രം അനുവദിക്കുന്ന API-കൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്.
• ModelViewSet: എല്ലാ സാധാരണ CRUD പ്രവർത്തനങ്ങളും (list, create, retrieve, update, കൂടാതെ destroy) നൽകുന്ന ഒരു ViewSet. മോഡൽ അടിസ്ഥാനമാക്കിയുള്ള API-കൾക്കായി ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ViewSet ഇതാണ്.
• GenericViewSet: സാധാരണ API പ്രവർത്തനങ്ങൾക്കായി ഒരു പൊതുവായ നടപ്പാക്കൽ നൽകുന്ന ഒരു ViewSet. കസ്റ്റം ViewSet-കൾ ഉണ്ടാക്കുന്നതിന് ഇത് അടിസ്ഥാന ക്ലാസ്സായി ഉപയോഗിക്കാം.

ശരിയായ ViewSet തിരഞ്ഞെടുക്കുന്നത് നിങ്ങളുടെ API-യുടെ പ്രത്യേക ആവശ്യകതകളെ ആശ്രയിച്ചിരിക്കുന്നു. നിങ്ങൾക്ക് റീഡ്-ഒൺലി പ്രവർത്തനങ്ങൾ മാത്രമേ ആവശ്യമുള്ളൂെങ്കിൽ, ReadOnlyModelViewSet ഉപയോഗിക്കുക. നിങ്ങൾക്ക് എല്ലാ സാധാരണ CRUD പ്രവർത്തനങ്ങളും വേണമെങ്കിൽ, ModelViewSet ഉപയോഗിക്കുക. API സ്വഭാവത്തിൽ നിങ്ങൾക്ക് കൂടുതൽ നിയന്ത്രണം ആവശ്യമാണെങ്കിൽ, GenericViewSet അല്ലെങ്കിൽ ViewSet-ൽ നിന്ന് ഇൻഹെറിറ്റ് ചെയ്ത് നിങ്ങൾക്ക് ഒരു കസ്റ്റം ViewSet ഉണ്ടാക്കാം.

ViewSet-കൾ കസ്റ്റമൈസ് ചെയ്യുക

അന്തർനിർമ്മിത ViewSet-കൾ API-കൾ നിർമ്മിക്കുന്നതിനുള്ള സൗകര്യപ്രദമായ മാർഗ്ഗം നൽകുമ്പോൾ, പ്രത്യേക ആവശ്യകതകൾ നിറവേറ്റുന്നതിനായി നിങ്ങൾ അവയുടെ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കേണ്ടി വന്നേക്കാം. രീതികൾ ഓവർറൈഡ് ചെയ്യുക, ഇഷ്ടമുള്ള പ്രവർത്തനങ്ങൾ ചേർക്കുക, ഇഷ്ടമുള്ള സീരിയലൈസറുകൾ ഉപയോഗിക്കുക എന്നിവയുൾപ്പെടെ ViewSet-കൾ കസ്റ്റമൈസ് ചെയ്യാൻ DRF നിരവധി വഴികൾ നൽകുന്നു.

രീതികൾ ഓവർറൈഡ് ചെയ്യുന്നു

നിങ്ങളുടെ ViewSet ക്ലാസ്സിൽ ഒരേ പേരുകളുള്ള രീതികൾ നിർവചിച്ചുകൊണ്ട് സാധാരണ API പ്രവർത്തനങ്ങളുടെ സ്ഥിരസ്ഥിതി നടപ്പാക്കലുകൾ നിങ്ങൾക്ക് ഓവർറൈഡ് ചെയ്യാൻ കഴിയും. ഉദാഹരണത്തിന്, ഒരു പുതിയ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നതിന് മുമ്പോ ശേഷമോ ഇഷ്ടമുള്ള ലോജിക് ചേർക്കാൻ നിങ്ങൾക്ക് create രീതി ഓവർറൈഡ് ചെയ്യാൻ കഴിയും:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.response import Response
from rest_framework import status

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        # Add custom logic here before creating the object
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, create രീതി സ്ഥിരസ്ഥിതി നടപ്പാക്കലിനെ മറികടക്കുകയും ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ് ഇഷ്ടമുള്ള ലോജിക് ചേർക്കുകയും ചെയ്യുന്നു. ഒബ്‌ജക്റ്റ് ശരിക്കും സൃഷ്‌ടിക്കാൻ perform_create രീതി വിളിക്കുന്നു, കൂടാതെ 201 Created സ്റ്റാറ്റസ് കോഡ് ഉപയോഗിച്ച് പ്രതികരണം നൽകുന്നു.

ഇഷ്ടമുള്ള പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു

@action ഡെക്കറേറ്റർ ഉപയോഗിച്ച് നിങ്ങളുടെ ViewSet-ലേക്ക് ഇഷ്ടമുള്ള പ്രവർത്തനങ്ങൾ ചേർക്കാൻ കഴിയും. ViewSet കൈകാര്യം ചെയ്യുന്ന ഉറവിടങ്ങളിൽ പ്രത്യേക പ്രവർത്തനങ്ങൾ നടത്തുന്ന പുതിയ API എൻഡ്‌പോയിന്റുകൾ നിർവചിക്കാൻ ഇഷ്ടമുള്ള പ്രവർത്തനങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ഉൽപ്പന്നം ഫീച്ചർ ചെയ്‌തതായി അടയാളപ്പെടുത്താൻ നിങ്ങൾക്ക് ഒരു പ്രവർത്തനം ചേർക്കാൻ കഴിയും:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework import status

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

    @action(detail=True, methods=['post'])
    def feature(self, request, pk=None):
        product = self.get_object()
        product.is_featured = True
        product.save()
        serializer = self.get_serializer(product)
        return Response(serializer.data)

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, @action ഡെക്കറേറ്റർ ഒരു പുതിയ API എൻഡ്‌പോയിന്റ് /products/{id}/feature/ നിർവചിക്കുന്നു, അത് ഒരു ഉൽപ്പന്നത്തെ ഫീച്ചർ ചെയ്‌തതായി അടയാളപ്പെടുത്തുന്നു. detail=True ആർഗ്യുമെൻ്റ് സൂചിപ്പിക്കുന്നത് പ്രവർത്തനം മോഡലിൻ്റെ ഒരു പ്രത്യേക ഇൻസ്റ്റൻസിൽ പ്രവർത്തിക്കുന്നു എന്നാണ്. methods=['post'] ആർഗ്യുമെൻ്റ് POST അഭ്യർത്ഥനകൾ മാത്രമേ പ്രവർത്തനം സ്വീകരിക്കൂ എന്ന് വ്യക്തമാക്കുന്നു.

ഇഷ്ടമുള്ള സീരിയലൈസറുകൾ ഉപയോഗിക്കുന്നു

ViewSet ഉപയോഗിച്ച് ഡാറ്റ സീരിയലൈസ് ചെയ്യുന്നതിനും ഡീസെരിയലൈസ് ചെയ്യുന്നതിനുമുള്ള രീതി ഇഷ്ടാനുസൃതമാക്കാൻ നിങ്ങൾക്ക് ഇഷ്ടമുള്ള സീരിയലൈസറുകൾ ഉപയോഗിക്കാം. സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകൾ കൈകാര്യം ചെയ്യാനോ ഇഷ്ടമുള്ള മൂല്യനിർണ്ണയം നടത്താനോ ഇത് ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, API പ്രതികരണത്തിൽ അനുബന്ധ ഡാറ്റ ഉൾപ്പെടുത്താൻ നിങ്ങൾക്ക് ഒരു ഇഷ്ടമുള്ള സീരിയലൈസർ ഉപയോഗിക്കാം:

            # serializers.py
from rest_framework import serializers
from .models import Product, Category

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

class ProductSerializer(serializers.ModelSerializer):
    category = CategorySerializer(read_only=True)

    class Meta:
        model = Product
        fields = '__all__'

            

              
                Copy
              
            
          

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, അനുബന്ധ വിഭാഗ ഡാറ്റ സീരിയലൈസ് ചെയ്യാൻ ProductSerializer ഒരു CategorySerializer ഉൾക്കൊള്ളുന്നു. ഒരൊറ്റ API അഭ്യർത്ഥനയിൽ ഉൽപ്പന്ന വിവരങ്ങളോടൊപ്പം വിഭാഗ വിവരങ്ങളും വീണ്ടെടുക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

വിപുലമായ ViewSet ടെക്നിക്കുകൾ

അടിസ്ഥാന ഉപയോഗത്തിനും കസ്റ്റമൈസേഷനും അപ്പുറം, ViewSet-കൾ സങ്കീർണ്ണമായ API-കൾ നിർമ്മിക്കുന്നതിനുള്ള വിപുലമായ ടെക്നിക്കുകൾ വാഗ്ദാനം ചെയ്യുന്നു:

ഫിൽട്ടറിംഗ്

അഭ്യർത്ഥന പാരാമീറ്ററുകളെ അടിസ്ഥാനമാക്കി ക്വറിസെറ്റ് ഫിൽട്ടർ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ശക്തമായ ഫിൽട്ടറിംഗ് കഴിവുകൾ DRF നൽകുന്നു. ഉപയോഗിക്കേണ്ട ഫിൽട്ടറിംഗ് ബാക്കെൻഡുകൾ വ്യക്തമാക്കാൻ നിങ്ങൾക്ക് filter_backends ആട്രിബ്യൂട്ട് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, പേര് അല്ലെങ്കിൽ വിവരണം അനുസരിച്ച് ഉൽപ്പന്നങ്ങൾ തിരയാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്നതിന് നിങ്ങൾക്ക് SearchFilter ഉപയോഗിക്കാം:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework import filters

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['name', 'description']

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, SearchFilter ഉപയോഗിക്കണമെന്ന് filter_backends ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു. തിരയേണ്ട ഫീൽഡുകൾ search_fields ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു.

പേജിനേഷൻ

വലിയ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്. ക്വറിസെറ്റിനെ ചെറിയ പേജുകളായി വിഭജിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന പേജിനേഷൻ കഴിവുകൾ DRF നൽകുന്നു. ഉപയോഗിക്കേണ്ട പേജിനേഷൻ ക്ലാസ് വ്യക്തമാക്കാൻ നിങ്ങൾക്ക് pagination_class ആട്രിബ്യൂട്ട് ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, പേജ് നമ്പറുകൾ ഉപയോഗിച്ച് ഫലങ്ങൾ പേജിനേറ്റ് ചെയ്യാൻ നിങ്ങൾക്ക് PageNumberPagination ഉപയോഗിക്കാം:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.pagination import PageNumberPagination

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    pagination_class = PageNumberPagination

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, PageNumberPagination ഉപയോഗിക്കണമെന്ന് pagination_class ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു. നിങ്ങളുടെ സ്വന്തം പേജിനേഷൻ ക്ലാസ് ഉണ്ടാക്കി നിങ്ങൾക്ക് പേജിനേഷൻ സ്വഭാവം ഇഷ്ടാനുസൃതമാക്കാനും കഴിയും.

ഓതൻ്റിക്കേഷനും പെർമിഷനുകളും

നിങ്ങളുടെ API എൻഡ്‌പോയിന്റുകളിലേക്കുള്ള ആക്‌സസ് നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഫ്ലെക്സിബിൾ ഓതൻ്റിക്കേഷൻ, പെർമിഷൻ മെക്കാനിസങ്ങൾ DRF നൽകുന്നു. ഉപയോഗിക്കേണ്ട ഓതൻ്റിക്കേഷൻ, പെർമിഷൻ ക്ലാസുകൾ വ്യക്തമാക്കാൻ നിങ്ങൾക്ക് authentication_classes, permission_classes ആട്രിബ്യൂട്ടുകൾ ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, ടോക്കണുകൾ ഉപയോഗിച്ച് ഉപയോക്താക്കളെ ഓതൻ്റിക്കേറ്റ് ചെയ്യാൻ നിങ്ങൾക്ക് TokenAuthentication ഉപയോഗിക്കാം, കൂടാതെ ഓതൻ്റിക്കേറ്റ് ചെയ്ത ഉപയോക്താക്കളെ മാത്രമേ API ആക്‌സസ് ചെയ്യാൻ അനുവദിക്കൂ എന്ന് ഉറപ്പാക്കാൻ IsAuthenticated പെർമിഷനും ഉപയോഗിക്കാം:

            # views.py
from rest_framework import viewsets
from .models import Product
from .serializers import ProductSerializer
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated

class ProductViewSet(viewsets.ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer
    authentication_classes = [TokenAuthentication]
    permission_classes = [IsAuthenticated]

            

              
                Copy
              
            
          

ഈ ഉദാഹരണത്തിൽ, TokenAuthentication ഉപയോഗിക്കണമെന്ന് authentication_classes ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു, കൂടാതെ IsAuthenticated പെർമിഷൻ ഉപയോഗിക്കണമെന്ന് permission_classes ആട്രിബ്യൂട്ട് വ്യക്തമാക്കുന്നു.

ViewSet-കൾ ഉപയോഗിക്കുന്നതിനുള്ള മികച്ച രീതികൾ

നിങ്ങളുടെ ViewSet-കൾ നന്നായി രൂപകൽപ്പന ചെയ്‌തതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമാണെന്ന് ഉറപ്പാക്കാൻ, ഈ മികച്ച രീതികൾ പിന്തുടരുക:

• ViewSet-കൾ ഫോക്കസ് ചെയ്‌തതായി സൂക്ഷിക്കുക: ഓരോ ViewSet-ഉം ഒരു സിംഗിൾ ഉറവിടം അല്ലെങ്കിൽ അടുത്ത ബന്ധമുള്ള ഉറവിടങ്ങളുടെ ഒരു കൂട്ടം കൈകാര്യം ചെയ്യുന്നതിന് ഉത്തരവാദി ആയിരിക്കണം. ഒന്നിലധികം ബന്ധമില്ലാത്ത പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യുന്ന അമിതമായി സങ്കീർണ്ണമായ ViewSet-കൾ ഉണ്ടാക്കുന്നത് ഒഴിവാക്കുക.
• അനുയോജ്യമായ ViewSet തരങ്ങൾ ഉപയോഗിക്കുക: നിങ്ങളുടെ API-യുടെ ആവശ്യകതകൾക്ക് ഏറ്റവും അനുയോജ്യമായ ViewSet തരം തിരഞ്ഞെടുക്കുക. റീഡ്-ഒൺലി API-കൾക്കായി ReadOnlyModelViewSet, CRUD API-കൾക്കായി ModelViewSet, കൂടാതെ കസ്റ്റം API-കൾക്കായി GenericViewSet അല്ലെങ്കിൽ ViewSet എന്നിവ ഉപയോഗിക്കുക.
• RESTful തത്വങ്ങൾ പിന്തുടരുക: RESTful തത്വങ്ങൾക്കനുസൃതമായി നിങ്ങളുടെ API എൻഡ്‌പോയിന്റുകൾ രൂപകൽപ്പന ചെയ്യുക. ഉറവിടങ്ങളിൽ പ്രവർത്തനങ്ങൾ നടത്താൻ സാധാരണ HTTP രീതികൾ (GET, POST, PUT, PATCH, DELETE) ഉപയോഗിക്കുക.
• ഡാറ്റാ മൂല്യനിർണ്ണയത്തിനായി സീരിയലൈസറുകൾ ഉപയോഗിക്കുക: API-യിലേക്ക് അയയ്‌ക്കുന്നതും സ്വീകരിക്കുന്നതുമായ ഡാറ്റ സാധൂകരിക്കാൻ സീരിയലൈസറുകൾ ഉപയോഗിക്കുക. ഇത് ഡാറ്റാ സമഗ്രത ഉറപ്പാക്കാൻ സഹായിക്കുകയും പിശകുകൾ തടയുകയും ചെയ്യുന്നു.
• കൃത്യമായ ഓതൻ്റിക്കേഷനും പെർമിഷനുകളും നടപ്പിലാക്കുക: കൃത്യമായ ഓതൻ്റിക്കേഷനും പെർമിഷനുകളും നടപ്പിലാക്കി നിങ്ങളുടെ API എൻഡ്‌പോയിന്റുകൾ സുരക്ഷിതമാക്കുക. അനധികൃത ആക്‌സസ്സിൽ നിന്ന് നിങ്ങളുടെ ഡാറ്റ പരിരക്ഷിക്കാൻ ഇത് സഹായിക്കുന്നു.
• സമഗ്രമായ ടെസ്റ്റുകൾ എഴുതുക: നിങ്ങളുടെ ViewSet-കൾ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ സമഗ്രമായ ടെസ്റ്റുകൾ എഴുതുക. ഇത് റിഗ്രഷനുകൾ തടയാൻ സഹായിക്കുകയും കോഡ് പരിപാലിക്കാൻ എളുപ്പമാക്കുകയും ചെയ്യുന്നു.

അന്താരാഷ്ട്രവൽക്കരണം (i18n), പ്രാദേശികവൽക്കരണം (l10n) പരിഗണനകൾ

ഒരു ആഗോള പ്രേക്ഷകർക്കായി API-കൾ നിർമ്മിക്കുമ്പോൾ, അന്താരാഷ്ട്രവൽക്കരണം (i18n), പ്രാദേശികവൽക്കരണം (l10n) എന്നിവ പരിഗണിക്കേണ്ടത് അത്യാവശ്യമാണ്. ഒന്നിലധികം ഭാഷകളെയും പ്രദേശങ്ങളെയും പിന്തുണയ്ക്കാൻ ViewSet-കൾക്ക് കഴിയും:

• സീരിയലൈസർ ഫീൽഡുകൾ: വിവർത്തനം ചെയ്‌ത ഫീൽഡ് ലേബലുകളും സഹായ വാചകങ്ങളും പ്രദർശിപ്പിക്കുന്നതിന് ഉചിതമായ വിവർത്തന ഫംഗ്‌ഷനുകളുള്ള (ഉദാഹരണത്തിന്, Django-യുടെ i18n ഫ്രെയിംവർക്കിൽ നിന്നുള്ള gettext) DRF-ൻ്റെ സീരിയലൈസർ ഫീൽഡുകൾ ഉപയോഗിക്കുക.
• പിശക് സന്ദേശങ്ങൾ: API നൽകുന്ന പിശക് സന്ദേശങ്ങൾ ഉപയോക്താവിൻ്റെ ഇഷ്ടപ്പെട്ട ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്‌തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.
• തീയതിയും സമയവും ഫോർമാറ്റ് ചെയ്യുക: ഉപയോക്താവിൻ്റെ ലൊക്കേലിനെ അടിസ്ഥാനമാക്കി ഉചിതമായ തീയതിയും സമയവും ഫോർമാറ്റ് ചെയ്യുക. തീയതിയും സമയവും ഫോർമാറ്റുകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റാനുള്ള ഓപ്ഷനുകൾ DRF നൽകുന്നു.
• കറൻസി ഫോർമാറ്റിംഗ്: ഉപയോക്താവിൻ്റെ ലൊക്കേൽ അനുസരിച്ച് കറൻസി മൂല്യങ്ങൾ ഫോർമാറ്റ് ചെയ്യുക. കറൻസി ഫോർമാറ്റ് ചെയ്യുന്നതിന് babel പോലുള്ള ലൈബ്രറികൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. ഉദാഹരണത്തിന്, USD-യിലെ 1234.56 എന്ന വില യുഎസിൽ $1,234.56 ആയി ഫോർമാറ്റ് ചെയ്‌തേക്കാം, എന്നാൽ ചില യൂറോപ്യൻ രാജ്യങ്ങളിൽ ഇത് 1.234,56 $ ആയിരിക്കും.
• സമയ മേഖലകൾ: സമയ മേഖലകൾ ശരിയായി കൈകാര്യം ചെയ്യുക. തീയതികളും സമയങ്ങളും UTC-യിൽ സംഭരിക്കുക, അവ പ്രദർശിപ്പിക്കുമ്പോൾ ഉപയോക്താവിൻ്റെ പ്രാദേശിക സമയ മേഖലയിലേക്ക് മാറ്റുക.

ഉദാഹരണത്തിന്, ഒരു ഉൽപ്പന്നത്തിന് വിവർത്തനം ചെയ്യേണ്ട ഒരു വിവരണം ഉണ്ടായിരിക്കാം. സീരിയലൈസറിനുള്ളിൽ നിങ്ങൾ Django-യുടെ വിവർത്തന സംവിധാനം ഉപയോഗിക്കും:

            # serializers.py
from rest_framework import serializers
from django.utils.translation import gettext_lazy as _
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    description = serializers.CharField(help_text=_("Product description"))

    class Meta:
        model = Product
        fields = '__all__'

            

              
                Copy
              
            
          

ഈ സീരിയലൈസർ ഉപയോഗിക്കുന്ന നിങ്ങളുടെ ടെംപ്ലേറ്റുകളിലോ കോഡിലോ, ശരിയായ ഭാഷ സജീവമാക്കിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.

ഉദാഹരണം: അന്താരാഷ്ട്ര പിന്തുണയുള്ള ഇ-കൊമേഴ്‌സ് API

ആഗോളതലത്തിൽ ഉൽപ്പന്നങ്ങൾ വിൽക്കുന്ന ഒരു ഇ-കൊമേഴ്‌സ് API-യെക്കുറിച്ച് സങ്കൽപ്പിക്കുക. Product മോഡലിൽ name, description, price, കൂടാതെ image പോലുള്ള ഫീൽഡുകൾ ഉൾപ്പെട്ടേക്കാം. API ഒന്നിലധികം ഭാഷകളെയും കറൻസികളെയും പിന്തുണയ്ക്കേണ്ടതുണ്ട്.

ViewSet ഉൽപ്പന്നങ്ങൾക്കായുള്ള അടിസ്ഥാന CRUD പ്രവർത്തനങ്ങൾ കൈകാര്യം ചെയ്യും. ഉൽപ്പന്നത്തിൻ്റെ പേരും വിവരണവും വിവർത്തനം ചെയ്യുന്നതിനെ പിന്തുണയ്ക്കുന്നതിന് സീരിയലൈസറുകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റും. വിഭാഗമനുസരിച്ച് ഉൽപ്പന്നങ്ങൾ വീണ്ടെടുക്കുന്നതിനും, വില പരിധിയനുസരിച്ച് ഉൽപ്പന്നങ്ങൾ ഫിൽട്ടർ ചെയ്യുന്നതിനും, കീവേഡ് ഉപയോഗിച്ച് ഉൽപ്പന്നങ്ങൾ തിരയുന്നതിനും API-യിൽ എൻഡ്‌പോയിന്റുകൾ ഉൾപ്പെടും. ഈ സവിശേഷതകൾ അന്താരാഷ്ട്രവൽക്കരണം പരിഗണിക്കണം, പ്രത്യേകിച്ചും തിരയൽ പദങ്ങളെക്കുറിച്ചും ഭാഷകൾക്കിടയിൽ വ്യത്യാസമുണ്ടാകാവുന്ന ഉൽപ്പന്ന വിവരണങ്ങളെക്കുറിച്ചും.

URL-കളുടെ ഉദാഹരണം:

• /en/products/ - ഇംഗ്ലീഷിലുള്ള ഉൽപ്പന്നങ്ങളുടെ ലിസ്റ്റ്
• /fr/products/ - ഫ്രഞ്ചിലുള്ള ഉൽപ്പന്നങ്ങളുടെ ലിസ്റ്റ്
• /en/products/?currency=USD - USD-യിലുള്ള ഉൽപ്പന്നങ്ങളുടെ ലിസ്റ്റ്
• /fr/products/123/?currency=EUR - ഫ്രഞ്ചിലുള്ള 123 ഉൽപ്പന്നത്തിൻ്റെ വിശദാംശങ്ങൾ, വില EUR-ൽ പ്രദർശിപ്പിക്കും

ഉപസംഹാരം

Django REST Framework ViewSet-കൾ നിങ്ങളുടെ API എൻഡ്‌പോയിന്റുകൾ ഓർഗനൈസ് ചെയ്യുന്നതിനുള്ള ശക്തവും മികച്ചതുമായ മാർഗ്ഗം നൽകുന്നു. ബന്ധപ്പെട്ട കാഴ്‌ചകളെ ഒരൊറ്റ ക്ലാസ്സിലേക്ക് എൻ‌കാപ്‌സുലേറ്റ് ചെയ്യുന്നതിലൂടെ ViewSet-കൾ കോഡ് വീണ്ടും ഉപയോഗിക്കാനുള്ള സാധ്യത വർദ്ധിപ്പിക്കുകയും റൂട്ടിംഗ് ലളിതമാക്കുകയും കോഡ് റീഡബിലിറ്റി മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. രീതികൾ ഓവർറൈഡ് ചെയ്യുക, ഇഷ്ടമുള്ള പ്രവർത്തനങ്ങൾ ചേർക്കുക, ഇഷ്ടമുള്ള സീരിയലൈസറുകൾ ഉപയോഗിക്കുക എന്നിവയിലൂടെ ViewSet-കൾ കസ്റ്റമൈസ് ചെയ്യാനുള്ള കഴിവ് ഉപയോഗിച്ച്, നിങ്ങളുടെ API-യുടെ പ്രത്യേക ആവശ്യകതകൾ നിറവേറ്റുന്നതിനായി നിങ്ങൾക്ക് അവയെ മാറ്റിയെടുക്കാൻ കഴിയും. ഈ ഗൈഡിൽ പറഞ്ഞിട്ടുള്ള മികച്ച രീതികൾ പിന്തുടരുന്നതിലൂടെ, നിങ്ങളുടെ ViewSet-കൾ നന്നായി രൂപകൽപ്പന ചെയ്‌തതും പരിപാലിക്കാൻ എളുപ്പമുള്ളതും സ്കേലബിളുമാണെന്ന് നിങ്ങൾക്ക് ഉറപ്പാക്കാൻ കഴിയും, ഇത് ശക്തവും കാര്യക്ഷമവുമായ API-കളിലേക്ക് നയിക്കുന്നു.

ഒരു ആഗോള പ്രേക്ഷകർക്കായി API-കൾ നിർമ്മിക്കുമ്പോൾ അന്താരാഷ്ട്രവൽക്കരണവും പ്രാദേശികവൽക്കരണവും പരിഗണിക്കാൻ ഓർമ്മിക്കുക. ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾക്ക് തടസ്സമില്ലാത്ത അനുഭവം നൽകുന്നതിന് ഒന്നിലധികം ഭാഷകൾ, കറൻസികൾ, സമയ മേഖലകൾ എന്നിവ പിന്തുണയ്ക്കുന്നതിനായി നിങ്ങളുടെ ViewSet-കളും സീരിയലൈസറുകളും മാറ്റുക.

ViewSet-കളിൽ പ്രാവീണ്യം നേടുന്നതിലൂടെ, നിങ്ങളുടെ Django REST Framework കഴിവുകളെ അടുത്ത ഘട്ടത്തിലേക്ക് കൊണ്ടുപോകാനും ശക്തവും പരിപാലിക്കാൻ കഴിയുന്നതുമായ API-കൾ നിർമ്മിക്കാനും കഴിയും. ഇത് ഉയർന്ന നിലവാരമുള്ള സോഫ്റ്റ്‌വെയറിനും നിങ്ങളുടെ ആഗോള പ്രേക്ഷകർക്ക് നല്ല ഉപയോക്തൃ അനുഭവത്തിനും സഹായിക്കുന്നു.

നിങ്ങളുടെ Django REST Framework പ്രോജക്റ്റുകളിൽ ViewSet-കളെക്കുറിച്ച് മനസ്സിലാക്കുന്നതിനും നടപ്പിലാക്കുന്നതിനും ഈ ഗൈഡ് ഒരു ശക്തമായ അടിത്തറയായി വർത്തിക്കണം. ഒരു യഥാർത്ഥ ViewSet മാസ്റ്ററാകാൻ പരിശീലനം തുടരുക, പരീക്ഷിക്കുക, DRF ഡോക്യുമെൻ്റേഷൻ കണ്ടെത്തുക!