Desenvolver sistemas de rotas do zero é um dos passos mais importantes para entender como os grandes frameworks (como Laravel e Symfony) funcionam por baixo dos panos. Quando deixamos de depender de arquivos físicos como contato.php ou produto.php e passamos a usar URLs amigáveis como /contato ou /produto/12, ganhamos total controle sobre a arquitetura da nossa aplicação.

Abaixo, vamos construir um Sistema de Rotas Simples e Eficiente em PHP, utilizando o padrão MVC (Model-View-Controller), conexão via PDO e Programação Orientada a Objetos (POO).

1. A Estrutura do Projeto

Para manter o código organizado e escalável, utilizaremos a seguinte estrutura de pastas e arquivos no ecossistema:

projeto-rotas/
├── Config/
│   └── Database.php
├── Controllers/
│   └── HomeController.php
├── Views/
│   └── home.php
├── Core/
│   └── Router.php
├── .htaccess
└── index.php

2. Configurando o Servidor (.htaccess)

O primeiro segredo para mapear rotas é redirecionar todas as requisições da URL para um único arquivo centralizador: o index.php. No Apache, fazemos isso utilizando o arquivo de configuração dinâmica de diretórios.

RewriteEngine On

# Impede que o Apache redirecione se o arquivo ou diretório físico existir
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d

# Redireciona tudo para o index.php passando a URL como parâmetro
RewriteRule ^(.*)$ index.php?url=$1 [QSA,L]

3. A Conexão com o Banco de Dados (Config/Database.php)

Para garantir que o projeto esteja preparado para a persistência e manipulação estruturada de dados, criamos uma classe de conexão utilizando PDO com o padrão Singleton para garantir uma instância única de conexão.

<?php
namespace Config;

use PDO;
use PDOException;

class Database {
    private static $instance = null;

    public static function getConnection() {
        if (!self::$instance) {
            try {
                $host = 'localhost';
                $dbname = 'seu_banco_de_dados';
                $username = 'root';
                $password = '';

                self::$instance = new PDO(
                    "mysql:host=$host;dbname=$dbname;charset=utf8mb4",
                    $username,
                    $password,
                    [
                        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
                        PDO::ATTR_EMULATE_PREPARES => false,
                    ]
                );
            } catch (PDOException $e) {
                die("Erro na conexão com o banco: " . $e->getMessage());
            }
        }
        return self::$instance;
    }
}

4. O Coração do Sistema: O Roteador (Core/Router.php)

A classe Router será responsável por registrar de forma dinâmica as rotas permitidas na aplicação e identificar qual Controller e Método devem ser acionados com base na requisição atual.

<?php
namespace Core;

class Router {
    private $routes = [];

    public function get($path, $callback) {
        $this->routes['GET'][$path] = $callback;
    }

    public function post($path, $callback) {
        $this->routes['POST'][$path] = $callback;
    }

    public function run() {
        $method = $_SERVER['REQUEST_METHOD'];
        $url = isset($_GET['url']) ? '/' . rtrim($_GET['url'], '/') : '/';

        if (isset($this->routes[$method][$url])) {
            $callback = $this->routes[$method][$url];

            if (is_string($callback)) {
                $parts = explode('@', $callback);
                $controllerName = "\\Controllers\\" . $parts[0];
                $methodName = $parts[1];

                if (class_exists($controllerName)) {
                    $controller = new $controllerName();
                    if (method_exists($controller, $methodName)) {
                        $controller->$methodName();
                        return;
                    }
                }
            }
        }

        http_response_code(404);
        echo "<h1>Erro 404 - Página Não Encontrada</h1>";
    }
}

5. Criando o Controlador e a View (Camada MVC)

Agora definimos a lógica visual e de controle com o HomeController.php, que processará a requisição da rota e chamará a View adequada para renderização.

Controllers/HomeController.php

<?php
namespace Controllers;

use Config\Database;

class HomeController {
    public function index() {
        $title = "Página Inicial";
        require_once __DIR__ . '/../Views/home.php';
    }
}

Views/home.php

<!DOCTYPE html>
<html lang="pt-br">
<head>
    <meta charset="UTF-8">
    <title><?php echo $title; ?></title>
</head>
<body>
    <h1>Bem-vindo ao nosso sistema de rotas próprio!</h1>
    <p>Esta página foi renderizada através do HomeController.</p>
</body>
</html>

6. O Ponto de Entrada (index.php)

Para finalizar, configuramos o arquivo index.php na raiz do projeto. Ele realiza o carregamento automático de todas as classes via Namespaces (Autoload) e instancia o roteador mapeando os caminhos da aplicação.

<?php
spl_autoload_register(function ($class) {
    $file = __DIR__ . '/' . str_replace('\\', '/', $class) . '.php';
    if (file_exists($file)) {
        require_once $file;
    }
});

use Core\Router;

$router = new Router();
$router->get('/', 'HomeController@index');
$router->run();

Conclusão

Criar um sistema de rotas do plano conceitual elimina a opacidade estrutural e desmistifica o funcionamento interno dos frameworks modernos. Com poucas linhas de código, organizamos uma arquitetura robusta baseada em POO, pronta para operações seguras via PDO e segregada sob os princípios de responsabilidade única do padrão MVC.