Что такое трехуровневая архитектура?

Трёхуровневая архитектура (Three-Tier Architecture)

Трёхуровневая архитектура (три слоя / 3-tier) — это классическая архитектурная парадигма, которая разделяет приложение на три логических и физических слоя: представления, бизнес-логики и данных. Это один из самых распространённых подходов в веб-разработке.

Структура трёхуровневой архитектуры

┌─────────────────────────────────────┐
│   PRESENTATION LAYER (Слой Клиента) │
│      (Frontend / UI / User)         │
└──────────────────┬──────────────────┘
                   │ HTTP/API
┌──────────────────▼──────────────────┐
│  BUSINESS LOGIC LAYER (Слой Бизнеса)│
│  (Backend / Application Logic)       │
└──────────────────┬──────────────────┘
                   │ SQL/Query
┌──────────────────▼──────────────────┐
│   DATA LAYER (Слой Данных)          │
│     (Database / Persistence)        │
└─────────────────────────────────────┘

Три слоя подробно

1. Presentation Layer (Слой представления)

Что находится здесь:

• Фронтенд приложение (React, Vue, Angular)
• HTML/CSS/JavaScript
• Пользовательский интерфейс
• Валидация на клиенте
• Отправка запросов на backend

Ответственность:

• Отображение данных пользователю
• Получение ввода от пользователя
• Форматирование данных для отправки

Пример:

// React компонент (Presentation Layer)
function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);
  
  useEffect(() => {
    // Запрос к Business Logic Layer
    fetch(`/api/users/${userId}`)
      .then(res => res.json())
      .then(data => {
        setUser(data);
        setLoading(false);
      });
  }, [userId]);
  
  if (loading) return <div>Загрузка...</div>;
  
  return (
    <div>
      <h1>{user.name}</h1>
      <p>Email: {user.email}</p>
      <button onClick={() => updateProfile(user)}>Обновить</button>
    </div>
  );
}

2. Business Logic Layer (Слой бизнес-логики)

Что находится здесь:

• REST API endpoints (Flask, Django, Express, FastAPI)
• Обработка запросов
• Валидация данных
• Бизнес-правила и логика
• Аутентификация и авторизация
• Обработка ошибок

Ответственность:

• Обработка запросов от клиента
• Применение бизнес-правил
• Взаимодействие с Data Layer
• Возврат результатов клиенту

Пример (FastAPI):

from fastapi import FastAPI, HTTPException
from sqlalchemy.orm import Session

app = FastAPI()

@app.get("/api/users/{user_id}")
def get_user(user_id: int, db: Session = Depends(get_db)):
    # Бизнес-логика: получить пользователя
    user = db.query(User).filter(User.id == user_id).first()
    
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    
    # Бизнес-правило: скрыть чувствительные данные
    return {
        "id": user.id,
        "name": user.name,
        "email": user.email
        # password не возвращаем!
    }

@app.post("/api/users")
def create_user(user_data: UserCreate, db: Session = Depends(get_db)):
    # Валидация: проверяем, существует ли пользователь
    existing = db.query(User).filter(User.email == user_data.email).first()
    if existing:
        raise HTTPException(status_code=400, detail="Email already exists")
    
    # Бизнес-логика: создаём пользователя
    new_user = User(
        name=user_data.name,
        email=user_data.email,
        password_hash=hash_password(user_data.password)
    )
    db.add(new_user)
    db.commit()
    
    return {"id": new_user.id, "name": new_user.name}

3. Data Layer (Слой данных)

Что находится здесь:

• База данных (PostgreSQL, MySQL, MongoDB)
• ORM модели (SQLAlchemy, Mongoose)
• SQL запросы
• Кэширование (Redis)

Ответственность:

• Сохранение данных
• Retrieval данных из БД
• Транзакции
• Индексы и оптимизация

Пример (SQLAlchemy):

from sqlalchemy import Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True)
    name = Column(String(100), nullable=False)
    email = Column(String(100), unique=True, nullable=False)
    password_hash = Column(String(255), nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    
    # Это определение модели взаимодействует с Data Layer

Преимущества трёхуровневой архитектуры

1. Разделение ответственности — каждый слой отвечает за одно
2. Модульность — легко добавлять новые функции
3. Масштабируемость — слои можно масштабировать независимо
4. Тестируемость — каждый слой можно тестировать отдельно
5. Переиспользуемость — backend может обслуживать несколько фронтенд-приложений
6. Безопасность — чувствительная логика на backend
7. Понятность — новые разработчики быстро разбирают код

Недостатки

1. Сложность — много файлов и структура
2. Производительность — много слоёв означает больше обработки
3. Узкие места — Business Layer может быть bottleneck
4. Статефульность — сложнее масштабировать при состоянии

Примеры в реальных проектах

E-commerce платформа

Frontend (React/Vue)
  ↓
  Отправляет POST /api/orders с товарами
  
Backend (Django/FastAPI)
  ↓
  Проверяет: товары существуют?
  Достаточно денег на счёте?
  Всё валидно?
  
Database
  ↓
  Сохраняет заказ
  Обновляет количество товара
  Записывает транзакцию

Социальная сеть

Frontend (React)
  ↓
  Пользователь нажимает "Like"
  Отправляет POST /api/posts/{id}/like
  
Backend
  ↓
  Проверяет: пользователь авторизован?
  Уже ли поставил лайк?
  Пост существует?
  
Database
  ↓
  Добавляет запись в таблицу likes
  Увеличивает счётчик лайков

Трёхуровневая архитектура vs MVC

Лучшие практики

1. Изолируй слои — не смешивай логику

# Плохо: логика БД в контроллере
@app.get("/users/{id}")
def get_user(id: int):
    user = db.query(User).filter(User.id == id).first()
    return user

# Хорошо: логика в сервис-слое
@app.get("/users/{id}")
def get_user(id: int, service: UserService):
    return service.get_user(id)

1. Используй репозитории — абстрагируй доступ к БД
2. Валидируй везде — на frontend и backend
3. Логируй — для отладки и мониторинга
4. Обрабатывай ошибки — не позволяй исключениям утечь

Развитие: от трёхуровневой к микросервисам

Когда приложение растёт, можно перейти на архитектуру микросервисов, где каждый сервис — это свои три слоя:

Frontend
  ↓
API Gateway
  ├─→ User Service (3 слоя)
  ├─→ Order Service (3 слоя)
  ├─→ Payment Service (3 слоя)
  └─→ Notification Service (3 слоя)

Ключевые выводы

1. Трёхуровневая архитектура разделяет приложение на Presentation, Business Logic и Data слои
2. Каждый слой имеет определённую ответственность и взаимодействует через четко определённые интерфейсы
3. Это обеспечивает модульность, тестируемость и масштабируемость
4. Frontend и Backend могут разрабатываться независимо
5. Это основа большинства современных веб-приложений и микросервисной архитектуры