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

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

Реализация маршрутизатора с поддержкой групп и middleware

Ниже показан более продвинутый роутер, который поддерживает группы маршрутов с общим middleware.

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

    public function group(array $attributes, callable $callback): void
    {
        $this->groupStack[] = $attributes;
        call_user_func($callback, $this);
        array_pop($this->groupStack);
    }

    public function add(string $method, string $path, callable $handler, array $middleware = []): void
    {
        $prefix = '';
        $groupMiddleware = [];
        foreach ($this->groupStack as $group) {
            $prefix .= $group['prefix'] ?? '';
            $groupMiddleware = array_merge($groupMiddleware, $group['middleware'] ?? []);
        }
        $fullPath = $prefix . $path;
        $this->routes[] = [
            'method' => $method,
            'path' => $fullPath,
            'handler' => $handler,
            'middleware' => array_merge($groupMiddleware, $middleware)
        ];
    }

    public function dispatch(string $method, string $uri): void
    {
        foreach ($this->routes as $route) {
            if ($route['method'] !== $method) continue;
            $pattern = preg_replace('/\{([a-z]+)\}/', '(?P<$1>[^/]+)', $route['path']);
            if (preg_match('#^' . $pattern . '$#', $uri, $matches)) {
                $params = array_filter($matches, 'is_string', ARRAY_FILTER_USE_KEY);
                // Выполнение middleware
                $stack = $route['middleware'];
                $handler = $route['handler'];
                $next = function ($request) use ($handler, $params) {
                    return $handler($request, ...$params);
                };
                while ($middleware = array_pop($stack)) {
                    $next = function ($request) use ($middleware, $next) {
                        return $middleware($request, $next);
                    };
                }
                $next(['uri' => $uri, 'method' => $method]);
                return;
            }
        }
        throw new \RuntimeException('Route not found');
    }
}

// Использование
$router = new Router();
$router->group(['prefix' => '/admin', 'middleware' => ['AuthMiddleware']], function ($r) {
    $r->add('GET', '/dashboard', function ($req) { echo 'Admin dashboard'; });
});
$router->add('GET', '/', function ($req) { echo 'Home'; });
try {
    $router->dispatch('GET', '/admin/dashboard');
} catch (\RuntimeException $e) {
    echo '404';
}

Результат: при запросе GET /admin/dashboard будет выполнен AuthMiddleware, затем обработчик. Без авторизации можно выдать перенаправление.

Результат (при отсутствии авторизации):
// Допустим, AuthMiddleware перенаправляет на /login
// Вывод может быть пустым или 302 редирект

Создание контейнера с поддержкой фабрик и псевдонимов

Расширенная версия DI-контейнера включает регистрацию фабрик, общих экземпляров (singleton) и псевдонимов.

class Container
{
    private array $definitions = [];
    private array $shared = [];
    private array $aliases = [];

    public function set(string $id, $definition, bool $shared = false): void
    {
        if (is_string($definition) && class_exists($definition)) {
            $definition = function (Container $c) use ($definition) {
                return $c->build($definition);
            };
        }
        $this->definitions[$id] = ['factory' => $definition, 'shared' => $shared];
    }

    public function alias(string $alias, string $original): void
    {
        $this->aliases[$alias] = $original;
    }

    public function get(string $id)
    {
        $id = $this->aliases[$id] ?? $id;
        if (isset($this->shared[$id])) {
            return $this->shared[$id];
        }
        if (!isset($this->definitions[$id])) {
            return $this->build($id); // autowire
        }
        $obj = call_user_func($this->definitions[$id]['factory'], $this);
        if ($this->definitions[$id]['shared']) {
            $this->shared[$id] = $obj;
        }
        return $obj;
    }

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

// Пример использования
$container = new Container();
$container->set(LoggerInterface::class, function () {
    return new FileLogger('/var/log/app.log');
}, shared: true);
$container->alias('logger', LoggerInterface::class);

$service = $container->get('logger'); // получит один экземпляр

Результат: объект FileLogger, при повторном вызове get вернётся тот же экземпляр.

Реализация PSR-7 middleware pipeline

Продемонстрируем собственный pipeline для обработки HTTP запросов через middleware.

use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;

interface MiddlewareInterface
{
    public function process(ServerRequestInterface $request, callable $next): ResponseInterface;
}

class Pipeline
{
    private array $middlewares = [];

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

    public function run(ServerRequestInterface $request, callable $coreHandler): ResponseInterface
    {
        $stack = array_reverse($this->middlewares);
        $next = $coreHandler;
        foreach ($stack as $middleware) {
            $next = function (ServerRequestInterface $req) use ($middleware, $next) {
                return $middleware->process($req, $next);
            };
        }
        return $next($request);
    }
}

// Пример middleware
class AuthMiddleware implements MiddlewareInterface
{
    public function process(ServerRequestInterface $request, callable $next): ResponseInterface
    {
        if (!isset($request->getCookieParams()['token'])) {
            return new Response(401, [], 'Unauthorized');
        }
        return $next($request);
    }
}

// Использование
$pipeline = new Pipeline();
$pipeline->add(new AuthMiddleware());
$request = new \Laminas\Diactoros\ServerRequest();
$response = $pipeline->run($request, function ($req) {
    return new Response(200, [], 'OK');
});

Результат: если нет cookie token, ответ 401, иначе 200.