Saubere Architektur mit den Augen eines Python-Entwicklers

Das Streben nach Eleganz und die kraftvolle Dynamik der Sprache haben viele Bibliotheken mit einer wirklich reizvollen API geschaffen. 

Schlechter Code

Saubere Architektur

• Die Prioritätsregel für die innere Schicht - Es ist die innere Schicht, die die Schnittstelle bestimmt, über die sie mit der Außenwelt interagiert.
• Abhängigkeitsregel - Abhängigkeiten sollten von der inneren zur äußeren Schicht gerichtet werden.

• Grenzübergangsregel;
• Abhängigkeitsregel;
• Die Prioritätsregel der inneren Schicht.

• Einfache Prüfung - Die Schichten sind isoliert, sie können ohne Affenflicken getestet werden. Sie können die Beschichtung je nach Grad ihrer Wichtigkeit für verschiedene Schichten granular einstellen.
• Einfache Änderung der Geschäftsregeln , da alle an einem Ort gesammelt werden, nicht über das Projekt verteilt sind und nicht mit Code auf niedriger Ebene gemischt werden.
• Unabhängigkeit von externen Agenten : Das Vorhandensein von Abstraktionen zwischen Geschäftslogik und Außenwelt ermöglicht es Ihnen in bestimmten Fällen, externe Quellen zu ändern, ohne die internen Ebenen zu beeinflussen. Dies funktioniert, wenn Sie die Geschäftslogik nicht an die spezifischen Funktionen externer Agenten gebunden haben, z. B. Datenbanktransaktionen.
• , , , .

, . . , . « Clean Architecture».

Python

from rentomatic.response_objects import response_objects as res

class RoomListUseCase(object):
   def __init__(self, repo):
       self.repo = repo
   def execute(self, request_object):
       if not request_object:
           return res.ResponseFailure.build_from_invalid_request_object(
               request_object)
       try:
           rooms = self.repo.list(filters=request_object.filters)
           return res.ResponseSuccess(rooms)
       except Exception as exc:
           return res.ResponseFailure.build_system_error(
               "{}: {}".format(exc.__class__.__name__, "{}".format(exc)))

repo RoomListUseCase, execute — . - , , . - . , , , repo .

from typing import Optional, List
from pydantic import BaseModel

class Room(BaseModel):
   code: str
   size: int
   price: int
   latitude: float
   longitude: float

class RoomFilter(BaseModel):
   code: Optional[str] = None
   price_min: Optional[int] = None
   price_max: Optional[int] = None

class RoomStorage:
   def get_rooms(self, filters: RoomFilter) -> List[Room]: ...

class RoomListUseCase:
   def __init__(self, repo: RoomStorage):
       self.repo = repo
   def show_rooms(self, filters: RoomFilter) -> List[Room]:
       rooms = self.repo.get_rooms(filters=filters)
       return rooms

def rool_list_use_case(filters: RoomFilter, repo: RoomStorage) -> List[Room]:
   rooms = repo.get_rooms(filters=filters)
   return rooms

from typing import List
from fastapi import FastAPI, Depends
from rentomatic import services, adapters
app = FastAPI()

def get_use_case() -> services.RoomListUseCase:
   return services.RoomListUseCase(adapters.MemoryStorage())

@app.post("/rooms", response_model=List[services.Room])
def rooms(filters: services.RoomFilter, use_case=Depends(get_use_case)):
   return use_case.show_rooms(filters)

, , , RoomStorage. , 15 , , , .

• Grenzüberschreitungsregel: pydantische Modelle, bei denen es sich im Wesentlichen um DTOs handelt, überschreiten Grenzen ;
• Abhängigkeitsregel : Die Geschäftslogikschicht ist unabhängig von anderen Schichten.
• Die Prioritätsregel der inneren Schicht : Es ist die Geschäftslogikschicht, die die Schnittstelle (RoomStorage) definiert, über die die Geschäftslogik mit der Außenwelt interagiert.