Introduction
Choosing the right architecture pattern affects maintainability, testability, and scalability. This guide covers major architecture patterns and when to use each.
Architecture is about decisions that are hard to change.
Layered Architecture
┌─────────────────────────────────────────────────────────────┐
│ Layered Architecture │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Presentation Layer │ │
│ │ (Controllers, Views, API handlers) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Business Layer │ │
│ │ (Services, Business Logic) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Data Layer │ │
│ │ (Repositories, DAOs) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Implementation
# Controllers (Presentation)
class UserController:
def __init__(self, user_service):
self.user_service = user_service
def create_user(self, request):
user_data = request.json()
user = self.user_service.create(user_data)
return json_response(user)
# Services (Business)
class UserService:
def __init__(self, user_repository):
self.user_repository = user_repository
def create(self, data):
user = User.from_dict(data)
return self.user_repository.save(user)
# Repositories (Data)
class UserRepository:
def __init__(self, db):
self.db = db
def save(self, user):
return self.db.users.insert(user.to_dict())
Hexagonal Architecture
┌─────────────────────────────────────────────────────────────┐
│ Hexagonal Architecture │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ │
│ │ Ports │ │
│ ┌─────┴─────────┴─────┐ │
│ │ │ │
│ ┌───────▼───────┐ ┌───────▼───────┐ │
│ │ Application │ │ Adapters │ │
│ │ Core │ │ │ │
│ │ │ │ - REST │ │
│ │ - Entities │ │ - Database │ │
│ │ - Use Cases │ │ - Message │ │
│ │ │ │ - External │ │
│ └────────────────┘ └───────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Ports and Adapters
# Port (interface)
class UserRepository(Protocol):
def save(self, user: User) -> User: ...
def find_by_id(self, user_id: str) -> Optional[User]: ...
# Adapter (implementation)
class PostgresUserRepository:
def __init__(self, db):
self.db = db
def save(self, user):
return self.db.save(user)
def find_by_id(self, user_id):
return self.db.find(user_id)
# Use Case (application core)
class CreateUserUseCase:
def __init__(self, user_repo: UserRepository):
self.user_repo = user_repo
def execute(self, user_data):
user = User.from_dict(user_data)
return self.user_repo.save(user)
Clean Architecture
┌─────────────────────────────────────────────────────────────┐
│ Clean Architecture │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Frameworks & Drivers │ │
│ │ (HTTP, Database, UI, External APIs) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Interface Adapters │ │
│ │ (Controllers, Presenters, Gateways) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Use Cases │ │
│ │ (Application Business Rules) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Entities │ │
│ │ (Enterprise Business Rules) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Best Practices
- Dependency rule: Dependencies point inward
- Separate concerns: Each layer has one job
- Testability: Easy to test each layer in isolation
- Flexibility: Swap implementations without changing core
Resources
- Clean Architecture by Robert Martin - The definitive book on clean architecture
- Hexagonal Architecture - Original hexagonal architecture article
- Onion Architecture - Alternative layered architecture
Comments