Современный PHP: статический анализ, типизация и фреймворки без ORM — как изменилась архитектура в 2026 году

<?php

// Векторное хранилище для AI-приложений
class VectorUserRepository {
    public function __construct(
        private VectorStore $vectorStore,
        private EmbeddingGenerator $embedder
    ) {}
    
    public function findSimilar(
        User $user, 
        int $limit = 10
    ): array {
        // Генерация embedding пользователя
        $embedding = $this->embedder->embed($user);
        
        // Поиск похожих в векторной БД
        return $this->vectorStore->similaritySearch(
            embedding: $embedding,
            namespace: 'users',
            limit: $limit,
            filter: ['active' => true]
        );
    }
}

// GraphQL-нативное хранилище
class GraphQLProductRepository {
    public function __construct(
        private GraphQLClient $client
    ) {}
    
    public function getProductsWithStock(): array {
        // Нативный GraphQL запрос с типизацией
        $query = '''
            query GetProductsWithStock {
                products(where: { stock: { gt: 0 } }) {
                    id
                    name
                    price
                    stock
                    category {
                        id
                        name
                    }
                }
            }
        ''';
        
        return $this->client->execute($query);
    }
}

// Event-sourced хранилище
class EventSourcedOrderRepository {
    public function __construct(
        private EventStore $eventStore
    ) {}
    
    public function save(Order $order): void {
        // Сохраняем не состояние, а события
        $events = $order->flushEvents();
        
        $this->eventStore->append(
            streamId: "order-{$order->id}",
            events: $events
        );
    }
    
    public function load(string $orderId): Order {
        // Восстанавливаем состояние из событий
        $events = $this->eventStore->load("order-$orderId");
        
        return Order::reconstitute($events);
    }
}

Архитектурные паттерны 2026

4.1 Гексагональная архитектура с type-safe портами

<?php

// Порты определяются как интерфейсы с типами
interface UserRepository {
    public function findById(UserID $id): ?User;
    public function findByEmail(EmailAddress $email): ?User;
    public function save(User $user): void;
}

interface EmailService {
    public function sendWelcomeEmail(User $user): void;
    public function sendPasswordReset(EmailAddress $email): void;
}

// Адаптеры реализуют порты
class PostgreSQLUserRepository implements UserRepository {
    public function __construct(
        private Connection $connection,
        private QueryCompiler $compiler
    ) {}
    
    public function findById(UserID $id): ?User {
        $query = $this->compiler->compile(
            'SELECT * FROM users WHERE id = :id',
            ['id' => $id->value()]
        );
        
        $row = $this->connection->execute($query)->fetch();
        
        return $row ? User::fromRow($row) : null;
    }
}

// Use case (ядро приложения) зависит только от портов
class RegisterUserUseCase {
    public function __construct(
        private UserRepository $users,
        private EmailService $email,
        private PasswordHasher $hasher
    ) {}
    
    public function execute(RegisterUserCommand $command): UserID {
        // Валидация через типы
        $email = EmailAddress::fromString($command->email);
        $password = HashedPassword::fromPlain($command->password);
        
        // Проверка существования
        if ($this->users->findByEmail($email)) {
            throw new UserAlreadyExists();
        }
        
        // Создание пользователя
        $user = User::create(
            name: $command->name,
            email: $email,
            password: $password
        );
        
        // Сохранение
        $this->users->save($user);
        
        // Отправка email
        $this->email->sendWelcomeEmail($user);
        
        return $user->id;
    }
}

4.2 CQRS с типизированными командами и запросами

<?php

// Команды и запросы как иммутабельные DTO
readonly class CreateProductCommand {
    public function __construct(
        public string $name,
        public Price $price,
        public ?string $description = null,
        public list<string> $tags = []
    ) {}
}

readonly class GetProductsQuery {
    public function __construct(
        public ?string $category = null,
        public ?PriceRange $priceRange = null,
        public int $page = 1,
        public int $perPage = 25
    ) {}
}

// Handler'ы с строгой типизацией
class CreateProductHandler {
    public function __construct(
        private ProductRepository $products,
        private EventDispatcher $events
    ) {}
    
    public function handle(CreateProductCommand $command): ProductID {
        $product = Product::create(
            name: $command->name,
            price: $command->price,
            description: $command->description,
            tags: $command->tags
        );
        
        $this->products->save($product);
        $this->events->dispatch(new ProductCreated($product->id));
        
        return $product->id;
    }
}

// Автоматическая диспетчеризация через атрибуты
#[CommandHandler]
class UpdateProductHandler {
    public function handle(UpdateProductCommand $command): void {
        // ...
    }
}

#[QueryHandler]
class GetProductsHandler {
    public function handle(GetProductsQuery $query): Paginated<ProductDTO> {
        // ...
    }
}

Заключение

2026 год стал точкой, где PHP окончательно сбросил ярлык «скриптового языка для начинающих». Благодаря революции в статическом анализе, продвинутой системе типов и отказу от компромиссных решений вроде универсальных ORM, PHP теперь конкурирует с TypeScript, Go и Java в enterprise-разработке.