A szerializáció az adatok olyan formátumba történő átalakításának folyamata, amely tárolható vagy továbbítható, majd rekonstruálható. Ezt használják minden alkalommal, amikor a fejlődő alkalmazások vagy adatok tárolására adatbázisokban, a memóriában, vagy konvertáló fájlokat.

nemrég segítettem a labcodes két fiatal fejlesztőjének megérteni a szerializátorokat, és úgy gondoltam, jó lenne megosztani a megközelítésemet Opensource.com olvasók.

tegyük fel, hogy szoftvereket hoz létre egy e-kereskedelmi Webhelyhez, és van egy rendelése, amely regisztrálja egy termék megvásárlását valaki által, áron, egy dátumon:

class Order:
def __init__(self, product, customer, price, date):
self.product = product
self.customer = customer
self.price = price
self.date = date

most képzelje el, hogy a rendelési adatokat egy kulcsérték-adatbázisból szeretné tárolni és letölteni. Szerencsére a kezelőfelület elfogadja és visszaadja a szótárakat, így az objektumot szótárvá kell konvertálni:

def serialize_order(order):
return {
'product': order.product,
'customer': order.customer,
'price': order.price,
'date': order.date
}

és ha adatokat szeretne szerezni az adatbázisból, akkor megkaphatja a dict adatokat, és ezt a rendelési objektummá alakíthatja:

def deserialize_order(order_data):
return Order(
product=order_data,
customer=order_data,
price=order_data,
date=order_data,
)

Ez elég egyszerű az egyszerű adatokkal, de ha komplex attribútumokból álló összetett objektumokkal kell foglalkoznunk, ez a megközelítés nem skálázódik jól. A különböző típusú mezők érvényesítését is kezelnie kell, és ez sok munkát igényel manuálisan.

Ez az, ahol a keretrendszerek szerializátorai hasznosak. Lehetővé teszik, hogy kis kazánlemezekkel szerializátorokat hozzon létre, amelyek az összetett esetekben működnek.

a Django egy sorosítási modullal rendelkezik, amely lehetővé teszi a modellek “lefordítását” más formátumokba:

from django.core import serializers
serializers.serialize('json', Order.objects.all())

a webes alkalmazások, például a JSON, a YAML és az XML leggyakrabban használt eseteit tartalmazza. De használhat harmadik féltől származó szerializátorokat is, vagy létrehozhat saját. Csak regisztrálnia kell azt a settings.py file:

# settings.py
SERIALIZATION_MODULES = {
'my_format': appname.serializers.MyFormatSerializer,
}

a saját MyFormatSerializer létrehozásához végre kell hajtania a .serialize() módszert, és el kell fogadnia a lekérdezést és az extra opciókat paraméterként:

class MyFormatSerializer:
def serialize(self, queryset, **options):
# serious serialization happening

most már sorosíthatja a lekérdezéseket az új formátumra:

from django.core import serializers
serializers.serialize('my_format', Order.objects.all())

az opciók paramétereivel meghatározhatja a szerializátor viselkedését. Például, ha meg szeretné határozni, hogy beágyazott sorosítással fog dolgozni a ForeignKeys kezelésekor, vagy csak azt szeretné, hogy az adatok visszaadják az elsődleges kulcsokat, átadhatja a flat=True param opcióként, és kezelheti ezt a módszeren belül:

class MyFormatSerializer:
def serializer(self, queryset, **options):
if options.get('flat', False):
# don't recursively serialize relationships
# recursively serialize relationships

a Django serializációjának egyik módja a loaddata és dumpdata kezelési parancsok.

DRF szerializátorok

a Django közösségben a Django REST framework (DRF) kínálja a legismertebb szerializátorokat. Bár a Django serializers segítségével elkészítheti azt a JSON-t, amelyre válaszolni fog az API-ban, a REST framework szolgáltatása olyan szép funkciókkal rendelkezik, amelyek segítenek az összetett adatok kezelésében és egyszerű érvényesítésében.

a sorrendben példa, akkor létrehozhat egy szerializáló, mint ez:

from restframework import serializers
class OrderSerializer(serializers.Serializer):
product = serializers.CharField(max_length=255)
customer = serializers.CharField(max_lenght=255)
price = serializers.DecimalField(max_digits=5, decimal_places=2)
date = serializers.DateField()

és könnyen szerializálja az adatokat:

order = Order('pen', 'renato', 10.50, date.today())
serializer = OrderSerializer(order)
serializer.data
# {'product': 'pen', 'customer': 'renato', 'price': '10.50', 'date': '2020-08-16'}

ahhoz, hogy vissza egy példányt az adatok, meg kell végrehajtani két módszer-létrehozása és frissítése:

from rest_framework import serializers
class OrderSerializer(serializers.Serializer):
product = serializers.CharField(max_length=255)
customer = serializers.CharField(max_length=255)
price = serializers.DecimalField(max_digits=5, decimal_places=2)
date = serializers.DateField()
def create(self, validated_data):
# perform order creation
return order
def update(self, instance, validated_data):
# perform instance update
return instance

ezután létrehozhat vagy frissíthet példányokat a is_valid() az adatok érvényesítéséhez és save() példány létrehozásához vagy frissítéséhez:

serializer = OrderSerializer(**data)
## to validate data, mandatory before calling save
serializer.is_valid()
serializer.save()

modellszerializátorok

az adatok szerializálásakor gyakran meg kell tennie egy adatbázisból, tehát a modelljeiből. A ModelSerializer, mint egy ModelForm, API-t biztosít a modellekből származó szerializátorok létrehozásához. Tegyük fel, hogy van egy rendelési modellje:

from django.db import models
class Order(models.Model):
product = models.CharField(max_length=255)
customer = models.CharField(max_length=255)
price = models.DecimalField(max_digits=5, decimal_places=2)
date = models.DateField()

ehhez létrehozhat egy sorosítót:

from rest_framework import serializers
class OrderSerializer(serializers.ModelSerializer):
class Meta:
model = Order
fields = '__all__'

a Django automatikusan tartalmazza az összes modellmezőt a sorosítóban, és létrehozza a create és update módszereket.

szerializátorok használata osztályalapú nézetekben (CBV-k)

mint a Django CBV-jével rendelkező űrlapok, a szerializátorok jól integrálódnak a DRFs-be. Beállíthatja a serializer_class attribútumot úgy, hogy a szerializáló elérhető legyen a nézet számára:

from rest_framework import generics
class OrderListCreateAPIView(generics.ListCreateAPIView):
queryset = Order.objects.all()
serializer_class = OrderSerializer

megadhatja a get_serializer_class() módszert is:

from rest_framework import generics
class OrderListCreateAPIView(generics.ListCreateAPIView):
queryset = Order.objects.all()
def get_serializer_class(self):
if is_free_order():
return FreeOrderSerializer
return OrderSerializer

A CBV-kben vannak más módszerek is, amelyek kölcsönhatásba lépnek a szerializátorokkal. Például a get_serializer () egy már példányosított szerializátort ad vissza, míg a get_serializer_context () azokat az argumentumokat adja vissza, amelyeket a példány létrehozásakor átad a szerializátornak. Az adatokat létrehozó vagy frissítő nézetek esetén acreateés aupdateais_validmetódussal érvényesíti az adatokat, és a perform_create és perform_update a serializer mentési metódusát hívja meg.

További információ

Vélemény, hozzászólás?

Az e-mail-címet nem tesszük közzé.