O padrão MVC é muito comum na arquitetura de sites. Ele nos permite construir um aplicativo de três camadas, separando camadas úteis do código, ajudando designers e desenvolvedores a trabalharem juntos e melhorando nossa capacidade de manter e estender aplicativos existentes.
Visualizar
"Visualizar" refere-se principalmente ao resultado final que enviamos ao navegador da web - como o HTML gerado pelo nosso script. Ao falar sobre visualizações, muitas pessoas pensam em modelos, mas a correção de chamar visualizações de soluções de modelo é questionável.
Provavelmente a coisa mais importante sobre uma visão é que ela deve ser "autoconsciente". Quando a visão é renderizada, seus elementos estão cientes de seu papel na estrutura mais ampla.
Tomando o XML como exemplo, pode-se dizer que quando o XML é analisado, a API do DOM possui tal conhecimento que um nó na árvore do DOM sabe onde ele está e o que contém. (Quando um nó em um documento XML é analisado com SAX, só faz sentido quando o nó é analisado.)
A maioria dos esquemas de modelo usa linguagens procedurais simples e tags de modelo como esta:
<p>{some_text}</p ＞
＜p＞{some_more_text}＜/p＞
Eles não têm significado no documento, tudo o que significam é que o PHP irá substituí-lo por outra coisa.
Se você concorda com esta descrição vaga de visualizações, também concordará que a maioria das soluções de modelo não separa efetivamente visualizações e modelos. A tag do modelo será substituída por tudo o que estiver armazenado no modelo.
Faça algumas perguntas a si mesmo ao implementar a visualização: "É fácil substituir a visualização inteira?" "Quanto tempo leva para implementar uma nova visualização?" "É fácil substituir a linguagem de descrição da visualização? (Por exemplo, usando SOAP na mesma visualização Documento substitui documento HTML)"
Modelo (Modelo)
O modelo representa a lógica do programa. (Muitas vezes chamada de camada de negócios em programas de nível empresarial)
Em geral, a tarefa do modelo é converter os dados originais em dados que contenham algum significado, que serão exibidos pela visualização. Normalmente, o modelo encapsulará consultas de dados, talvez por meio de alguma classe de dados abstrata (camada de acesso a dados) para implementar a consulta. Por exemplo, se você deseja calcular a precipitação anual no Reino Unido (apenas para encontrar um bom local para férias), o modelo receberá a precipitação diária durante dez anos, calculará a média e a transmitirá à visualização.
Controlador (controlador)
significa simplesmente que o controlador é a primeira parte da solicitação HTTP recebida no aplicativo da web. Ele verifica a solicitação recebida, como algumas variáveis GET, e faz o feedback apropriado. É difícil começar a escrever outro código PHP até escrever seu primeiro controlador. O uso mais comum é uma estrutura como a instrução switch em index.php:
<?php
switch ($_GET['visualização']) {
caso "notícias":
$page=new NewsRenderer;
quebrar;
caso "links":
$page=new LinksRenderer;
quebrar;
padrão:
$page=new HomePageRenderer;
quebrar;
}
$página->exibição();
?>
Esse código mistura código processual e orientado a objetos, mas para sites pequenos, essa geralmente é a melhor escolha. Embora o código acima ainda possa ser otimizado.
Os controladores são, na verdade, controles usados para acionar ligações entre os dados do modelo e os elementos de visualização.
Exemplo
Aqui está um exemplo simples usando o padrão MVC.
Primeiro precisamos de uma classe de acesso ao banco de dados, que é uma classe comum.
<?php
/**
* Uma classe simples para consultar MySQL
*/
classe Acesso a dados {
/**
*Privado
* $db armazena um recurso de banco de dados
*/
var $db;
/**
*Privado
* $query armazena um recurso de consulta
*/
var $query; // Recurso de consulta
//!
/**
* Constrói um novo objeto DataAccess
* @param $host string nome do host para dbserver
* @param $user string usuário do servidor de banco de dados
* @param $pass string senha do usuário dbserver
* @param $db string nome do banco de dados
*/
function DataAccess ($host,$usuário,$pass,$db) {
$this->db=mysql_pconnect($host,$usuário,$pass);
mysql_select_db($db,$this->db);
}
//! Um acessador
/**
* Busca recursos de consulta e os armazena em um membro local
* @param $sql string a consulta ao banco de dados a ser executada
* @return nulo
*/
função buscar($sql) {
$this->query=mysql_unbuffered_query($sql,$this->db); // Execute a consulta aqui;
}
//! Um acessador
/**
* Retorna um array associativo de uma linha de consulta
* @return misto
*/
function getRow() {
if ($row=mysql_fetch_array($this->query,MYSQL_ASSOC) )
return $linha;
outro
retornar falso;
}
}
?＞
Coloque o modelo em cima dele.
<?php
/**
* Busca "produtos" do banco de dados
*/
classe ProdutoModelo {
/**
*Privado
* $dao uma instância da classe DataAccess
*/
var $dao;
//!Um construtor.
/**
* Constrói um novo objeto ProductModel
* @param $dbobject uma instância da classe DataAccess
*/
function ModeloProduto (&$dao) {
$this-＞dao=& $dao;
}
//! Um manipulador
/**
* Diz ao $dboject para armazenar esta consulta como um recurso
* @param $start a linha a partir da qual começar
* @param $rows o número de linhas a serem buscadas
* @return nulo
*/
function listaProdutos($start=1,$rows=50) {
$this->dao->fetch("SELECT * FROM produtos LIMIT ".$start.", ".$rows);
}
//! Um manipulador
/**
* Diz ao $dboject para armazenar esta consulta como um recurso
* @param $id uma chave primária para uma linha
* @return nulo
*/
function listaProduto($id) {
$this->dao->fetch("SELECT * FROM produtos WHERE PRODUCTID='".$id."'");
}
//! Um manipulador
/**
* Busca um produto como um array associativo do $dbobject
* @return misto
*/
function getProduto() {
if ($produto=$this->dao->getRow() )
retornar $produto;
outro
retornar falso;
}
}
?>
Uma coisa a notar é que a interação entre o modelo e a classe de acesso a dados nunca é superior a uma linha - nenhuma linha múltipla é enviada, o que tornará o programa rapidamente lento. O mesmo programa só precisa reter uma linha (Row) na memória para a classe que usa o esquema - o restante é dado ao recurso de consulta salvo (recurso de consulta) - em outras palavras, deixamos o MYSQL manter os resultados para nós.
A seguir vem a view - removi o HTML para economizar espaço, você pode conferir o código completo neste post.
<?php
/**
* Vincula dados do produto à renderização HTML
*/
classe ProdutoView {
/**
*Privado
* $model uma instância da classe ProductModel
*/
var $modelo;
/**
*Privado
* $output HTML renderizado é armazenado aqui para exibição
*/
var $saída;
//! Um construtor.
/**
* Constrói um novo objeto ProductView
* @param $model uma instância da classe ProductModel
*/
função ProductView (&$model) {
$this->model=& $model;
}
//! Um manipulador
/**
* Constrói o topo de uma página HTML
* @return nulo
*/
function header() {
}
// Um manipulador
/**
* Constrói a parte inferior de uma página HTML
* @return nulo
*/
function footer() {
}
// Um manipulador
/**
* Exibe um único produto
* @return nulo
*/
function itemproduto($id=1) {
$this->model->listProduct($id);
while ($produto=$este->modelo->getProduto()) {
// Vincula dados ao HTML
}
}
//! Um manipulador
/**
* Constrói uma tabela de produtos
* @return nulo
*/
function tabelaproduto($rownum=1) {
$rowsperpage='20';
$this->model->listProducts($rownum,$rowsperpage);
while ($produto=$este->modelo->getProduto()) {
// Vincula dados ao HTML
}
}
//! Um acessador
/**
* Retorna o HTML renderizado
* @return string
*/
exibição de função () {
retorne $isto->saída;
}
}
?＞
Resumo: O padrão MVC é muito comum na arquitetura de sites. Ele nos permite construir um aplicativo de três camadas, separando camadas úteis do código, ajudando designers e desenvolvedores a trabalharem juntos e melhorando nossa capacidade de manter e estender aplicativos existentes. Este artigo apresentará a implementação do padrão MVC em PHP.
Tags: PHP MVC Padrão MVC Site PHP
A Oracle ajuda você a obter insights precisos sobre cada link logístico
Oracle ajuda você a obter uma visão precisa de cada link logístico. Finalmente, o controlador, implementaremos a visão como uma subclasse.
<?php
/**
* Controla o aplicativo
*/
class ProductController estende ProductView {
//! Um construtor.
/**
* Constrói um novo objeto ProductController
* @param $model uma instância da classe ProductModel
* @param $getvars as variáveis do método HTTP GET de entrada
*/
função ProductController (&$model,$getvars=null) {
ProductView::ProductView($model);
$this->header();
switch ( $getvars['view'] ) {
caso "produto":
$this->productItem($getvars['id']);
quebrar;
padrão:
if (vazio ($getvars['rownum'])) {
$this->productTable();
} outro {
$this->productTable($getvars['rownum']);
}
quebrar;
}
$this->rodapé();
}
}
?＞
Observe que esta não é a única maneira de implementar MVC - por exemplo, você pode usar controladores para implementar modelos e integrar visualizações ao mesmo tempo. Esta é apenas uma maneira de demonstrar o padrão.
Nosso arquivo index.php se parece com isto:
<?php
require_once('lib/DataAccess.php');
require_once('lib/ProductModel.php');
require_once('lib/ProductView.php');
require_once('lib/ProductController.php');
$dao=& new DataAccess ('localhost','usuário','pass','dbname');
$productModel=& new ProductModel($dao);
$productController=& novo ProductController($productModel,$_GET);
echo $productController->display();
?＞
Bonito e simples.
Temos alguns truques para usar controladores, em PHP você pode fazer isso:
$this->{$_GET['method']}($_GET['param'])
; (namespace), então ele ficará mais padronizado, por exemplo:
"index.php?class=ProductView&method=productItem&id=4"
Através dele podemos processar nosso controlador assim:
$view=new $_GET['class'];
$view->{$_GET['method']($_GET['id']);
Às vezes, construir um controlador é difícil, como quando você negocia velocidade de desenvolvimento e adaptabilidade. Um bom lugar para se inspirar é o Java Struts do grupo Apache, cujos controladores são inteiramente definidos por documentos XML.