Что такое архитектура разработки ПО?

Архитектура разработки ПО: Проектирование масштабируемых систем

Архитектура разработки ПО — это набор высокоуровневых структур, паттернов и принципов, которые определяют организацию кода, разделение ответственности между компонентами и способы взаимодействия между ними. Хорошая архитектура — это фундамент масштабируемого, поддерживаемого и тестируемого приложения.

Основные принципы архитектуры

Separation of Concerns (Разделение ответственности)

Каждый компонент должен отвечать за одну задачу:

# Плохо: смешивание ответственности
class UserManager:
    def save_user(self, user):
        # Валидация
        if not user.email:
            raise ValueError("Email required")
        # Сохранение в БД
        db.save(user)
        # Отправка письма
        email_service.send_welcome_email(user.email)
        # Логирование
        logger.info(f"User {user.id} saved")

# Хорошо: разделение ответственности
class UserValidator:
    @staticmethod
    def validate(user):
        if not user.email:
            raise ValueError("Email required")

class UserRepository:
    @staticmethod
    def save(user):
        db.save(user)

class EmailService:
    @staticmethod
    def send_welcome(email):
        email_service.send(email)

class UserService:
    def register(self, user):
        UserValidator.validate(user)
        UserRepository.save(user)
        EmailService.send_welcome(user.email)

Основные архитектурные паттерны

1. Layered Architecture (Многоуровневая архитектура)

Приложение разделяется на горизонтальные слои:

• Presentation Layer — интерфейс пользователя (API, веб-страницы)
• Application Layer — бизнес-логика и use cases
• Domain Layer — сущности и правила бизнеса
• Infrastructure Layer — работа с БД, сервисы, внешние API

2. Domain-Driven Design (DDD)

Архитектура строится вокруг бизнес-моделей:

# Entities — объекты с идентичностью
class User:
    def __init__(self, id, name, email):
        self.id = id
        self.name = name
        self.email = email

# Value Objects — объекты без идентичности
class Email:
    def __init__(self, address):
        self.address = address
    
    def is_valid(self):
        return '@' in self.address

# Aggregates — группировка связанных сущностей
class UserAggregate:
    def __init__(self, user, email):
        self.user = user
        self.email = email

3. Microservices Architecture

Приложение разбивается на независимые сервисы:

• Каждый сервис отвечает за одну область функциональности
• Сервисы общаются через API (REST, gRPC)
• Независимое развертывание и масштабирование

4. MVC (Model-View-Controller)

# Model — данные и логика
class UserModel:
    def get_all_users(self):
        return db.query(User).all()

# Controller — обработка запросов
class UserController:
    def list_users(self):
        users = UserModel.get_all_users()
        return self.render_view(users)

# View — представление данных
def render_view(users):
    return render_template('users.html', users=users)

SOLID принципы

• S (Single Responsibility) — один класс = одна ответственность
• O (Open/Closed) — открыт для расширения, закрыт для модификации
• L (Liskov Substitution) — подклассы должны быть заменяемы
• I (Interface Segregation) — много специфичных интерфейсов, чем один универсальный
• D (Dependency Inversion) — зависеть от абстракций, не от конкретики

Проектирование API

# RESTful API архитектура
# Resources — существительные, не глаголы
GET /api/users          # Получить список пользователей
POST /api/users         # Создать пользователя
GET /api/users/123      # Получить пользователя с id 123
PUT /api/users/123      # Обновить пользователя
DELETE /api/users/123   # Удалить пользователя

Обработка ошибок и логирование

# Структурированное логирование
logger.info("User registered", extra={
    'user_id': user.id,
    'email': user.email
})

# Централизованная обработка ошибок
class AppException(Exception):
    def __init__(self, code, message):
        self.code = code
        self.message = message

try:
    user = register_user(data)
except AppException as e:
    logger.error(f"Registration failed: {e.message}")
    return error_response(e.code, e.message)

Масштабируемость и производительность

• Кеширование — сохранение результатов дорогих операций
• Асинхронность — использование Celery, RabbitMQ для фоновых задач
• Индексирование БД — ускорение поиска
• Load Balancing — распределение нагрузки между серверами

Тестируемость

Хорошая архитектура должна быть легко тестируемой:

# Dependency Injection для тестирования
class UserService:
    def __init__(self, repository):
        self.repository = repository
    
    def get_user(self, user_id):
        return self.repository.find(user_id)

# В тестах используем mock-объект
def test_get_user():
    mock_repo = MockRepository()
    service = UserService(mock_repo)
    user = service.get_user(123)
    assert user is not None

Хорошая архитектура — это инвестиция в будущее проекта. Она позволяет быстро добавлять новые функции, легко найти и исправить баги, и масштабировать приложение по мере роста.