IlmHamroh
Python kursi/Arxitektura7/12-dars19 daqiqa
Mundarija (22)

27.7-dars: Clean Architecture

27-QISM — ARXITEKTURA · 7-dars

1. Kirish va motivatsiya

Qatlamli arxitekturada 27.6-bob bir muammo bor: biznes mantiq odatda ma'lumot qatlamiga (bazaga) bog'liq bo'ladi — baza o'zgarsa, biznes mantiq ham ta'sirlanadi. Lekin biznes qoidalari — tizimning eng qimmatli va barqaror qismi; ular texnik tafsilotlarga (baza, veb-freymvork, tashqi xizmat) bog'liq bo'lmasligi kerak. Clean Architecture — qatlamlarni "ichkariga burab", domenni (biznes mantiq) markazga qo'yadi: bog'liqlik doim ichkariga yo'naladi (tashqi tafsilotlar domenga bog'liq, teskarisi emas). Yadro (biznes qoidalari) hech narsaga bog'liq emas — eng barqaror, mustaqil, sinaladigan.

Clean Architecture (Robert Martin) — bog'liqlikni ichkariga yo'naltiruvchi arxitektura: markazda entities (korxona qoidalari — asosiy modellar), atrofida use cases (ilova qoidalari — amaliyotlar), tashqarida interface adapters (kontrollerlar, taqdimot), eng tashqarida frameworks & drivers (baza, veb, UI). Bog'liqlik qoidasi (Dependency Rule): kod bog'liqligi faqat ichkariga yo'naladi — ichki halqa tashqisini bilmaydi. Domen (yadro) baza, veb, freymvorkni bilmaydi — ular domenni bilishadi (DIP — 27.2). Bu qatlamli arxitekturani 27.6-bob takomillashtiradi: bog'liqlik yo'nalishini domen foydasiga o'zgartiradi. Clean Architecture — domenni markazga qo'yish.

Real vaziyat. Bir loyihada biznes mantiq to'g'ridan-to'g'ri ORM modellariga (baza) bog'liq edi — bazani PostgreSQL dan MongoDB ga o'zgartirish biznes mantiqni ham qayta yozishni talab qildi. Clean Architecture qo'llanildi: domen sof Python obyektlar (bazasiz), repository interfeys domenda, amalga oshirish tashqarida. Baza o'zgarganda — faqat adapter (repository amalga oshirishi). Domen tegilmadi. Biznes mantiq texnologiyadan ozod bo'ldi. Clean Architecture — yadroni himoya qildi.

Bu darsda Clean Architecture ni o'rganamiz.

Bu darsda:

  • Clean Architecture nima
  • Bog'liqlik qoidasi (ichkariga)
  • Halqalar: entities, use cases, adapters
  • Domen — texnologiyadan mustaqil
  • Bog'liqlikni teskari qilish (DIP)
  • Clean Architecture foydasi va narxi
  • Clean Architecture va qatlamlar
  • Amaliy: domen markazda

ℹ Misollar sof Python bilan — domen bazasiz (deterministik).

2. Nazariya — chuqur tushuntirish

2.1. Clean Architecture nima

Domen markazda, bog'liqlik ichkariga:

┌─────────────────────────────────┐
│ Frameworks (baza, veb, UI)      │  ← tashqi
│  ┌───────────────────────────┐  │
│  │ Interface Adapters        │  │
│  │  ┌─────────────────────┐  │  │
│  │  │ Use Cases (amallar) │  │  │
│  │  │  ┌───────────────┐  │  │  │
│  │  │  │ Entities      │  │  │  │  ← markaz (yadro)
│  │  │  └───────────────┘  │  │  │
│  │  └─────────────────────┘  │  │
│  └───────────────────────────┘  │
└─────────────────────────────────┘
   bog'liqlik: doim ichkariga →

Clean Architecture — tizimni konsentrik halqalar ga bo'lib, domenni (biznes qoidalari) markazga qo'yadi: markazda entities (asosiy modellar), atrofida use cases (amaliyotlar), tashqarida adapters (kontroller), eng tashqarida frameworks (baza, veb). Asosiy g'oya: bog'liqlik ichkariga — ichki halqa tashqisini bilmaydi (domen bazani bilmaydi). Sabab: biznes qoidalari — eng qimmatli va barqaror; ularni texnik tafsilotlardan (baza, freymvork) ajratish (ular o'zgaradi, qoidalar qoladi). Clean Architecture — yadroni himoya qilish.

2.2. Bog'liqlik qoidasi (ichkariga)

Manba kodi bog'liqligi faqat ichkariga:

Tashqi halqa → ichki halqani biladi (bog'liq)
Ichki halqa → tashqini BILMAYDI
   Domen (ichki) baza (tashqi) ni bilmaydi
   Baza domenni biladi (unga moslashadi)

Bog'liqlik qoidasi (Dependency Rule) — Clean Architecture ning asosiy qonuni: manba kodi bog'liqligi faqat ichkariga yo'naladi (tashqi halqadan ichkiga) — ichki halqa tashqi haqida hech narsa bilmaydi. Domen (markaz) baza, veb, UI nomlarini ham bilmaydi; tashqi qatlamlar domenga moslashadi. Sabab: agar domen bazaga bog'liq bo'lsa — baza o'zgarishi domenni buzadi; teskarisi (baza domenga bog'liq) — baza o'zgaradi, domen barqaror. Bu DIP 27.2-bob ning arxitektura darajasi. Bog'liqlik qoidasi — yadro mustaqilligi.

2.3. Halqalar: entities, use cases, adapters

Ichkaridan tashqariga:

Halqa Mas'uliyat
Entities Korxona qoidalari (asosiy model)
Use Cases Ilova qoidalari (amaliyot)
Adapters Kontroller, taqdimot, repository
Frameworks Baza, veb, UI, tashqi

Halqalar (ichkaridan): Entities (mohiyatlar) — eng asosiy biznes qoidalari va modellar (korxona darajasi — masalan "buyurtma summasi manfiy bo'lmaydi"); Use Cases (foydalanish holatlari) — aniq amaliyotlar (ilova darajasi — "buyurtma yaratish", entities ni orkestrlaydi); Interface Adapters — tashqi va ichki orasidagi tarjimon (kontroller, taqdimot, repository amalga oshirishi); Frameworks & Drivers — texnik tafsilotlar (baza, veb-freymvork, UI). Har halqa ichkarisiga bog'liq (tashqarisiga emas). Halqalar — mavhumlik darajalari (markaz — eng mavhum, tashqi — eng aniq).

2.4. Domen — texnologiyadan mustaqil

python
# domen: sof Python (baza, veb, freymvork YO'Q)
class Buyurtma:
    def __init__(self, summa: float):
        if summa < 0:
            raise ValueError("summa manfiy bo'lmaydi")
        self.summa = summa
    def chegirma(self, foiz): return self.summa * (1 - foiz/100)
# import sqlalchemy YO'Q, import fastapi YO'Q

Domen mustaqilligi — domen (entities, use cases) sof til (Python) da yoziladi, hech qanday tashqi texnologiyaga import qilmaydi: baza (sqlalchemy), veb (fastapi), tashqi kutubxona yo'q — faqat biznes qoidalari. Sabab: domen texnologiyadan ozod bo'lsa — texnologiya almashsa (PostgreSQL → MongoDB, FastAPI → Flask) domen tegilmaydi; domen mustaqil sinaladi (baza/server kerak emas); domen — eng barqaror. Belgi: domen faylida import faqat standart kutubxona (yoki boshqa domen). Domen mustaqilligi — texnologiyadan ozodlik.

2.5. Bog'liqlikni teskari qilish (DIP)

Interfeys domenda, amalga oshirish tashqarida:

python
# domen interfeysni belgilaydi (ichkarida)
class BuyurtmaOmbori(Protocol):
    def saqla(self, b: Buyurtma) -> None: ...

# tashqi qatlam interfeysni amalga oshiradi
class PostgresOmbori:               # framework halqasi
    def saqla(self, b): ...          # domenga moslashadi

Bog'liqlikni teskari qilish — domen bazaga bog'lanmasligi uchun: domen interfeys (repository shartnomasi) ni belgilaydi (ichkarida), tashqi qatlam bu interfeysni amalga oshiradi (tashqarida). Natija: bog'liqlik teskari — baza domenga bog'liq (interfeysga moslashadi), domen bazani bilmaydi. Bu DIP 27.2-bob ning yuragi: ikkalasi abstraksiyaga (interfeysga) bog'lanadi, abstraksiya domenga tegishli. Use case interfeysni ishlatadi (aniq bazani emas). Bog'liqlikni teskari qilish — Clean Architecture mexanizmi. Interfeys ichkarida — bog'liqlik ichkariga.

2.6. Clean Architecture foydasi va narxi

Foydalar: texnologiya mustaqilligi (baza/freymvork almashadi, domen qoladi); sinaladiganlik (domen bazasiz/serversiz sinaladi — tez, ishonchli); barqarorlik (yadro o'zgarmaydi — talab o'zgarsa, tashqi qatlam); ravshanlik (biznes qoidalari bir joyda, aniq). Narx: ko'proq kod (interfeys, adapter, DTO — ko'p sinf/fayl); ko'proq mavhumlik (o'rganish qiyinroq); ortiqcha (kichik loyihaga — KISS buzildi). Clean Architecture — katta, uzoq muddatli, murakkab biznes uchun (oddiy CRUD ga ortiqcha). Muvozanat: yadro qimmat bo'lsa qo'llash. Narx: mavhumlik va kod (kichik loyihaga ortiqcha).

2.7. Clean Architecture va qatlamlar

Clean Architecture — qatlamli arxitekturaning (27.6) takomillashtirilgan shakli: qatlamli — bog'liqlik yuqoridan pastga (taqdimot → mantiq → baza, mantiq bazaga bog'liq); Clean — bog'liqlik ichkariga (baza → mantiq, baza domenga bog'liq). Farq: qatlamlida domen (mantiq) pastdagi bazaga bog'liq; Clean da domen markazda, hech narsaga bog'liq emas. Boshqa nomlar: Hexagonal (portlar-adapterlar), Onion (piyoz) — bir g'oya (domen markazda, bog'liqlik ichkariga). Ular DIP 27.2-bob, strukturaviy naqshlar (Adapter — 27.4) ustiga quriladi. Clean Architecture — qatlamli + bog'liqlik teskari (domen foydasiga).

2.8. Clean Architecture — yadroni himoya qilish

Clean Architecture asosiy g'oyasi — eng qimmatlini himoya qilish: biznes qoidalari (domen) tizimning sababi va qiymati; texnologiya (baza, veb, freymvork) — o'zgaruvchi vosita (ular kelib-ketadi, qoidalar qoladi). Yadroni tashqi tafsilotlarga bog'lamaslik uni barqaror va uzoq umrli qiladi. Bu "detallarni kechiktirish" falsafasi: avval biznes qoidalarini yoz (domen), texnologiya qarorini (qaysi baza) keyinga qoldir (adapter almashadi). Bu SOLID (27.2 — DIP), qatlamlar 27.6-bob, DDD (27.8 — domen urg'usi) bilan uyg'un. Katta, uzoq yashaydigan tizim uchun kuchli. Clean Architecture — qiymatni (domen) texnologiyadan ustun qo'yish. Yadro barqaror — tizim uzoq yashaydi.

3. Tez ma'lumotnoma

python
# HALQALAR (ichkaridan tashqariga):
# 1. Entities — asosiy model + qoida (sof Python)
# 2. Use Cases — amaliyot (entities ni ishlatadi)
# 3. Adapters — kontroller, repository amalga oshirishi
# 4. Frameworks — baza, veb, UI

# DOMEN (ichki) — texnologiyasiz:
class Buyurtma:                    # entity
    def __init__(self, summa):
        if summa < 0: raise ValueError()
        self.summa = summa

class BuyurtmaOmbori(Protocol):    # interfeys (domenda)
    def saqla(self, b): ...

class YaratishUseCase:             # use case
    def __init__(self, ombor: BuyurtmaOmbori):
        self.ombor = ombor         # interfeysga bog'liq
    def bajar(self, summa):
        b = Buyurtma(summa)
        self.ombor.saqla(b)
        return b

# TASHQI (framework) — interfeysni amalga oshiradi:
class PostgresOmbori:              # domenga moslashadi
    def saqla(self, b): ...

# BOG'LIQLIK QOIDASI: faqat ichkariga (domen tashqini bilmaydi)

Clean Architecture xulosasi

Domen markazda (entities + use cases) — sof Python
Bog'liqlik doim ICHKARIGA (domen tashqini bilmaydi)
Interfeys domenda, amalga oshirish tashqarida (DIP)
Foyda: texnologiya mustaqil, sinaladigan, barqaror
Narx: ko'p kod/mavhumlik (katta loyihaga — KISS)

4. Batafsil misollar

Misollar sof Python bilan — domen bazasiz (deterministik).

Misol 1 — Domen: texnologiyasiz entity

python
"""Entity: sof biznes qoidalari (baza, veb import YO'Q)."""


class Buyurtma:
    """Domen entity — faqat biznes qoidalari."""

    def __init__(self, mahsulot: str, summa: float) -> None:
        # biznes qoidasi: summa manfiy bo'lmaydi
        if summa < 0:
            raise ValueError("Summa manfiy bo'lmaydi")
        self.mahsulot = mahsulot
        self.summa = summa

    def chegirma_qollab(self, foiz: float) -> float:
        # biznes qoidasi: chegirma 0-50%
        if not 0 <= foiz <= 50:
            raise ValueError("Chegirma 0-50% oralig'ida")
        return round(self.summa * (1 - foiz / 100), 2)


def main() -> None:
    print("=== 1. Buyurtma yaratish (qoida bilan) ===")
    b = Buyurtma("Python kursi", 1000)
    print(f"  {b.mahsulot}: {b.summa}")

    print("\n=== 2. Manfiy summa — qoida ishlaydi ===")
    try:
        Buyurtma("Xato", -100)
    except ValueError as e:
        print(f"  {e}")

    print("\n=== 3. Chegirma (biznes qoidasi) ===")
    print(f"  20% chegirma: {b.chegirma_qollab(20)}")

    print("\n=== 4. Chegirma cheklovi ===")
    try:
        b.chegirma_qollab(80)
    except ValueError as e:
        print(f"  {e}")
    print("  domen sof Python (baza/veb import yo'q)")
    print("  ⭐ Entity — texnologiyasiz biznes qoidalari")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Buyurtma yaratish (qoida bilan) ===
  Python kursi: 1000

=== 2. Manfiy summa — qoida ishlaydi ===
  Summa manfiy bo'lmaydi

=== 3. Chegirma (biznes qoidasi) ===
  20% chegirma: 800.0

=== 4. Chegirma cheklovi ===
  Chegirma 0-50% oralig'ida
  domen sof Python (baza/veb import yo'q)
  ⭐ Entity — texnologiyasiz biznes qoidalari

Nima ko'rsatdi: 2.1, 2.4-bo'limlar.

Misol 2 — Use case va interfeys (bog'liqlik ichkariga)

python
"""Use case: interfeysga bog'lanadi (aniq bazaga emas) — bog'liqlik ichkariga."""
from abc import ABC, abstractmethod


# --- DOMEN (ichki halqa) ---
class Buyurtma:
    def __init__(self, mahsulot: str, summa: float) -> None:
        if summa < 0:
            raise ValueError("summa manfiy")
        self.mahsulot = mahsulot
        self.summa = summa


class BuyurtmaOmbori(ABC):
    """Interfeys — DOMENDA belgilanadi (bog'liqlik ichkariga)."""

    @abstractmethod
    def saqla(self, b: Buyurtma) -> int: ...


class BuyurtmaYaratish:
    """Use case — interfeysga bog'liq (aniq bazaga emas)."""

    def __init__(self, ombor: BuyurtmaOmbori) -> None:
        self.ombor = ombor

    def bajar(self, mahsulot: str, summa: float) -> dict:
        buyurtma = Buyurtma(mahsulot, summa)   # domen qoidasi
        buyurtma_id = self.ombor.saqla(buyurtma)
        return {"id": buyurtma_id, "mahsulot": mahsulot}


# --- TASHQI (framework halqasi) ---
class XotiraOmbori(BuyurtmaOmbori):
    """Interfeysni amalga oshiradi (domenga moslashadi)."""

    def __init__(self) -> None:
        self._saqlangan: list = []

    def saqla(self, b: Buyurtma) -> int:
        self._saqlangan.append(b)
        return len(self._saqlangan)


def main() -> None:
    ombor = XotiraOmbori()
    use_case = BuyurtmaYaratish(ombor)

    print("=== 1. Use case orqali buyurtma ===")
    print(f"  {use_case.bajar('Python kursi', 1000)}")
    print(f"  {use_case.bajar('Go kursi', 1200)}")

    print("\n=== 2. Saqlangan (ombor) ===")
    print(f"  jami: {len(ombor._saqlangan)}")

    print("\n=== 3. Use case ombor turini bilmaydi ===")
    print("  BuyurtmaOmbori interfeysiga bog'liq")
    print("  XotiraOmbori — amalga oshirish (tashqi)")

    print("\n=== 4. Bog'liqlik yo'nalishi ===")
    print("  interfeys domenda, amalga oshirish tashqarida")
    print("  baza almashsa — use case tegilmaydi")
    print("  ⭐ Bog'liqlik ichkariga (domen mustaqil)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Use case orqali buyurtma ===
  {'id': 1, 'mahsulot': 'Python kursi'}
  {'id': 2, 'mahsulot': 'Go kursi'}

=== 2. Saqlangan (ombor) ===
  jami: 2

=== 3. Use case ombor turini bilmaydi ===
  BuyurtmaOmbori interfeysiga bog'liq
  XotiraOmbori — amalga oshirish (tashqi)

=== 4. Bog'liqlik yo'nalishi ===
  interfeys domenda, amalga oshirish tashqarida
  baza almashsa — use case tegilmaydi
  ⭐ Bog'liqlik ichkariga (domen mustaqil)

Nima ko'rsatdi: 2.2, 2.5-bo'limlar.

Misol 3 — Texnologiya almashtirish (domen tegilmaydi)

python
"""Texnologiya mustaqilligi: baza almashadi, domen/use case tegilmaydi."""
from abc import ABC, abstractmethod


class Mahsulot:
    def __init__(self, nom: str, narx: float) -> None:
        self.nom = nom
        self.narx = narx


class MahsulotOmbori(ABC):
    @abstractmethod
    def barchasi(self) -> list: ...


class NarxXizmati:
    """Use case — interfeysga bog'liq."""

    def __init__(self, ombor: MahsulotOmbori) -> None:
        self.ombor = ombor

    def ortacha_narx(self) -> float:
        mahsulotlar = self.ombor.barchasi()
        if not mahsulotlar:
            return 0.0
        return round(sum(m.narx for m in mahsulotlar) / len(mahsulotlar), 2)


# ikki xil "baza" — bir xil interfeys
class SqlOmbori(MahsulotOmbori):
    def barchasi(self) -> list:
        return [Mahsulot("A", 100), Mahsulot("B", 200)]


class NosqlOmbori(MahsulotOmbori):
    def barchasi(self) -> list:
        return [Mahsulot("X", 300), Mahsulot("Y", 500)]


def main() -> None:
    print("=== 1. SQL ombor bilan ===")
    xizmat_sql = NarxXizmati(SqlOmbori())
    print(f"  o'rtacha narx: {xizmat_sql.ortacha_narx()}")

    print("\n=== 2. NoSQL ombor bilan (almashtirildi) ===")
    xizmat_nosql = NarxXizmati(NosqlOmbori())
    print(f"  o'rtacha narx: {xizmat_nosql.ortacha_narx()}")

    print("\n=== 3. Bir xil use case ===")
    print("  NarxXizmati kodi o'zgarmadi (ikkalasida)")

    print("\n=== 4. Texnologiya mustaqilligi ===")
    print("  baza SQL→NoSQL — domen/use case tegilmadi")
    print("  faqat ombor amalga oshirishi almashdi")
    print("  ⭐ Domen texnologiyadan mustaqil")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. SQL ombor bilan ===
  o'rtacha narx: 150.0

=== 2. NoSQL ombor bilan (almashtirildi) ===
  o'rtacha narx: 400.0

=== 3. Bir xil use case ===
  NarxXizmati kodi o'zgarmadi (ikkalasida)

=== 4. Texnologiya mustaqilligi ===
  baza SQL→NoSQL — domen/use case tegilmadi
  faqat ombor amalga oshirishi almashdi
  ⭐ Domen texnologiyadan mustaqil

Nima ko'rsatdi: 2.4, 2.6-bo'limlar.

Misol 4 — To'liq oqim (halqalar birga)

python
"""To'liq Clean oqim: framework → adapter → use case → entity (va qaytish)."""
from abc import ABC, abstractmethod


# --- ENTITY (markaz) ---
class Hisob:
    def __init__(self, balans: float = 0) -> None:
        self.balans = balans

    def yechish(self, miqdor: float) -> None:
        # biznes qoidasi: balansdan ko'p yechib bo'lmaydi
        if miqdor > self.balans:
            raise ValueError("Mablag' yetarli emas")
        self.balans -= miqdor


# --- USE CASE ---
class HisobOmbori(ABC):
    @abstractmethod
    def ol(self, hisob_id: int) -> Hisob: ...
    @abstractmethod
    def saqla(self, hisob_id: int, h: Hisob) -> None: ...


class PulYechish:
    def __init__(self, ombor: HisobOmbori) -> None:
        self.ombor = ombor

    def bajar(self, hisob_id: int, miqdor: float) -> float:
        hisob = self.ombor.ol(hisob_id)
        hisob.yechish(miqdor)              # entity qoidasi
        self.ombor.saqla(hisob_id, hisob)
        return hisob.balans


# --- ADAPTER (repository) ---
class XotiraHisobOmbori(HisobOmbori):
    def __init__(self) -> None:
        self._db = {1: Hisob(1000)}

    def ol(self, hisob_id: int) -> Hisob:
        return self._db[hisob_id]

    def saqla(self, hisob_id: int, h: Hisob) -> None:
        self._db[hisob_id] = h


# --- FRAMEWORK (taqdimot/kontroller) ---
class HisobKontroller:
    def __init__(self, use_case: PulYechish) -> None:
        self.use_case = use_case

    def yechish(self, hisob_id: int, miqdor: float) -> dict:
        try:
            balans = self.use_case.bajar(hisob_id, miqdor)
            return {"holat": "ok", "balans": balans}
        except ValueError as e:
            return {"holat": "xato", "sabab": str(e)}


def main() -> None:
    # halqalarni ulash (tashqidan ichkariga)
    ombor = XotiraHisobOmbori()
    use_case = PulYechish(ombor)
    kontroller = HisobKontroller(use_case)

    print("=== 1. Pul yechish (to'liq oqim) ===")
    print(f"  300 yechish: {kontroller.yechish(1, 300)}")

    print("\n=== 2. Yana yechish ===")
    print(f"  200 yechish: {kontroller.yechish(1, 200)}")

    print("\n=== 3. Mablag' yetmasa (entity qoidasi) ===")
    print(f"  1000 yechish: {kontroller.yechish(1, 1000)}")

    print("\n=== 4. Oqim: kontroller→use case→entity ===")
    print("  qoida entityda, orkestr use caseda")
    print("  har halqa ichkarisiga bog'liq")
    print("  ⭐ Clean — halqalar birga (domen markazda)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Pul yechish (to'liq oqim) ===
  300 yechish: {'holat': 'ok', 'balans': 700}

=== 2. Yana yechish ===
  200 yechish: {'holat': 'ok', 'balans': 500}

=== 3. Mablag' yetmasa (entity qoidasi) ===
  1000 yechish: {'holat': 'xato', 'sabab': "Mablag' yetarli emas"}

=== 4. Oqim: kontroller→use case→entity ===
  qoida entityda, orkestr use caseda
  har halqa ichkarisiga bog'liq
  ⭐ Clean — halqalar birga (domen markazda)

Nima ko'rsatdi: 2.1–2.5-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"Domen bazaga bog'liq" Bog'liqlik ichkariga (teskari)
"Interfeys tashqarida" Interfeys domenda
"Domen ORM modeli" Sof Python (texnologiyasiz)
"Clean har loyihaga" Katta, uzoq muddatli
"Bir xil qatlamli" Bog'liqlik teskari (domen markaz)
"Ko'p kod — yomon" Yadro himoyasi narxi
"Freymvork markazda" Domen markazda
"Texnologiya avval" Detalni kechiktir

6. Keng tarqalgan xatolar va yechimlari

1. Domen bazaga bog'liq (import)

python
# domen faylida: import sqlalchemy          # ⚠️
# domen sof Python (interfeys orqali)        # ✅

2. Interfeys tashqi qatlamda

python
# repository interfeysi baza modulida        # ⚠️
# interfeys domenda (bog'liqlik ichkariga)    # ✅

3. Use case aniq bazaga

python
def __init__(self): self.db = Postgres()    # ⚠️
def __init__(self, repo: Repository)         # ✅

4. Domen ORM modeli bilan aralash

python
class Buyurtma(Base):  # SQLAlchemy           # ⚠️
class Buyurtma:  # sof + alohida ORM model    # ✅

5. Kichik loyihaga Clean (ortiqcha)

python
# oddiy CRUD ga 4 halqa, ko'p interfeys      # ⚠️
# hajmga qarab (oddiy — qatlamli yoki sodda)  # ✅

6. Biznes qoidasi tashqarida (adapter/kontroller)

python
# kontrollerda soliq hisobi                   # ⚠️
# qoida entity/use caseda                      # ✅

7. Halqani sakrash (kontroller→entity to'g'ridan)

python
# kontroller entityni to'g'ridan yaratadi      # ⚠️
# use case orqali (orkestr)                     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 27.6-dars (o'tilgan): Qatlamli — Clean asosi
  • 27.8-dars: DDD — domen urg'usi
  • 27.2-dars (o'tilgan): SOLID — DIP (yadrosi)
  • 23-qism (o'tilgan): ORM — adapter (domendan tashqarida)
  • 20-qism (o'tilgan): FastAPI — framework halqasi

8. Eng yaxshi amaliyotlar

  1. Domen sof (texnologiya import yo'q).

  2. Interfeys domenda (bog'liqlik ichkariga).

  3. Use case interfeysga bog'liq (DIP).

  4. Biznes qoidasi entity/use caseda.

  5. Domen va ORM model alohida.

  6. Detalni kechiktir (texnologiya keyin).

  7. Katta/uzoq loyihaga (KISS — kichikka sodda).

  8. Halqa sakramaslik (use case orqali).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # Clean Architecture nima?
2.  # bog'liqlik qoidasi nima?
3.  # bog'liqlik qaysi yo'nalishda?
4.  # entities nima?
5.  # use cases nima?
6.  # adapters nima?
7.  # frameworks nima?
8.  # domen nimaga bog'liq?
9.  # interfeys qayerda?
10. # domen mustaqilligi nima?
11. # Clean vs qatlamli?
12. # narxi?
Javoblar
  1. Domen markazda, bog'liqlik ichkariga
  2. Bog'liqlik faqat ichkariga
  3. Ichkariga (tashqi → ichki)
  4. Asosiy model + korxona qoidasi
  5. Amaliyotlar (ilova qoidasi)
  6. Kontroller, repository (tarjimon)
  7. Baza, veb, UI (tashqi)
  8. Hech narsaga (mustaqil)
  9. Domenda (ichkarida)
  10. Texnologiyasiz (sof Python)
  11. Clean — bog'liqlik teskari (domen markaz)
  12. Ko'p kod/mavhumlik

Vazifa 2: Xatolarni tuzating

python
1.  # domen: import sqlalchemy        # sof

2.  # interfeys baza modulida         # domenda

3.  self.db = Postgres()             # interfeys

4.  class Buyurtma(Base)             # sof + ORM alohida

5.  # kontrollerda soliq hisobi       # use case
Javoblar
python
1.  domen sof Python (interfeys orqali)

2.  interfeys domenda (bog'liqlik ichkariga)

3.  def __init__(self, repo: Repository)

4.  class Buyurtma:  # sof + alohida ORM

5.  qoida entity/use caseda

Vazifa 3: Entity

Tuzing:

  1. Model
  2. Qoida
  3. Sof Python
  4. Import yo'q

Vazifa 4: Use case

Tuzing:

  1. Interfeys
  2. Bog'lanish
  3. Entity ishlatish
  4. Amaliyot

Vazifa 5: Bog'liqlik

Tekshiring:

  1. Ichkariga
  2. Domen mustaqil
  3. Interfeys domenda
  4. Baza moslashadi

Vazifa 6: Almashtirish

Tuzing:

  1. Interfeys
  2. SQL
  3. NoSQL
  4. Domen tegilmaydi

Vazifa 7: O'ylash

Clean Architecture ning markaziy g'oyasi — biznes qoidalari (domen) texnologiyadan (baza, freymvork) qimmatliroq va barqarorroq, shuning uchun himoyalanishi kerak. Nima uchun ko'p dasturchi buni teskari his qiladi (texnologiya — asosiy, biznes qoidasi — "shunchaki kod"), va nega "detalni kechiktirish" (texnologiya qarorini keyinga qoldirish) amalda juda qiyin (garchi nazariyada to'g'ri bo'lsa)?

Javob

Qisqa javob: Ko'p dasturchi buni teskari his qiladi, chunki: texnologiya ko'rinadigan va hayajonli (yangi freymvork, baza — o'rganiladi, gaplashiladi, rezyumega yoziladi), biznes qoidalari zerikarli va "aniq" ("shunchaki soliq hisobi" — ahamiyatsiz tuyuladi); dasturchi texnik muammolarni yechishni yoqtiradi (freymvork sozlash, optimizatsiya — qiziqarli), biznes qoidalari esa domen bilimi talab qiladi (soha ekspertlari bilan gaplashish — texnik emas). Lekin bu yanglish: texnologiya almashadi (5 yilda freymvork eskiradi, baza o'zgaradi), biznes qoidalari qoladi (soliq hisobi 20 yil bir xil) — qiymat qoidalarda (tizim nima uchun mavjud), texnologiya faqat vosita (qanday). "Detalni kechiktirish" amalda qiyin, chunki: bosim (loyiha boshida "qaysi baza?" savoli darrov chiqadi — jamoa qaror kutadi), noqulaylik (interfeys yozish — qo'shimcha ish, aniq bazani ishlatish tezroq), ko'rinmas foyda (kechiktirishning foydasi keyin — baza o'zgarganda — ko'rinadi, hozir emas), odat (ko'p dasturchi bazadan boshlaydi — jadval loyihalash, keyin kod). Nazariyada to'g'ri (domen avval), amalda qiyin (bosim, noqulaylik, odat). Yechim: intizom (domenni avval o'ylash — texnologiyasiz), interfeys bilan chegara (baza qarorini adapter ichida ushlash). Muhandislik saboqlari: qiymat — biznes qoidalarda (texnologiya vosita); texnologiya hayajonli, lekin o'tkinchi; domen zerikarli, lekin barqaror; "detalni kechiktirish" — intizom (bosimga qarshi); yaxshi arxitektura — qiymatni (domen) himoya qiladi (texnologiyani ushlaydi).

1. Nega teskari his qilinadi

  • Texnologiya ko'rinadigan, hayajonli (yangi, rezyume)
  • Biznes qoidasi zerikarli, "aniq" (ahamiyatsiz tuyuladi)
  • Dasturchi texnik muammoni yoqtiradi (domen bilimi emas)

2. Nega yanglish

Narsa Umri
Texnologiya Almashadi (5 yil)
Biznes qoidasi Qoladi (20 yil)

Qiymat qoidalarda (nima uchun), texnologiya vosita (qanday).

3. Nega kechiktirish qiyin

  • Bosim ("qaysi baza?" darrov)
  • Noqulaylik (interfeys — qo'shimcha ish)
  • Ko'rinmas foyda (keyin ko'rinadi)
  • Odat (bazadan boshlash)

4. Yechim

Intizom (domen avval), interfeys chegara (baza adapterda). Bosimga qarshi.

5. Muhandislik saboqlari

  1. Qiymat — biznes qoidalarda (texnologiya vosita)
  2. Texnologiya hayajonli, lekin o'tkinchi
  3. Domen zerikarli, lekin barqaror
  4. Detalni kechiktirish — intizom

6. Xulosa

  1. Texnologiya ko'rinadigan (his teskari)
  2. Qoidalar barqaror, texnologiya almashadi
  3. Kechiktirish qiyin (bosim, odat)
  4. Intizom — qiymatni himoya qil

Nimani mustahkamlaydi: 2.6, 2.8-bo'limlar.

Xulosa

Bu darsda Clean Architecture ni o'rgandik.

Eng muhim uch fikr:

  1. Clean Architecture va bog'liqlik qoidasi. Clean Architecture — tizimni konsentrik halqalar ga bo'lib, domenni (biznes qoidalari) markazga qo'yadi: markazda entities (asosiy model), atrofida use cases (amaliyot), tashqarida adapters (kontroller), eng tashqarida frameworks (baza, veb). Bog'liqlik qoidasi (Dependency Rule) — asosiy qonun: manba kodi bog'liqligi faqat ichkariga (tashqi → ichki), ichki halqa tashqini bilmaydi (domen bazani bilmaydi, baza domenga moslashadi). Sabab: baza domenga bog'liq bo'lsa — baza o'zgaradi, domen barqaror (biznes qoidalari — eng qimmatli, o'zgarmas).

  2. Domen mustaqilligi va bog'liqlikni teskari qilish. Domen mustaqilligi — domen (entities, use cases) sof Python da, tashqi texnologiyaga import yo'q (sqlalchemy, fastapi yo'q — faqat biznes qoidalari): texnologiya almashsa (PostgreSQL → MongoDB) domen tegilmaydi, mustaqil sinaladi (baza kerak emas). Bog'liqlikni teskari qilish — domen interfeys (repository shartnomasi) ni belgilaydi (ichkarida), tashqi qatlam uni amalga oshiradi (tashqarida): bog'liqlik teskari (baza domenga moslashadi), DIP 27.2-bob ning yuragi. Use case interfeysga bog'liq (aniq bazaga emas).

  3. Foyda, narx, yadroni himoya qilish. Foydalar: texnologiya mustaqilligi (baza/freymvork almashadi, domen qoladi), sinaladiganlik (bazasiz — tez), barqarorlik (yadro o'zgarmaydi), ravshanlik. Narx: ko'proq kod (interfeys, adapter — ko'p sinf), ko'proq mavhumlik, ortiqcha (kichik loyihaga — KISS); Clean katta, uzoq muddatli, murakkab biznes uchun. Clean Architecture — qatlamli arxitekturaning 27.6-bob takomili (bog'liqlik ichkariga, domen markazda; Onion, Hexagonal — bir g'oya). Asosiy g'oya — eng qimmatlini himoya qilish: biznes qoidalari (domen, barqaror) texnologiyadan (o'zgaruvchi vosita) ustun; "detalni kechiktirish" (texnologiya qarorini keyinga) — nazariyada to'g'ri, amalda qiyin (bosim, odat — intizom talab qiladi). Yadro barqaror — tizim uzoq yashaydi. DDD 27.8-bob uchun asos.

Keyingi darsda Domain-Driven Design (DDD) kirishini o'rganamiz: murakkab biznes domenini kod bilan modellashtirimsh — umumiy til (ubiquitous language), chegaralangan kontekst (bounded context), entity, value object va aggregate tushunchalari bilan.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
27.7-dars: Clean Architecture — IlmHamroh