JORGE DEAN MOCTEZUMA AMORO

PROGRAMACION IMPERATIVA
UNIVERSIDADAD AUTONOMA DE MEXICO
CU UAEM ECATEPEC
 ¿QUE ES?
El modelo de MVC le ayuda a crear aplicaciones que separan los diferentes
aspectos de la aplicación (lógica de entrada, lógica comercial y lógica de la
interfaz de usuario), a la vez que proporciona un vago acoplamiento entre estos
elementos. El modelo especifica dónde se debería encontrar cada tipo de lógica
en la aplicación. La lógica de la interfaz de usuario pertenece a la vista. La
lógica de entrada pertenece al controlador. La lógica de negocios pertenece al
modelo. Esta separación le ayuda a administrar la complejidad al compilar una
aplicación, ya que le permite centrarse en cada momento en un único aspecto
de la implementación. Por ejemplo, se puede centrar en la vista sin estar
condicionado por la lógica comercial. Además de administrar la complejidad, el
modelo de MVC hace que sea más fácil probar las aplicaciones que probar una
aplicación web ASP.NET basada en formularios Web Forms. Por ejemplo, en
una aplicación web ASP.NET basada en formularios Web Forms, se usa una
clase única para mostrar la salida y para responder a los datos proporcionados
por el usuario. Escribir pruebas automatizadas para las aplicaciones ASP.NET
basadas en formularios Web Forms puede ser complejo, ya que para probar
una página individual se deben crear instancias de la clase de página, todos sus
controles secundarios y las clases dependientes adicionales de la aplicación.

¿CUÁNDO SE USA?
Debe considerar cuidadosamente si desea implementar una aplicación web
mediante el marco de ASP.NET MVC o el modelo de formularios Web Forms
de ASP.NET. El marco de MVC no reemplaza el modelo de formularios Web
Forms; puede usar cualquiera de los dos marcos para las aplicaciones web. (Si
ya tiene aplicaciones basadas en formularios Web Forms, estas seguirán
funcionando exactamente igual que siempre).
Antes de decidir usar el marco de MVC o el modelo de formularios Web Forms
para un sitio web concreto, sopese las ventajas de cada método.

¿CUALES SON SUS VENTAJAS?

• Facilita la administración de la complejidad, al dividir una aplicación en
el modelo, la vista y el controlador.
 • No usa el estado de vista ni formularios basados en servidor. Esto hace
que el marco de MVC sea ideal para los desarrolladores que deseen un
control completo sobre el comportamiento de una aplicación.
• Usa un modelo de controlador frontal que procesa las solicitudes de la
aplicación web a través de un controlador único. Esto permite diseñar
una aplicación que admite una infraestructura de enrutamiento
avanzada. Para obtener más información, vea en el sitio web de MSDN.
• Proporciona una mayor compatibilidad con el desarrollo basado en
pruebas (TDD).
• Funciona bien para las aplicaciones web que son compatibles con
grandes equipos de desarrolladores y diseñadores web que necesitan un
alto grado de control sobre el comportamiento de la aplicación.

¿Por qué MVC?

La rama de la ingeniería del software se preocupa por crear procesos que
aseguren calidad en los programas que se realizan y esa calidad atiende a
diversos parámetros que son deseables para todo desarrollo, como la
estructuración de los programas o reutilización del código, lo que debe influir
positivamente en la facilidad de desarrollo y el mantenimiento.
Los ingenieros del software se dedican a estudiar de qué manera se pueden
mejorar los procesos de creación de software y una de las soluciones a las que
han llegado es la arquitectura basada en capas que separan el código en
función de sus responsabilidades o conceptos. Por tanto, cuando estudiamos
MVC lo primero que tenemos que saber es que está ahí para ayudarnos a
crear aplicaciones con mayor calidad.

MODELOS
Es la capa donde se trabaja con los datos, por tanto contendrá mecanismos
para acceder a la información y también para actualizar su estado. Los datos
los tendremos habitualmente en una base de datos, por lo que en los modelos
tendremos todas las funciones que accederán a las tablas y harán los
correspondientes selects, updates, inserts, etc.
No obstante, cabe mencionar que cuando se trabaja con MCV lo habitual
también es utilizar otras librerías como PDO o algún ORM como Doctrine, que
nos permiten trabajar con abstracción de bases de datos y persistencia en
objetos. Por ello, en vez de usar directamente sentencias SQL, que suelen
depender del motor de base de datos con el que se esté trabajando, se utiliza
un dialecto de acceso a datos basado en clases y objetos.

VISTAS
Las vistas, como su nombre nos hace entender, contienen el código de nuestra
aplicación que va a producir la visualización de las interfaces de usuario, o sea,
el código que nos permitirá renderizar los estados de nuestra aplicación en
HTML. En las vistas nada más tenemos los códigos HTML y PHP que nos
permite mostrar la salida.
En la vista generalmente trabajamos con los datos, sin embargo, no se realiza
un acceso directo a éstos. Las vistas requerirán los datos a los modelos y ellas
se generará la salida, tal como nuestra aplicación requiera.

CONTROLADORES
Contiene el código necesario para responder a las acciones que se solicitan en
la aplicación, como visualizar un elemento, realizar una compra, una búsqueda
de información, etc.
En realidad es una capa que sirve de enlace entre las vistas y los modelos,
respondiendo a los mecanismos que puedan requerirse para implementar las
necesidades de nuestra aplicación. Sin embargo, su responsabilidad no es
manipular directamente datos, ni mostrar ningún tipo de salida, sino servir de
enlace entre los modelos y las vistas para implementar las diversas necesidades
del desarrollo.
 EJEMPLOS EN PHP

config/config.php

En este fichero guardaremos información básica que atañe tanto a la conexión

con base de datos como o tros parámetros. Por ejemplo, el controlador y la
acción por defecto. Si esta aplicación creciera, seguramente el uso de este
fichero estaría más justificado.
<?php

/* Database connection values */

define("DB_HOST", "localhost");
define("DB", "mvc_example");
define("DB_USER", "root");
define("DB_PASS", "");

/* Default options */
define("DEFAULT_CONTROLLER", "note");
define("DEFAULT_ACTION", "list");

?>

controller/note.php

Será el único controlador de nuestra aplicación. Se encarga de recibir las

peticiones desde la vista, solicitar información y/u ordenar cambios al modelo
<?php

require_once 'model/note.php';

class noteController{
public $page_title;
public $view;

public function __construct() {

$this->view = 'list_note';
$this->page_title = '';
$this->noteObj = new Note();
 }

/* List all notes */

public function list(){
$this->page_title = 'Listado de notas';
return $this->noteObj->getNotes();
}

/* Load note for edit */

public function edit($id = null){
$this->page_title = 'Editar nota';
$this->view = 'edit_note';
/* Id can from get param or method param */
if(isset($_GET["id"])) $id = $_GET["id"];
return $this->noteObj->getNoteById($id);
}

/* Create or update note */

public function save(){
$this->view = 'edit_note';
$this->page_title = 'Editar nota';
$id = $this->noteObj->save($_POST);
$result = $this->noteObj->getNoteById($id);
$_GET["response"] = true;
return $result;
}

/* Confirm to delete */
public function confirmDelete(){
$this->page_title = 'Eliminar nota';
$this->view = 'confirm_delete_note';
return $this->noteObj->getNoteById($_GET["id"]);
}

/* Delete */
public function delete(){
$this->page_title = 'Listado de notas';
$this->view = 'delete_note';
return $this->noteObj->deleteNoteById($_POST["id"]);
}

?>
model/db.php

Creamos este modelo para facilitar las operaciones contra base de datos.
<?php

require_once 'config/config.php';

class Db {

private $host;
private $db;
private $user;
private $pass;
public $conection;

public function __construct() {

$this->host = constant('DB_HOST');
$this->db = constant('DB');
$this->user = constant('DB_USER');
$this->pass = constant('DB_PASS');

try {
$this->conection = new PDO('mysql:host='.$this->host.';
dbname='.$this->db, $this->user, $this->pass);
} catch (PDOException $e) {
echo $e->getMessage();
exit();
}

?>
view/template/header.php

En esta parte simplementes abriremos las etiquetas necesarias de html, así

como incrustaremos las llamadas a las librerías que vamos a utilizar. En nuestro
caso, para no tener que trabajar demasiado los estilos, utilizaremos Bootstrap.
Además, mostraremos en el encabezado un título de página, que se cargará de
forma dinámica desde nuestro controlador.

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<link rel="stylesheet"
href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.
min.css" integrity="sha384-
1BmE4kWBq78iYhFldvKuhfTAU6auU8tT94WrHftjDbrCEXSU1oBoqyl2QvZ6jIW3"
crossorigin="anonymous">

<script
src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.mi
n.js" integrity="sha384-
QJHtvGhmr9XOIpI6YVutG+2QOK9T+ZnN4kzFN1RtK3zEFEIsxhlmWl5/YESvpZ13"
crossorigin="anonymous"></script>
</head>
<body>
<div class="container">
<header class="mb-5">
<div class="p-5 text-center bg-light" style="margin-
top: 58px;">
<h1 class="mb-3"><?php echo $controller-
>page_title; ?></h1>
<h4 class="mb-3">-</h4>
</div>
</header>