Membina Aplikasi Python Boleh Diselenggara dengan Seni Bina Heksagon dan Reka Bentuk Didorong Domain

Dalam landskap pembangunan perisian yang pantas hari ini, membina aplikasi yang mudah diselenggara, disesuaikan dan berskala adalah penting. Seni Bina Heksagon (juga dikenali sebagai Pelabuhan dan Penyesuai) dan Reka Bentuk Dipacu Domain (DDD) ialah kombo yang berkesan untuk menangani cabaran ini. Seni Bina Heksagon menggalakkan pemisahan kebimbangan yang bersih, menjadikannya lebih mudah untuk menggantikan, menguji atau meningkatkan bahagian sistem tanpa mengganggu logik teras. Sementara itu, DDD memfokuskan pada menjajarkan kod anda dengan konsep perniagaan dunia sebenar, memastikan sistem anda intuitif dan berdaya tahan. Bersama-sama, pendekatan ini membolehkan pembangun membina sistem yang teguh, berdaya tahan dan direka bentuk untuk menyesuaikan dengan lancar kepada keperluan yang berubah-ubah dan pertumbuhan masa hadapan.

1. Pengenalan kepada Seni Bina Heksagon

Seni Bina Heksagon, juga dikenali sebagai corak Pelabuhan dan Penyesuai, telah diperkenalkan oleh Alistair Cockburn untuk menangani ketegaran dan kerumitan seni bina berlapis tradisional. Matlamat utamanya ialah untuk menjadikan logik teras (domain) aplikasi bebas daripada sistem luaran, membolehkan ujian, penyelenggaraan dan kebolehsuaian yang lebih mudah.

Pada terasnya, Seni Bina Heksagon membahagikan aplikasi kepada tiga lapisan utama:

• Teras (Logik/Domain Perniagaan): Nadi sistem di mana peraturan perniagaan dan logik domain berada. Lapisan ini bebas dan tidak bergantung pada perpustakaan atau rangka kerja luaran.
  Contoh: Mengira faedah ke atas pinjaman atau mengesahkan tindakan pengguna terhadap peraturan perniagaan.

• Port (Antara Muka): Takrifan abstrak (cth., antara muka atau protokol) untuk cara teras berinteraksi dengan dunia luar. Port mewakili kes penggunaan atau API khusus aplikasi. Mereka mentakrifkan apa yang perlu dilakukan tanpa menyatakan bagaimana.
  Contoh: Port Repositori mentakrifkan kaedah untuk berinteraksi dengan sumber data seperti:

  • get(id: ID): Entiti: Dapatkan semula entiti dengan pengecam uniknya.
  • sisipkan(entiti: Entiti): batal: Tambah entiti baharu.
  • kemas kini(entiti: Entiti): batal: Kemas kini entiti sedia ada.

src/ports/repository.py
from abc import ABC, abstractmethod
from typing import List
from src.entities import Entity

class Repository(ABC):
    @abstractmethod
    def get(self, id: str) -> Entity:
        pass

    @abstractmethod
    def insert(self, entity: Entity) -> None:
        pass

    @abstractmethod
    def update(self, entity: Entity) -> None:
        pass

• Penyesuai (Pelaksanaan): Pelaksanaan konkrit port. Mereka mengendalikan interaksi sebenar dengan sistem luaran seperti pangkalan data, API atau UI. Contoh: Penyesuai PostgresRepository melaksanakan Port Repositori untuk PostgreSQL menggunakan SQLAlchemy.

# src/adapters/postgres_repository.py
from sqlalchemy import create_engine, Column, String
from sqlalchemy.orm import declarative_base, sessionmaker
from src.entities import Entity
from src.ports.repository import Repository

Base = declarative_base()

# Define the database table for Entity
class EntityModel(Base):
    __tablename__ = "entities"
    id = Column(String, primary_key=True)
    name = Column(String, nullable=False)
    description = Column(String)

class PostgresRepository(Repository):
    def __init__(self, db_url: str):
        """
        Initialize the repository with the PostgreSQL connection URL.
        Example db_url: "postgresql+psycopg2://username:password@host:port/dbname"
        """
        self.engine = create_engine(db_url)
        Base.metadata.create_all(self.engine)
        self.Session = sessionmaker(bind=self.engine)

    def get(self, id: str) -> Entity:
        session = self.Session()
        try:
            entity_model = session.query(EntityModel).filter_by(id=id).first()
            if not entity_model:
                raise ValueError(f"Entity with id {id} not found")
            return Entity(id=entity_model.id, name=entity_model.name, description=entity_model.description)
        finally:
            session.close()

    def insert(self, entity: Entity) -> None:
        session = self.Session()
        try:
            entity_model = EntityModel(id=entity.id, name=entity.name, description=entity.description)
            session.add(entity_model)
            session.commit()
        finally:
            session.close()

    def update(self, entity: Entity) -> None:
        session = self.Session()
        try:
            entity_model = session.query(EntityModel).filter_by(id=entity.id).first()
            if not entity_model:
                raise ValueError(f"Entity with id {entity.id} not found")
            entity_model.name = entity.name
            entity_model.description = entity.description
            session.commit()
        finally:
            session.close()

Seni bina sering digambarkan sebagai heksagon, melambangkan pelbagai cara untuk berinteraksi dengan teras, dengan setiap sisi mewakili penyesuai atau port yang berbeza.

2. Pengenalan kepada Reka Bentuk Dipacu Domain (DDD)

Reka Bentuk Dipacu Domain (DDD) ialah pendekatan reka bentuk perisian yang menekankan penjajaran rapat antara matlamat perniagaan dan perisian yang dibina untuk mencapainya. Metodologi ini diperkenalkan oleh Eric Evans dalam bukunya Reka Bentuk Dipacu Domain: Menangani Kerumitan dalam Hati Perisian.

Pada terasnya, DDD memfokuskan pada pemahaman dan pemodelan domain (ruang masalah perniagaan) dengan bantuan pakar domain dan menterjemah pemahaman itu ke dalam sistem perisian. DDD menggalakkan penyahgandingan domain, memastikan bahagian sistem yang berlainan kekal bebas, jelas dan mudah diurus.
Konsep Utama Reka Bentuk Dipacu Domain:

• Domain: Bidang pengetahuan atau aktiviti khusus yang ditangani oleh perisian. Contohnya, dalam aplikasi perbankan, domain termasuk konsep seperti akaun, urus niaga dan pelanggan.

• Bahasa Ubiquitous: Bahasa biasa yang dibangunkan secara kolaboratif oleh pembangun dan pakar domain. Perbendaharaan kata yang dikongsi ini memastikan komunikasi yang jelas dan pemahaman yang konsisten merentas semua pihak berkepentingan.

• Entiti dan Objek Nilai:

  • Entiti: Objek yang mempunyai identiti dan kitaran hayat yang berbeza, seperti pelanggan atau pesanan.
  • Objek Nilai: Objek tidak berubah yang ditakrifkan oleh atributnya dan bukannya identiti unik, seperti tarikh atau jumlah wang.

• Agregat: Kelompok entiti berkaitan dan objek nilai dianggap sebagai satu unit untuk perubahan data. Setiap agregat mempunyai entiti akar yang memastikan integriti keseluruhan kluster.

• Repositori: Mekanisme untuk mendapatkan dan menyimpan agregat, menyediakan lapisan abstraksi ke atas akses data.

• Perkhidmatan: Operasi atau proses yang secara semula jadi tidak sesuai dalam entiti atau objek nilai tetapi penting untuk domain, seperti memproses pembayaran.
  

src/ports/repository.py
from abc import ABC, abstractmethod
from typing import List
from src.entities import Entity

class Repository(ABC):
    @abstractmethod
    def get(self, id: str) -> Entity:
        pass

    @abstractmethod
    def insert(self, entity: Entity) -> None:
        pass

    @abstractmethod
    def update(self, entity: Entity) -> None:
        pass

Dalam bahagian ini, saya tidak memberikan contoh terperinci untuk melaksanakan Reka Bentuk Dipacu Domain (DDD) kerana ia merupakan metodologi komprehensif yang tertumpu terutamanya pada menangani cabaran logik perniagaan yang kompleks. DDD cemerlang dalam menstruktur dan mengurus peraturan perniagaan yang rumit, tetapi untuk merealisasikan sepenuhnya potensinya dan menangani kebimbangan pengekodan yang lain, ia sebaiknya digunakan dalam rangka kerja seni bina yang saling melengkapi. Jadi, dalam bahagian berikut, Reka Bentuk Dipacu Domain akan digabungkan dengan Seni Bina Heksagon untuk menyerlahkan kekuatannya dan menyediakan asas yang kukuh untuk menyelesaikan masalah pengekodan tambahan di luar logik perniagaan, disertai dengan contoh terperinci.

3. Bagaimana Seni Bina Heksagon dan Reka Bentuk Dipacu Domain Melengkapkan Satu Sama Lain

Mengapa Seni Bina Heksagon dan Reka Bentuk Dipacu Domain?

Reka Bentuk Dipacu Domain (DDD) dan Seni Bina Heksagon saling melengkapi dengan menekankan sempadan yang jelas dan menyelaraskan perisian dengan keperluan perniagaan. DDD memfokuskan pada pemodelan domain teras dan mengasingkan logik perniagaan, manakala Seni Bina Heksagon memastikan logik ini kekal bebas daripada sistem luaran melalui port dan penyesuai. Mereka menangani kebimbangan yang berbeza tetapi saling melengkapi:

• Seni Bina Heksagon sebagai Rangka Kerja:

  • Seni Bina Heksagon mentakrifkan cara keseluruhan sistem disusun dan cara bahagian yang berbeza (mis., domain, infrastruktur, antara muka pengguna) berinteraksi.
  • Ia menyediakan persekitaran di mana logik domain boleh berfungsi secara bebas daripada kebimbangan luaran, menawarkan kebebasan daripada butiran infrastruktur.

• Reka Bentuk Didorong Domain sebagai Logik Teras:

  • DDD memperkayakan domain teras yang ditakrifkan oleh Seni Bina Heksagon dengan memastikan bahawa logik perniagaan bukan sahaja dirangkumkan tetapi juga mencerminkan keperluan perniagaan dunia sebenar.
  • Ia memfokuskan pada cara mereka bentuk dan melaksanakan lapisan domain dengan berkesan, memastikan ia kekal bermakna dan boleh disesuaikan.

Bersama-sama, mereka mendayakan sistem berskala, boleh diuji dan fleksibel di mana domain kekal sebagai tumpuan utama, terlindung daripada perubahan dalam infrastruktur atau teknologi. Sinergi ini memastikan reka bentuk teguh yang mudah menyesuaikan diri dengan keperluan perniagaan yang berkembang.
Bahagian berikut menawarkan contoh praktikal tentang cara Reka Bentuk Dipacu Domain (DDD) dan Seni Bina Heksagon bekerjasama untuk mencipta sistem perisian yang teguh, boleh diselenggara dan boleh disesuaikan.

Contoh praktikal

Projek ini menggunakan Seni Bina Heksagon dan Reka Bentuk Dipacu Domain (DDD) untuk mencipta sistem berskala dan boleh diselenggara, menyediakan asas moden dan teguh untuk pembangunan aplikasi. Dibina dengan Python, ia menggunakan FastAPI sebagai rangka kerja web dan DynamoDB sebagai pangkalan data.

Projek ini dianjurkan seperti berikut:

src/ports/repository.py
from abc import ABC, abstractmethod
from typing import List
from src.entities import Entity

class Repository(ABC):
    @abstractmethod
    def get(self, id: str) -> Entity:
        pass

    @abstractmethod
    def insert(self, entity: Entity) -> None:
        pass

    @abstractmethod
    def update(self, entity: Entity) -> None:
        pass

Anda boleh mencari kod sumber dalam repositori GitHub saya.

4. Kesimpulan

Menggabungkan Seni Bina Heksagon dan Reka Bentuk Dipacu Domain (DDD) ke dalam aplikasi Python memupuk pembangunan sistem yang boleh diselenggara, boleh disesuaikan dan diselaraskan rapat dengan objektif perniagaan. Seni Bina Heksagon memastikan pemisahan yang jelas antara logik perniagaan teras dan sistem luaran, menggalakkan fleksibiliti dan kemudahan ujian. DDD menekankan pemodelan domain dengan tepat, menghasilkan perisian yang benar-benar mencerminkan proses dan peraturan perniagaan. Dengan menyepadukan metodologi ini, pembangun boleh mencipta aplikasi mantap yang bukan sahaja memenuhi keperluan semasa tetapi juga bersedia untuk berkembang dengan keperluan perniagaan masa hadapan.

Hubungi saya jika anda menyukai artikel ini!

Atas ialah kandungan terperinci Membina Aplikasi Python Boleh Diselenggara dengan Seni Bina Heksagon dan Reka Bentuk Didorong Domain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!