Express это фреймворк

Express как фреймворк для Node.js

Да, Express — это легковесный но мощный веб-фреймворк для Node.js. Это один из самых популярных фреймворков в экосистеме, и я использовал его в десятках проектов.

Что такое Express

Express — это фреймворк для:

• Создания REST API
• Обработки HTTP запросов
• Управления маршрутами (routing)
• Работы с middleware

const express = require('express');
const app = express();

app.get('/api/users/:id', (req, res) => {
  res.json({ id: req.params.id });
});

app.listen(3000, () => console.log('Server running'));

Концепция Middleware

Это сердце Express. Middleware — это функции, которые имеют доступ к request и response объектам:

app.use((req, res, next) => {
  console.log('Request received');
  next(); // передать управление следующему middleware
});

app.use((req, res, next) => {
  req.startTime = Date.now();
  next();
});

app.get('/api/users', (req, res) => {
  res.json({ data: [] });
});

Порядок важен! Middleware выполняются в том порядке, в котором их определили.

Структура типичного Express приложения

// app.ts
import express from 'express';
import cors from 'cors';
import { userRouter } from './routes/users';
import { errorHandler } from './middleware/error-handler';

const app = express();

// Global middleware
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Логирование
app.use((req, res, next) => {
  console.log(`${req.method} ${req.path}`);
  next();
});

// Роуты
app.use('/api/users', userRouter);

// Обработка ошибок (ДОЛЖНА быть в конце!)
app.use(errorHandler);

export default app;

Роутеры

Это модули для группировки связанных маршрутов:

// routes/users.ts
import { Router } from 'express';
import { UserController } from '../controllers/user-controller';

const router = Router();
const controller = new UserController();

router.get('/:id', controller.getUser);
router.post('/', controller.createUser);
router.put('/:id', controller.updateUser);
router.delete('/:id', controller.deleteUser);

export { router as userRouter };

Использование в main приложении:

app.use('/api/users', userRouter);
// GET /api/users/:id → controller.getUser
// POST /api/users → controller.createUser

Обработка ошибок

В Express есть специальный механизм для ошибок:

// Middleware для обработки ошибок (4 параметра обязательны!)
app.use((err, req, res, next) => {
  console.error(err);
  
  res.status(err.status || 500).json({
    error: {
      message: err.message,
      status: err.status || 500
    }
  });
});

// В контроллере
class UserController {
  async getUser(req, res, next) {
    try {
      const user = await userService.getUser(req.params.id);
      res.json(user);
    } catch (error) {
      next(error); // передаём в error handler middleware
    }
  }
}

Жизненный цикл request-response

1. HTTP запрос приходит
   ↓
2. Express обрабатывает global middleware (app.use)
   ↓
3. Express ищет matching route
   ↓
4. Выполняет middleware для этого route (router.use)
   ↓
5. Выполняет handler (controller)
   ↓
6. Отправляет response (res.json, res.send, etc.)
   ↓
7. Если error — идёт в error handler middleware

Параметры запроса

app.get('/api/users/:id/posts/:postId', (req, res) => {
  console.log(req.params);    // { id: '123', postId: '456' }
  console.log(req.query);     // { sort: 'date', limit: '10' }
  console.log(req.body);      // { name: 'John' }
  console.log(req.headers);   // { authorization: 'Bearer ...' }
});

// GET /api/users/123/posts/456?sort=date&limit=10
// POST /api/users { "name": "John" }

Практические примеры

Пример 1: Аутентификация middleware

const authMiddleware = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ error: 'Invalid token' });
  }
};

// Использование
router.get('/protected', authMiddleware, (req, res) => {
  res.json({ user: req.user });
});

Пример 2: Валидация request body

const validateUser = (req, res, next) => {
  const { name, email } = req.body;
  
  if (!name || !email) {
    return res.status(400).json({ error: 'Name and email required' });
  }
  
  if (!email.includes('@')) {
    return res.status(400).json({ error: 'Invalid email' });
  }
  
  next();
};

router.post('/users', validateUser, (req, res) => {
  // Здесь знаем, что данные валидны
  const user = await userService.create(req.body);
  res.status(201).json(user);
});

Пример 3: Логирование и метрики

app.use((req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`${req.method} ${req.path} ${res.statusCode} ${duration}ms`);
  });
  
  next();
});

Express vs альтернативы

• Express — минималистичный, максимум контроля
• Fastify — быстрее, встроенная валидация, лучше типизация
• Nest.js — фреймворк с архитектурой (вроде Spring Boot)
• Hapi — более структурированный, лучше для больших приложений

Когда используется Express

• Быстрого прототипирования
• Небольших до средних REST API
• Когда нужна гибкость в архитектуре
• Legacy проектов (Express везде)

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

1. Разделение ответственности: роуты → контроллеры → сервисы → репозитории
2. Middleware в правильном порядке: логирование → парсинг → аутентификация → роуты → ошибки
3. Error handling: всегда обрабатывай ошибки в middleware
4. TypeScript: добавь типизацию для req и res
5. Асинхронность: используй async/await, оборачивай в try-catch
6. Валидация: валидируй входные данные на границе API

Express — это отличный выбор для backend разработки в Node.js, особенно если ты ценишь простоту и контроль над архитектурой.