Kem Intensif Pembangunan Bahagian Belakang FastAPI · Pelajaran

Pemodelan Dokumen dengan Beanie ODM

Takrifkan model dokumen bertip, indeks dan struktur terbenam menggunakan Beanie berasaskan Pydantic.

Pelajaran 2 daripada 413 langkah

Pemodelan Dokumen dengan Beanie ODM ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Perkara yang Dibawa oleh Beanie kepada FastAPI

Beanie ialah ODM tak segerak (Pemetaan Dokumen-Objek) untuk MongoDB yang dibina terus berasaskan Pydantic dan pemacu motor tak segerak. Dalam bahagian belakang FastAPI, ia memberikan Anda dokumen yang ditaip dan disahkan, yang berkelakuan seperti model Pydantic yang telah Anda gunakan untuk isi permintaan dan respons.

Setiap kelas dokumen dipetakan kepada satu koleksi MongoDB.
Setiap tika dipetakan kepada satu dokumen (rekod seperti JSON).
Pengesahan, pensirian dan Skema JSON tersedia secara automatik melalui Pydantic v2.

Oleh sebab semuanya tak segerak, Beanie sememangnya sesuai digandingkan dengan pengendali laluan tak segerak FastAPI dan mengelakkan gelung peristiwa daripada disekat oleh I/O pangkalan data.

Model Dokumen Pertama Anda

Model Beanie mewarisi Document, bukannya BaseModel Pydantic. Medan diisytiharkan dengan petunjuk jenis biasa, dan Beanie memberikan setiap dokumen medan id secara automatik yang disokong oleh _id MongoDB (sebuah ObjectId).

Medan wajib tidak mempunyai nilai lalai; medan pilihan menggunakan Optional[...] atau nilai lalai.
Nama koleksi diperoleh daripada nama kelas melainkan Anda mengatasinya.

Di bawah, Product menjadi koleksi dokumen produk.

from typing import Optional
from beanie import Document


class Product(Document):
    name: str
    price: float
    description: Optional[str] = None
    in_stock: bool = True


# An instance is just a validated Pydantic object until you insert it
item = Product(name="Keyboard", price=49.9)
print(item.name, item.price, item.in_stock)

Mengkonfigurasi Koleksi dengan Settings

Beanie membaca konfigurasi pilihan daripada class Settings dalaman. Pilihan yang paling biasa ialah name, yang menetapkan nama koleksi MongoDB secara eksplisit dan bukannya bergantung pada nama kelas.

name — nama koleksi.
use_state_management — menjejak medan yang berubah untuk simpanan separa.
validate_on_save — menjalankan semula pengesahan apabila menyimpan dokumen sedia ada.

Menetapkan nama koleksi secara tetap memastikan skema Anda stabil walaupun Anda menamakan semula kelas Python kemudian.

from beanie import Document


class Product(Document):
    name: str
    price: float

    class Settings:
        name = "products"
        validate_on_save = True


print(Product.Settings.name)

Memulakan Beanie Semasa Permulaan Aplikasi

Sebelum mana-mana dokumen boleh berkomunikasi dengan MongoDB, Anda mesti memanggil init_beanie sekali dengan menghantar pangkalan data motor dan senarai model dokumen. Dalam FastAPI, tindakan ini hendaklah berada dalam pengendali lifespan supaya ia berjalan semasa permulaan.

AsyncIOMotorClient mencipta sambungan tak segerak.
document_models mendaftarkan setiap model supaya Beanie boleh membina indeks dan pertanyaan.

Ini ialah pendawaian rangka kerja/pelayan — ia memerlukan MongoDB yang aktif, jadi anggap ia sebagai corak persediaan, bukan skrip kendiri.

from contextlib import asynccontextmanager
from fastapi import FastAPI
from motor.motor_asyncio import AsyncIOMotorClient
from beanie import init_beanie


@asynccontextmanager
async def lifespan(app: FastAPI):
    client = AsyncIOMotorClient("mongodb://localhost:27017")
    await init_beanie(
        database=client.shop_db,
        document_models=[Product],
    )
    yield
    client.close()


app = FastAPI(lifespan=lifespan)

Pengesahan Medan dengan Pydantic

Oleh sebab Document ialah model Pydantic, setiap alat pengesahan yang Anda ketahui masih berfungsi: kekangan Field, pengesah tersuai dan jenis kaya seperti EmailStr atau HttpUrl.

Field(gt=0) menolak harga yang tidak positif.
Field(min_length=...) menguatkuasakan panjang rentetan.
Pengesahan dijalankan apabila objek dibina, jadi data yang tidak sah tidak pernah sampai ke MongoDB.

Coretan ini ialah pengesahan gaya Pydantic sepenuhnya dan boleh dijalankan sendiri.

from pydantic import BaseModel, Field, ValidationError


class Product(BaseModel):
    name: str = Field(min_length=1, max_length=80)
    price: float = Field(gt=0)
    sku: str = Field(pattern=r"^[A-Z]{3}-\d{4}$")


try:
    Product(name="Mouse", price=-5, sku="bad")
except ValidationError as e:
    print("Rejected:", len(e.errors()), "errors")

good = Product(name="Mouse", price=19.99, sku="MOU-0001")
print("Accepted:", good.sku)

Mengisytiharkan Indeks dengan Indexed

Indeks menjadikan pertanyaan pantas dan boleh menguatkuasakan keunikan. Beanie menawarkan dua gaya. Yang paling mudah ialah pembungkus Indexed yang digunakan pada jenis medan, lalu mencipta indeks satu medan.

Indexed(str, unique=True) membina indeks unik — sesuai untuk e-mel atau SKU.
Beanie mencipta indeks secara automatik semasa init_beanie.

Gunakan indeks unik untuk meletakkan peraturan integriti pada pangkalan data, bukannya hanya bergantung pada semakan aplikasi.

import pymongo
from beanie import Document, Indexed
from pydantic import EmailStr


class User(Document):
    email: Indexed(EmailStr, unique=True)
    username: Indexed(str)
    age: int

    class Settings:
        name = "users"

Indeks Gubahan dalam Settings

Untuk indeks berbilang medan atau indeks lanjutan, isytiharkannya dalam Settings.indexes menggunakan IndexModel PyMongo. Beginilah cara Anda membina indeks gubahan, mengawal arah isihan atau menambah TTL.

Senaraikan medan bersama arahnya: pymongo.ASCENDING / DESCENDING.
Hantar unique=True atau expireAfterSeconds=... melalui IndexModel.

Susunan penting: indeks gubahan pada (category, price) mengoptimumkan pertanyaan yang menapis mengikut kategori kemudian mengisih mengikut harga.

import pymongo
from pymongo import IndexModel
from beanie import Document


class Product(Document):
    name: str
    category: str
    price: float

    class Settings:
        name = "products"
        indexes = [
            IndexModel(
                [("category", pymongo.ASCENDING), ("price", pymongo.DESCENDING)],
                name="category_price_idx",
            ),
        ]

Dokumen Terbenam dengan BaseModel

MongoDB menyimpan objek bersarang di dalam satu dokumen. Dalam Beanie, struktur terbenam hanyalah BaseModel Pydantic biasa yang digunakan sebagai jenis medan — ia bukan koleksi berasingan dan tidak mempunyai id.

Benamkan apabila data bersarang dimiliki oleh induk dan sentiasa dibaca bersama (alamat di dalam pengguna).
Seluruh struktur disahkan dan dibuat bersiri sebagai satu dokumen.

Di sini, Address dibenamkan di dalam dokumen User.

from pydantic import BaseModel
from beanie import Document


class Address(BaseModel):
    street: str
    city: str
    postal_code: str


class User(Document):
    name: str
    address: Address

    class Settings:
        name = "users"


u = User(name="Ada", address=Address(street="1 Main", city="Oslo", postal_code="0150"))
print(u.address.city)

Senarai Struktur Terbenam

Satu medan dokumen boleh mengandungi senarai model terbenam, yang sesuai untuk data satu-ke-banyak yang sepenuhnya dimiliki oleh induk — contohnya item baris pesanan atau komen.

list[OrderItem] mengesahkan setiap elemen semasa pembinaan.
Setiap item disiri terus dalam dokumen, jadi pembacaan pesanan tidak memerlukan pertanyaan tambahan.

Utamakan senarai terbenam apabila koleksi mempunyai had dan dibaca bersama induk; gunakan rujukan apabila koleksi boleh berkembang tanpa had.

from pydantic import BaseModel
from beanie import Document


class OrderItem(BaseModel):
    product_name: str
    quantity: int
    unit_price: float


class Order(Document):
    customer: str
    items: list[OrderItem]

    class Settings:
        name = "orders"

    @property
    def total(self) -> float:
        return sum(i.quantity * i.unit_price for i in self.items)


order = Order(
    customer="Lin",
    items=[OrderItem(product_name="Pen", quantity=3, unit_price=1.5)],
)
print(order.total)

Membuat Rujukan kepada Dokumen Lain dengan Link

Apabila data berkaitan berada dalam koleksinya sendiri serta dikongsi atau bersaiz besar, gunakan rujukan dan bukannya pembenaman. Link[OtherDocument] Beanie menyimpan penuding (DBRef) dan boleh mendapatkan dokumen yang dipautkan apabila diperlukan.

Link[Category] mengekalkan kategori dalam koleksinya sendiri.
Gunakan fetch_links=True pada pertanyaan, atau await doc.fetch_link(...), untuk menyelesaikannya.

Peraturan umum: benamkan data yang dimiliki dan dibaca bersama; pautkan data yang dikongsi atau ditanya secara berasingan.

from beanie import Document, Link


class Category(Document):
    name: str

    class Settings:
        name = "categories"


class Product(Document):
    name: str
    price: float
    category: Link[Category]

    class Settings:
        name = "products"

Pilihan Pemodelan: Benam atau Rujuk

Keputusan reka bentuk utama dalam pemodelan dokumen ialah sama ada untuk membenamkan data atau merujuk kepadanya. Tiada jawapan sejagat — semuanya bergantung pada corak capaian dan saiz data.

Benamkan apabila: anak dimiliki oleh induk, sentiasa dimuatkan bersama, dan saiznya terhad (alamat, item pesanan).
Rujuk apabila: data dikongsi merentas dokumen, ditanya secara berasingan, atau boleh berkembang tanpa had (kategori, pengarang, log audit).

Dokumen MongoDB mempunyai had 16 MB, jadi tatasusunan terbenam yang tidak terhad akhirnya akan menyebabkan masalah — satu lagi sebab untuk merujuk koleksi yang besar dan terus berkembang.

Semakan Pantas: Benam atau Rujuk?

Anda sedang memodelkan bahagian belakang e-dagang dengan Beanie. Satu Product tergolong dalam tepat satu Category, kategori dikongsi merentas ribuan produk, dan anda kerap menyenaraikan semua kategori pada halaman pentadbirnya sendiri.

Jawab dalam pelajaran interaktif

Rumusan: Pemodelan Dokumen dengan Beanie

Anda telah mempelajari cara memodelkan data MongoDB dengan Beanie berasaskan Pydantic:

Subkelas Document memetakan kelas Python kepada koleksi; class Settings menetapkan nama dan pilihan koleksi.
init_beanie mesti dijalankan semasa permulaan (dalam jangka hayat FastAPI) dengan pangkalan data motor anda dan document_models.
Kekangan dan pengesah Pydantic Field menghalang data yang tidak sah daripada masuk ke pangkalan data.
Gunakan pembalut Indexed untuk mengindeks medan tunggal, atau Settings.indexes + IndexModel untuk indeks gabungan dan unik.
Benamkan data yang dimiliki, terhad dan dibaca bersama sebagai BaseModel bersarang; rujuk data yang dikongsi atau berkembang dengan Link[...], sambil mengambil kira had dokumen 16 MB.

Dengan alat ini, anda boleh mereka bentuk skema MongoDB yang ditaip, disahkan dan cekap untuk pertanyaan bagi bahagian belakang FastAPI anda.

Percuma untuk bermula

Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 21
Pelajaran: 84

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pemodelan Dokumen dengan Beanie ODM” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Pemodelan Dokumen dengan Beanie ODM”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pemodelan Dokumen dengan Beanie ODM”?

Takrifkan model dokumen bertip, indeks dan struktur terbenam menggunakan Beanie berasaskan Pydantic. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Pemodelan Dokumen dengan Beanie ODM” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Akses MongoDB Tak Segerak dengan Motor
Pemodelan Dokumen dengan Beanie ODM
Saluran Paip Agregat dan Pertanyaan Kompleks
Evolusi Skema dan Migrasi Dokumen

← Kembali ke Kem Intensif Pembangunan Bahagian Belakang FastAPI