Практическое построение фреймворка на PHP: от идеи до реализации

Расширенные примеры реализации компонентов фреймворка

Полноценный роутер с поддержкой middleware

Роутер может выполнять цепочку middleware перед вызовом контроллера. Пример основан на PSR-15.

interface MiddlewareInterface {
    public function handle(callable $next): void;
}

class Router {
    private array $routes = [];
    private array $middlewares = [];

    public function addMiddleware(MiddlewareInterface $middleware): void {
        $this->middlewares[] = $middleware;
    }

    public function add(string $method, string $pattern, callable $handler): void {
        $this->routes[] = compact('method', 'pattern', 'handler');
    }

    public function run(): void {
        $uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
        $method = $_SERVER['REQUEST_METHOD'];
        foreach ($this->routes as $route) {
            if ($route['method'] !== $method) continue;
            if (preg_match($route['pattern'], $uri, $params)) {
                $core = function () use ($route, $params) {
                    ($route['handler'])($params);
                };
                // оборачиваем middleware снаружи внутрь
                $pipeline = array_reduce(
                    array_reverse($this->middlewares),
                    function ($next, MiddlewareInterface $mw) {
                        return function () use ($mw, $next) {
                            $mw->handle($next);
                        };
                    },
                    $core
                );
                $pipeline();
                return;
            }
        }
        http_response_code(404);
    }
}

// Пример middleware для логирования
class LoggingMiddleware implements MiddlewareInterface {
    public function handle(callable $next): void {
        error_log('Request: ' . $_SERVER['REQUEST_URI']);
        $next();
    }
}

Контейнер с поддержкой PSR-11 и автозаполнением

Реализация, соответствующая интерфейсу Psr\Container\ContainerInterface, с автоматическим разрешением зависимостей через Reflection и обработкой циклических ссылок.

use Psr\Container\ContainerInterface;

class Container implements ContainerInterface {
    private array $definitions = [];
    private array $instances = [];
    private array $resolving = []; // для обнаружения циклов

    public function set(string $id, callable $factory): void {
        $this->definitions[$id] = $factory;
    }

    public function get(string $id): object {
        if (isset($this->resolving[$id])) {
            throw new \RuntimeException("Ciclic dependency for $id");
        }
        if (!isset($this->instances[$id])) {
            $this->resolving[$id] = true;
            if (isset($this->definitions[$id])) {
                $this->instances[$id] = $this->definitions[$id]($this);
            } else {
                $this->instances[$id] = $this->autowire($id);
            }
            unset($this->resolving[$id]);
        }
        return $this->instances[$id];
    }

    public function has(string $id): bool {
        return isset($this->definitions[$id]) || class_exists($id);
    }

    private function autowire(string $class): object {
        $ref = new ReflectionClass($class);
        if (!$ref->isInstantiable()) {
            throw new \InvalidArgumentException("Class $class is not instantiable");
        }
        $constructor = $ref->getConstructor();
        if (!$constructor) {
            return $ref->newInstance();
        }
        $args = [];
        foreach ($constructor->getParameters() as $param) {
            $type = $param->getType();
            if ($type && !$type->isBuiltin()) {
                $args[] = $this->get($type->getName());
            } elseif ($param->isDefaultValueAvailable()) {
                $args[] = $param->getDefaultValue();
            } else {
                throw new \RuntimeException("Cannot resolve parameter \${$param->getName()} for class $class");
            }
        }
        return $ref->newInstanceArgs($args);
    }
}

Шаблонизатор с наследованием (простая реализация)

Минималистичная система шаблонов, поддерживающая блоки и extends, вдохновлённая Smart или Twig.

class Template {
    private string $basePath;

    public function __construct(string $basePath) {
        $this->basePath = $basePath;
    }

    public function render(string $template, array $data = []): string {
        extract($data);
        ob_start();
        include $this->basePath . '/' . $template . '.php';
        return ob_get_clean();
    }

    // Пример использования в шаблоне:
    // {% extends 'layout' %}
    // {% block content %}...{% endblock %}
}

// Функция-помощник для парсинга extends и block (упрощённо)
function parseTemplate(string $content, Template $engine): string {
    // можно реализовать замену с помощью регулярных выражений
    return $content;
}

Результат работы шаблонизатора с наследованием (входной шаблон):

Базовая структура применена: блок content заменён на переданный контент.

Обработчик ошибок с поддержкой разных форматов

Класс, который определяет формат ответа в зависимости от заголовка Accept.

class HttpErrorHandler {
    public function __invoke(Throwable $e): void {
        $statusCode = ($e instanceof \InvalidArgumentException) ? 400 : 500;
        http_response_code($statusCode);

        $accept = $_SERVER['HTTP_ACCEPT'] ?? 'text/html';
        if (strpos($accept, 'application/json') !== false) {
            header('Content-Type: application/json');
            echo json_encode([
                'error' => $e->getMessage(),
                'code' => $statusCode,
            ]);
        } else {
            header('Content-Type: text/html; charset=utf-8');
            echo sprintf(
                '<h1>Ошибка %d</h1><p>%s</p>',
                $statusCode,
                htmlspecialchars($e->getMessage())
            );
        }
    }
}

// Регистрация
set_exception_handler(new HttpErrorHandler());