.jpg)
Seja muito bem-vindo à Academy Code Christ!
🌍 Academy Code Christ está disponível em vários idiomas.Fique à vontade para usar o tradutor na Barra lateral (Sidebar) e aprender no seu idioma.
PHP 🐘 Etapa 11
Arquitetura MVC e Organização
%20-%20Copia.png)
.png)
💻 Pratique o que você aprende
.png)
🎯 Por que Precisamos de Organização
Nas etapas anteriores, você aprendeu a criar sistemas que
funcionam.
Mas conforme o projeto cresce, surgem
problemas:
● Códigos HTML, PHP e SQL misturados no mesmo arquivo;
● Dificuldade em localizar erros;
● Dificuldade em adicionar novas funcionalidades sem quebrar o que já existe;
● Pouca possibilidade de reaproveitamento do código.
Esses pontos afetam a manutenibilidade e a escalabilidade do sistema.
Por isso, desenvolvedores profissionais adotam padrões de arquitetura — formas inteligentes de dividir um projeto em partes bem definidas. O mais popular deles é o MVC.
O Que é o Padrão MVC
MVC significa Model – View – Controller (Modelo –
Visão – Controlador).
Ele separa a aplicação em três
camadas independentes, cada uma com responsabilidades específicas:
|
Camada |
Função |
|
Model |
Lida com dados e regras de negócio (banco de dados, cálculos, validações). |
|
View |
Cuida da apresentação ao usuário (interface, HTML, CSS). |
|
Controller |
Faz a conexão entre Model e View. Recebe requisições, decide as ações e envia respostas. |
Essa separação traz flexibilidade e clareza: o código fica modular, limpo e fácil de testar.
Analogias para Entender o MVC
Imagine um restaurante:
● O Cliente (usuário) faz um pedido (requisição).
● O Garçom (Controller) recebe o pedido e leva para a Cozinha (Model), que prepara a comida.
● Depois, o garçom entrega o prato ao cliente, arrumado no Prato (View).
Cada parte cumpre um papel distinto. O garçom não cozinha, e a cozinha não fala diretamente com o cliente — exatamente como no MVC.
Estrutura Básica de Pastas em MVC
Um projeto organizado em MVC normalmente segue esta estrutura:
meu_sistema/
│
├── index.php
├── .htaccess
│
├── app/
│ ├── controllers/
│ │ └── UsuarioController.php
│ ├── models/
│ │ └── Usuario.php
│ └── views/
│ ├── usuario/
│ │ ├── listar.php
│ │ └── cadastrar.php
│ └── layout.php
│
└── config/
└── conexao.php
Essa hierarquia cria modularidade.
Cada camada possui arquivos separados e
especializados.
O Papel do index.php
O index.php
é o ponto de entrada único da aplicação — todas as requisições passam
por ele.
Ele analisa a URL, decide qual controlador
chamar e qual ação executar.
Exemplo simples:
<?php
require_once "config/conexao.php";
$controller = isset($_GET["controller"]) ? $_GET["controller"] : "usuario";
$action = isset($_GET["action"]) ? $_GET["action"] : "listar";
$controllerClass = ucfirst($controller) . "Controller";
require_once "app/controllers/$controllerClass.php";
$objController = new $controllerClass();
$objController->$action();
?>
Se a URL for index.php?controller=usuario&action=cadastrar, o sistema automaticamente chama:
● UsuarioController
● método cadastrar()
Essa abordagem é chamada de roteamento simples, e é o coração de qualquer framework MVC.
Criando o Model (Modelo)
O Model é responsável por acessar o banco de dados e representar as entidades do sistema.
Arquivo: app/models/Usuario.php
<?php
class Usuario {
private $pdo;
public function __construct($conexao) {
$this->pdo = $conexao;
}
public function listar() {
$sql = "SELECT * FROM usuarios";
return $this->pdo->query($sql)->fetchAll(PDO::FETCH_ASSOC);
}
public function inserir($nome, $email, $senha) {
$sql = "INSERT INTO usuarios (nome, email, senha) VALUES (?, ?, ?)";
$stmt = $this->pdo->prepare($sql);
$stmt->execute([$nome, $email, password_hash($senha, PASSWORD_DEFAULT)]);
}
public function buscar($id) {
$sql = "SELECT * FROM usuarios WHERE id = ?";
$stmt = $this->pdo->prepare($sql);
$stmt->execute([$id]);
return $stmt->fetch(PDO::FETCH_ASSOC);
}
public function excluir($id) {
$sql = "DELETE FROM usuarios WHERE id = ?";
$stmt = $this->pdo->prepare($sql);
$stmt->execute([$id]);
}
}
?>
O Model não se preocupa com HTML. Ele apenas fala com o banco e devolve dados prontos.
Criando o Controller
O Controller faz a ponte entre o usuário (interface) e os modelos de dados.
Arquivo: app/controllers/UsuarioController.php
<?php
require_once "app/models/Usuario.php";
class UsuarioController {
private $usuarioModel;
public function __construct() {
include "config/conexao.php";
$this->usuarioModel = new Usuario($pdo);
}
public function listar() {
$usuarios = $this->usuarioModel->listar();
include "app/views/usuario/listar.php";
}
public function cadastrar() {
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$nome = $_POST["nome"];
$email = $_POST["email"];
$senha = $_POST["senha"];
$this->usuarioModel->inserir($nome, $email, $senha);
header("Location: index.php?controller=usuario&action=listar");
} else {
include "app/views/usuario/cadastrar.php";
}
}
public function excluir() {
if (isset($_GET["id"])) {
$id = $_GET["id"];
$this->usuarioModel->excluir($id);
header("Location: index.php?controller=usuario&action=listar");
}
}
}
?>
O Controller decide:
● Qual método do modelo chamar;
● Qual visão (view) será mostrada.
Criando as Views
As Views são arquivos HTML/PHP que mostram dados para o usuário.
Arquivo: app/views/usuario/listar.php
<!DOCTYPE html>
<html>
<head>
<title>Lista de Usuários</title>
</head>
<body>
<h3>Usuários Cadastrados</h3>
<a href="index.php?controller=usuario&action=cadastrar">Cadastrar Novo</a>
<hr>
<?php foreach ($usuarios as $u): ?>
<p><?= $u["nome"] ?> - <?= $u["email"] ?>
<a href="index.php?controller=usuario&action=excluir&id=<?= $u["id"] ?>">Excluir</a></p>
<?php endforeach; ?>
</body>
</html>
Arquivo: app/views/usuario/cadastrar.php
<!DOCTYPE html>
<html>
<head>
<title>Cadastrar Usuário</title>
</head>
<body>
<h3>Novo Usuário</h3>
<form method="POST" action="index.php?controller=usuario&action=cadastrar">
Nome: <input type="text" name="nome"><br>
Email: <input type="email" name="email"><br>
Senha: <input type="password" name="senha"><br>
<input type="submit" value="Cadastrar">
</form>
</body>
</html>
Perceba que a View não possui código de banco nem lógica de controle — apenas exibe o que o controller enviou.
A Importância do layout.php
Para evitar repetição de cabeçalho, rodapé e estilos, normalmente criamos um layout principal.
Arquivo: app/views/layout.php
<!DOCTYPE html>
<html>
<head>
<title><?= $titulo ?? "Sistema PHP MVC" ?></title>
<style>
body { font-family: Arial; margin: 30px; }
header { background: #008CBA; color: white; padding: 10px; }
footer { background: #efefef; text-align:center; padding:5px; margin-top:20px; }
</style>
</head>
<body>
<header><h2>Sistema MVC</h2></header>
<main>
<?php include $pagina; ?>
</main>
<footer>Desenvolvido em PHP Moderno</footer>
</body>
</html>
Agora em cada controller, basta definir qual conteúdo vai dentro:
$titulo = "Lista de Usuários";
$pagina = "app/views/usuario/listar.php";
include "app/views/layout.php";
Isso cria consistência visual entre as páginas.
Benefícios Concretos do MVC
1. Código Limpo e Organizado — HTML, regras e SQL em locais separados.
2. Fácil Manutenção — mudar o layout não afeta a lógica.
3. Reutilização — os modelos podem ser reutilizados por outras partes do sistema.
4. Escalabilidade — é possível adicionar novos módulos sem refazer toda a base.
5. Segurança — o Controller filtra requisições antes de passar para o banco.
É exatamente assim que frameworks como Laravel, CodeIgniter e Symfony funcionam.
MVC na Prática — Fluxo de Execução
1. O usuário acessa index.php?controller=usuario&action=listar;
2. O index.php invoca UsuarioController → método listar();
3. O Controller pede ao Usuario (Model) os dados do banco;
4. O Controller envia os dados para a View;
5. A View exibe o conteúdo dentro do layout.
Esse fluxo garante separação lógica e clareza.
Dicas Profissionais de Organização
✅
Padronize nomes (Ex: UsuarioController → Usuario.php → pasta usuario).
✅ Use comentários claros em cada função.
✅ Centralize configurações no diretório config/.
✅ Evite HTML dentro de Models e
Controllers.
✅ Utilize require_once em vez de include
para evitar duplicações.
✅ Crie pastas específicas para assets (CSS, JS, imagens).
✅ Use namespaces (versões mais modernas
do PHP).
MVC + PDO = Sistema Escalável
Juntando o design MVC com as operações PDO dos capítulos anteriores, você obtém um sistema robusto com:
● Segurança contra injeções SQL;
● Reuso de funções e queries;
● Facilidade de integração com bibliotecas externas;
● Organização modular voltada à expansão.
Isso é o ponto de partida para aplicações profissionais de verdade.
Próximo Passo: Frameworks PHP
Após dominar o MVC manualmente, você poderá facilmente aprender frameworks modernos como:
● Laravel (o mais popular e completo);
● CodeIgniter (leve e fácil de aprender);
● Symfony (robusto e corporativo).
Esses frameworks automatizam tudo que você fez aqui: roteamento, conexão, templates, segurança, e muito mais.
Porém, entender o MVC “na unha” é essencial antes de usá-los — e você acabou de aprender isso agora. ✅
Conclusão
Nesta etapa, você aprendeu a organizar seu projeto PHP com a arquitetura MVC, separando responsabilidades de forma clara e profissional.
Você viu:
● O conceito e a importância da arquitetura MVC;
● Como estruturar pastas e arquivos;
● Como criar Models para acessar dados, Controllers para coordenar ações e Views para apresentar a interface;
● A importância dos layouts e boas práticas de organização;
● Como essa abordagem serve de base para qualquer framework moderno.
Agora você tem o domínio conceitual e técnico de como construir, expandir e manter um sistema PHP real, pronto para crescer com segurança e clareza.
🚀 Próximo Passo – Trabalhando com
Uploads, Imagens e Manipulação de Arquivos no PHP
Na próxima etapa, aprenderemos a integrar o MVC com upload e gerenciamento de conteúdo de mídia, fazendo seu sistema lidar com arquivos, fotos e documentos de forma eficiente e segura.
.png)
.png)
Postar um comentário