O padrão de design Page Controller é uma abordagem de arquitetura comum usada em sistemas baseados na web. Ele organiza o fluxo de controle dedicando um controlador específico para lidar com a lógica de uma página ou solicitação individual. Essa abordagem ajuda a isolar responsabilidades, tornando a base de código mais fácil de manter e evoluir.

O que é o controlador de página?

No padrão Page Controller, cada página (ou grupo de páginas com comportamento semelhante) possui seu próprio controlador, responsável por:

1. Tratamento da solicitação: Processamento de dados enviados pelo cliente.
2. Executando a lógica específica da página: Validando entradas, interagindo com modelos ou realizando cálculos.
3. Renderizando uma resposta: Passando os dados processados ​​para uma view (template) e retornando a resposta final ao cliente.

Vantagens do Padrão

1. Fluxo simples: cada página é mapeada para seu próprio controlador dedicado.
2. Separação de interesses: Cada controlador lida apenas com sua própria lógica.
3. Manutenção: alterações em uma página afetam apenas o controlador associado.
4. Escalabilidade: adicionar novas páginas é simples e não interrompe a funcionalidade existente.

Estrutura Básica

Uma implementação típica envolve os seguintes componentes:

• Controladores: arquivos PHP contendo lógica para páginas específicas.
• Rotas: um mecanismo de roteamento para mapear URLs para controladores.
• Visualizações: modelos usados ​​para renderizar a interface do usuário.

Fluxo

1. O cliente envia uma solicitação para um URL específico.
2. O sistema de roteamento identifica o controlador apropriado para a solicitação.
3. O controlador executa a lógica necessária e delega a renderização da resposta a uma visualização.
4. A visualização gera a saída final e a retorna ao cliente.

Exemplo de implementação

Estrutura do arquivo

/htdocs
    /src
        /Controllers
            HomeController.php
            AboutController.php
        /Services
            ViewRenderer.php
        /Views
            home.html.php
            about.html.php
    /public
        index.php
    /routes.php
    composer.json

Autocarregador

{
    "autoload": {
        "psr-4": {
            "App\\": "htdocs/"
        }
    }
}

composer dump-autoload

Modelo

Modelo para a página inicial e about.html.php.

    


    
= htmlspecialchars($title) ?>
    
= htmlspecialchars($content) ?>

ViewRenderer

namespace App\Services;

class ViewRenderer {

    public function render(string $view, array $data = []): void {
        extract($data); // Turns array keys into variables
        include __DIR__ . "/../../Views/{$view}.html.php";
    }
}

HomeController

Lida com a lógica da página inicial.

namespace App\Controllers;

use App\Services\ViewRenderer;

class HomeController {

    public function __construct(private ViewRenderer $viewRenderer)
    {
    }

    public function handleRequest(): void {
        $data = [
            'title' => 'Welcome to the Site',
            'content' => 'Homepage content.',
        ];

        $this->viewRenderer->render('home', $data);
    }
}

SobreControlador

Lida com a lógica da página "Sobre nós".

namespace App\Controllers;

use App\Services\ViewRenderer;

class AboutController
{

    public function __construct(private ViewRenderer $viewRenderer)
    {
    }

    public function handleRequest(): void {
        $data = [
            'title' => 'About Us',
            'content' => 'Information about the company.',
        ];

        $this->viewRenderer->render('about', $data);
    }
}

routes.php

Define mapeamentos de rotas para controladores.

use App\Controllers\HomeController;
use App\Controllers\AboutController;

// Define the routes in an associative array
return [
    '/' => HomeController::class,
    '/about' => AboutController::class,
];

index.php

O ponto de entrada do aplicativo.

require_once __DIR__ . '/../vendor/autoload.php';

use App\Services\ViewRenderer;

// Include the routes
$routes = require_once __DIR__ . '/../routes.php';

// Instantiate the view rendering service
$viewRenderer = new ViewRenderer();

// Get the current route from the request URI
$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

// Check if the route exists and resolve the controller
if (isset($routes[$requestUri])) {
    $controllerClass = $routes[$requestUri];
    $controller = new $controllerClass($viewRenderer);
    $controller->handleRequest();
} else {
    http_response_code(404);
    echo "Page not found.";
}

Prós e Contras

Vantagens

• Organização: os controladores são modulares, cada um lidando com uma página específica.
• Reutilização: as visualizações podem ser reutilizadas em diferentes controladores.
• Depuração: Os erros são mais fáceis de rastrear, pois cada página tem seu próprio controlador dedicado.

Desvantagens

• Aumento do número de controladores: Grandes projetos podem levar a uma proliferação de controladores, exigindo melhor organização.
• Duplicação de código: a lógica comum entre controladores pode ser repetida. Isso pode ser mitigado usando uma classe de controlador base.

Quando usar o padrão do controlador de página?

• Sistemas simples: ideal para aplicativos Web de pequeno e médio porte, onde cada página tem uma lógica específica.
• Projetos modulares: quando você deseja isolar a lógica para facilitar a manutenção.
• Sem frameworks: Ideal para projetos PHP sem frameworks robustos (como Laravel ou Symfony).

Para projetos mais complexos, onde há reutilização lógica significativa ou múltiplos pontos de entrada, padrões como Front Controller ou arquitetura MVC completa podem ser mais adequados.