Publicado em 7 de mai.

MVC - Páginas dinâmicas

olá povo, eu não utilizo frameworks (porque não sei por onde começar), então dei uma pesquisada na internet sobre criar um "mini-framework" em MVC, porém em todos que vi, as views repetiam muito, o que quero dizer é, em todas as views, tinha <html>, <head>, <body, chamadas de arquivos js e css, etc. eu em todos os projetos que faço utilizo uma tabela no banco de dados que armazena as páginas e seu respectivo diretório, e não repito o header e o footer, somente o conteúdo, um exemplo simples:

if(file_exists($db->dirpage($_GET['pagina']))
 include($db->dirpage($_GET['pagina']));

else include("404.php"); e nessa página tenho SOMENTE a box que irá variar conforme o parâmetro passado na URL, o ponto que quero chegar é, como não repetir elementos HTML "fixos" nas views do modelo MVC.Pensei de duas maneiras:

1 - Criar no diretório de views tres arquivos, header.php (tudo acima do body), cont-top.php (tudo abaixo do body até a box que varia o conteúdo), cont-bottom.php (tudo abaixo da box que varia conteúdo até </html>) e nas views chamar algo como:

www/app/views/alguma_pagina.php

include("header.php");
include("cont-top.php");
echo "Conteúdo da página";

include("cont-bottom.php"); 2 (acredito nao ser correto, por isso vim aqui) - na minha index, criar a index normalmente, não só aquele PHP, e onde o conteúdo varia dar o run(), algo assim:

www/index.php

<html>
...
<body>
...
<div id="conteudo">
<?php
$system = new System;
$system->run();
?>
</div>
...
</body>
</html>

alguém me dá uma luz ?

Discussão (1)

Entre ou cadastre-se para participar da discussão

Entrar Criar conta

Gabriel Heming· 7 de mai.

Hoje em dia, principalmente na questão do PHP, existe muita confusão entre a separação das camadas.

Muitos exemplos que você vai procurar tratam a view apenas como um template, usando aquele jargão de que "a view é somente aquilo que você visualiza", mas quem tratará o que o usuário deve visualizar? Não é de responsabilidade da view?

A resposta é simples: claro que é!

A view deve receber os objetos/entidades que deverão ser exibidos e, a partir de então, tratar de renderizar a página.

Por exemplo, já que você não quer um framework, você poderia utilizar um arquivo template.php, que contenha toda a estrutura HTML, carregar o arquivo em memória e renderizar o que você deseja dentro do template.

Claro que alguma template engine, como twig ou smarty, lhe facilitaria a vida e lhe entregaria poderosos recursos junto. Mas, no caso específico apenas de HTML, você poderia utilizar a biblioteca DOMDocument para inserir o html renderizado em um template. Vamos a um exemplo bem básico (e de certa forma besta).

Uma tela de boas vindas de um usuário em um template padrão:

template.php

<!DOCTYPE html>

<html lang="pt-br">
 <head>
 <title>Meu template padrão/title>
 </head>

 <body></body>
</html>

E eu quero dar boas vindas ao usuário logado:

Vamos a nossa entidade usuário bem simples (besta).

Model\Entity\Usuario

namespace Model\Entity;

class User {

 private $name;

 public function getNome() {
 return $this->name;
 }

 public function setName($name) {
 $this->nome = $name;
 }

}
 View\Home

namespace View;

classe Home {

 private $user;

 public function index(\Etity\User $user) {
 $this->user = $user;
 }

 public function show() {
 /** implementação omitida **/
 }
}

Pronto, temos nossos três participantes (não vou entrar em outras partes da exibição), vamos ao código de execução na parte do Model Controller.

O Model fica responsável pelas regras de negócio criando a entidade (sem muitos detalhes, apenas para fingir que está buscando no SGBD):

Model\User

namespace Model;

Class User
{
/ a função ignora a entrada do ID, é apenas para simular um SGBD /

 public function getUser(\int $id) : Entity\User
 {
 $user = new \Entity\User();
 $user->setName("Gabriel Heming");
 return $user;
 }
}

Por outro lado, o controller fica responsável pela interpretação da requisição (request) e pela "intermediação" entre os componentes.

Controller\Home

namespace Controller;
Class Home
{

 public function index()
 {
 $userModel = new \Model\User();
 $view = new \View\Home();
 $view->index($userModel->getUser(1));
 $view->show();
 }
}

É dessa forma que estou passando a entidade para a View e, através do método show, espero que a view seja renderizada.

Voltando a view, vamos a implementação do método show:

View\Home

namespace View;

classe Home {

 private $user;

 public function index(\Model\Etity\User $user) {
 /** implementação omitida **/
 }

 public function show() {
 $dom = new \DOMDocument();

 $dom->loadHTMLFile("source/para/template.php");

 $welcomeMessage = $dom->createElement('p' , sprintf("Seja bem vindo %s!" , $this->user->getName()));

 $bodyList = $dom->getElementsByTagName('body');
 foreach($bodyList AS $body) {
 $body->appendChild($welcomeMessage);
 }

 echo $dom->saveHTML();
 }
}

Saída:

>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">

<html lang="pt-br">

<head>

<title>Meu template padrão</title>

</head>

 

<body>

<p>Seja bem vindo Gabriel Heming!</p>

</body>

</html>

Infelizmente, DOMDocument trabalha internamente com html 4, removendo qualquer padrão externo que seja adicionado na hora do parser do arquivo. Mesmo assim, continua sendo um exemplo válido.

------

Edit:

Como eu criei tudo aqui, pode ser que haja algum erro nas entidades... eu fiz a exibição a parte.