El patrón MVC es muy común en la arquitectura de sitios web. Nos permite crear una aplicación de tres niveles, separando las capas útiles del código, ayudando a los diseñadores y desarrolladores a trabajar juntos y mejorando nuestra capacidad para mantener y ampliar las aplicaciones existentes.
Ver
"Ver" se refiere principalmente al resultado final que enviamos al navegador web, como el HTML generado por nuestro script. Cuando se habla de vistas, mucha gente piensa en plantillas, pero la exactitud de llamar vistas de soluciones de plantilla es cuestionable.
Probablemente lo más importante de una vista es que debe ser "consciente de sí misma". Cuando se representa la vista, sus elementos son conscientes de su papel en el marco más amplio.
Tomando XML como ejemplo, se puede decir que cuando se analiza XML, la API DOM tiene tal conocimiento que un nodo en el árbol DOM sabe dónde está y qué contiene. (Cuando un nodo en un documento XML se analiza con SAX, solo tiene sentido cuando se analiza el nodo).
La mayoría de los esquemas de plantilla utilizan lenguajes de procedimiento simples y etiquetas de plantilla como esta:
<p>{some_text}</p ＞
＜p＞{some_more_text}＜/p＞
No tienen ningún significado en el documento, lo único que quieren decir es que PHP lo reemplazará con otra cosa.
Si está de acuerdo con esta descripción vaga de las vistas, también estará de acuerdo en que la mayoría de las soluciones de plantilla no separan de manera efectiva las vistas y los modelos. La etiqueta de la plantilla se reemplazará con lo que esté almacenado en el modelo.
Hágase algunas preguntas mientras implementa la vista: "¿Es fácil reemplazar la vista completa?" "¿Cuánto tiempo lleva implementar una nueva vista?" "¿Es fácil reemplazar el lenguaje de descripción de la vista? (Por ejemplo, usando SOAP en la misma vista El documento reemplaza el documento HTML)"
Modelo (Modelo)
El modelo representa la lógica del programa. (A menudo llamada capa empresarial en programas de nivel empresarial)
En general, la tarea del modelo es convertir los datos originales en datos que contengan algún significado, que se mostrarán en la vista. Normalmente, el modelo encapsulará consultas de datos, quizás a través de alguna clase de datos abstractos (capa de acceso a datos) para implementar la consulta. Por ejemplo, si desea calcular la precipitación anual en el Reino Unido (solo para encontrar un buen lugar de vacaciones), el modelo recibirá la precipitación diaria durante diez años, calculará el promedio y lo pasará a la vista.
Controlador (controlador)
simplemente significa que el controlador es la primera parte de la solicitud HTTP entrante en la aplicación web. Comprueba la solicitud recibida, como algunas variables GET, y proporciona la respuesta adecuada. Es difícil empezar a escribir otro código PHP hasta que escriba su primer controlador. El uso más común es una estructura como la declaración de cambio en index.php:
<?php
cambiar ($_GET['viewpage']) {
caso "noticias":
$página=nuevo NewsRenderer;
romper;
caso "enlaces":
$página=nuevo LinksRenderer;
romper;
por defecto:
$page=new HomePageRenderer;
romper;
}
$página->mostrar();
?>
Este código combina código procedimental y orientado a objetos, pero para sitios pequeños, suele ser la mejor opción. Aunque el código anterior aún se puede optimizar.
Los controladores son en realidad controles utilizados para activar enlaces entre los datos del modelo y los elementos de vista.
Ejemplo
A continuación se muestra un ejemplo sencillo que utiliza el patrón MVC.
Primero necesitamos una clase de acceso a la base de datos, que es una clase ordinaria.
<?php
/**
* Una clase simple para consultar MySQL
*/
clase Acceso a datos {
/**
*Privado
* $db almacena un recurso de base de datos
*/
var$db;
/**
*Privado
* $query almacena un recurso de consulta
*/
var $consulta; // Consultar recurso
//!
/**
* Construye un nuevo objeto DataAccess
* @param $host cadena nombre de host para dbserver
* @param $usuario cadena dbserver usuario
* @param $pass string contraseña de usuario de dbserver
* @param $db nombre de la base de datos de cadena
*/
función Acceso a datos ($host,$usuario,$contraseña,$db) {
$this->db=mysql_pconnect($host,$usuario,$contraseña);
mysql_select_db($db,$this->db);
}
//! Un descriptor de acceso
/**
* Obtiene recursos de consulta y los almacena en un miembro local
* @param $sql cadena de la consulta de base de datos a ejecutar
* @retorno nulo
*/
función de búsqueda ($sql) {
$this->query=mysql_unbuffered_query($sql,$this->db); // Realizar consulta aquí
}
//! Un descriptor de acceso
/**
* Devuelve una matriz asociativa de una fila de consulta
* @retorno mixto
*/
función obtenerFila() {
si ( $fila=mysql_fetch_array($this->query,MYSQL_ASSOC) )
devolver $fila;
demás
devolver falso;
}
}
?＞
Pon el modelo encima.
<?php
/**
* Obtiene "productos" de la base de datos
*/
clase ProductoModelo {
/**
*Privado
* $dao una instancia de la clase DataAccess
*/
var $dao;
//! Un constructor.
/**
* Construye un nuevo objeto ProductModel
* @param $dbobject una instancia de la clase DataAccess
*/
función ProductoModel (&$dao) {
$this-＞dao=& $dao;
}
//! Un manipulador
/**
* Le dice al $dboject que almacene esta consulta como un recurso
* @param $iniciar la fila desde la que empezar
* @param $rows el número de filas a recuperar
* @retorno nulo
*/
lista de funcionesProductos($inicio=1,$filas=50) {
$this->dao->fetch("SELECT * FROM productos LIMIT ".$start.", ".$rows);
}
//! Un manipulador
/**
* Le dice al $dboject que almacene esta consulta como un recurso
* @param $id una clave principal para una fila
* @retorno nulo
*/
lista de funcionesProducto($id) {
$this->dao->fetch("SELECT * FROM productos DONDE PRODUCTID='".$id."'");
}
//! Un manipulador
/**
* Obtiene un producto como una matriz asociativa del $dbobject
* @retorno mixto
*/
función obtenerProducto() {
si ( $producto=$this->dao->getRow() )
devolver $producto;
demás
devolver falso;
}
}
?>
Una cosa a tener en cuenta es que la interacción entre el modelo y la clase de acceso a datos nunca es más de una línea; no se envían varias líneas, lo que ralentizará rápidamente el programa. El mismo programa solo necesita retener una fila (Fila) en la memoria para la clase que usa el esquema; el resto se entrega al recurso de consulta guardado (recurso de consulta); en otras palabras, dejamos que MYSQL mantenga los resultados por nosotros.
El siguiente paso es la vista: eliminé el HTML para ahorrar espacio; puedes consultar el código completo en esta publicación.
<?php
/**
* Vincula los datos del producto a la representación HTML
*/
clase VistaProducto {
/**
*Privado
* $model una instancia de la clase ProductModel
*/
var $modelo
/**
*Privado
* El HTML renderizado de $output se almacena aquí para su visualización.
*/
var $salida;
//! Un constructor.
/**
* Construye un nuevo objeto ProductView
* @param $model una instancia de la clase ProductModel
*/
función ProductView (&$modelo) {
$this->modelo=& $modelo;
}
//! Un manipulador
/**
* Construye la parte superior de una página HTML
* @retorno nulo
*/
encabezado de función () {
}
//! Un manipulador
/**
* Construye la parte inferior de una página HTML
* @retorno nulo
*/
pie de página de función () {
}
//! Un manipulador
/**
* Muestra un solo producto
* @retorno nulo
*/
función artículoproducto($id=1) {
$this->modelo->listProduct($id);
mientras ( $producto=$este->modelo->getProduct() ) {
// Vincular datos a HTML
}
}
//! Un manipulador
/**
* Construye una tabla de productos.
* @retorno nulo
*/
function tablaproducto($rownum=1) {
$rowsperpage='20';
$this->model->listProducts($rownum,$rowsperpage);
mientras ( $producto=$este->modelo->getProduct() ) {
// Vincular datos a HTML
}
}
//! Un descriptor de acceso
/**
* Devuelve el HTML renderizado
* @cadena de retorno
*/
visualización de funciones () {
devolver $this->salida;
}
}
?＞
Resumen: el patrón MVC es muy común en la arquitectura de sitios web. Nos permite crear una aplicación de tres niveles, separando las capas útiles del código, ayudando a los diseñadores y desarrolladores a trabajar juntos y mejorando nuestra capacidad para mantener y ampliar las aplicaciones existentes. Este artículo le presentará la implementación del patrón MVC en PHP.
Etiquetas: PHP MVC Patrón MVC Sitio web PHP
Oracle le ayuda a obtener información precisa sobre cada enlace logístico
Oracle le ayuda a obtener información precisa sobre cada enlace logístico. Finalmente, implementaremos la vista como una subclase del controlador.
<?php
/**
* Controla la aplicación
*/
clase ProductController extiende ProductView {
//! Un constructor.
/**
* Construye un nuevo objeto ProductController
* @param $model una instancia de la clase ProductModel
* @param $getvars las variables del método HTTP GET entrante
*/
función ProductController (&$model,$getvars=null) {
VistaProducto::VistaProducto($modelo);
$this->encabezado();
cambiar ( $getvars['vista'] ) {
caso "producto":
$this->productItem($getvars['id']);
romper;
por defecto:
si (vacío ($getvars['rownum'])) {
$this->productTable();
} demás {
$this->productTable($getvars['rownum']);
}
romper;
}
$this->pie de página();
}
}
?＞
Tenga en cuenta que esta no es la única forma de implementar MVC; por ejemplo, puede usar controladores para implementar modelos e integrar vistas al mismo tiempo. Esta es sólo una forma de demostrar el patrón.
Nuestro archivo index.php se ve así:
<?php
require_once('lib/DataAccess.php');
require_once('lib/ProductModel.php');
require_once('lib/ProductView.php');
require_once('lib/ProductController.php');
$dao=& nuevo DataAccess ('localhost','usuario','contraseña','dbname');
$productModel=& nuevo ProductoModel($dao);
$productController=& nuevo ProductoController($productModel,$_GET);
echo $productController->display();
?＞
Hermoso y simple.
Tenemos algunos trucos para usar controladores, en PHP puedes hacer esto:
$this->{$_GET['method']}($_GET['param'])
; (espacio de nombres), entonces estará más estandarizado, por ejemplo:
"index.php?class=ProductView&method=productItem&id=4"
A través de él podemos procesar nuestro controlador de esta manera:
$view=new $_GET['class'];
$view->{$_GET['method']($_GET['id']);
A veces, construir un controlador es difícil, como cuando se sacrifica velocidad de desarrollo y adaptabilidad. Un buen lugar para inspirarse son los Java Struts del grupo Apache, cuyos controladores están completamente definidos por documentos XML.