PHP Conceptos básicos Modelo-Vista-Controlador

De MediaWiki
Saltar a: navegación, buscar

Introdución

  • Có que levamos visto ata o de agora xa podemos facer sitios webs en PHP, pero teremos certos problemas 'de mantemento' en caso de que o sitio sexa grande (con grande me refiro a unha cantidade alta de páxinas PHP).
  • Isto é debido a que estamos a 'mesturar' aspectos, como por exemplo as funcións de acceso a datos (conexión e operacións) dentro das páxinas que van 'presentar' ao usuario a información.


  • Imaxinemos como estamos a facer agora que queremos cambiar o acceso á base de datos e no canto de utilizar Mysql queremos usar SQLServer...
Teríamos que ir a todas as páxinas cambiando as funcións de acceso a datos.
  • Por outra banda, imaxinade que temos un equipo de persoas e queremos 'distribuír' o traballo en equipos.
De tal forma que un equipo se encargue de 'maquetar' a información con CSS e HTML e outro que se adique a facer as chamadas á base de datos en busca de dita información.
Esta labor non a poderíamos facer en 'paralelo' xa que a presentación de datos e o acceso aos mesmos se fan dentro da mesma páxina.


Melloras ao feito ata o de agora

Clase para acceder a Mysql

  • En primeiro lugar, poderíamos crear unha clase que se encargue da facer a conexión á base de datos e as operacións contra a mesma.
  1. <?php
  2. class Database {
  3.  
  4.         const CONSULTAR_LIBROS='select id_libro,titulo from LIBROS order by titulo';    
  5.    
  6.         const SERVIDOR = 'localhost';
  7.         const USUARIO = 'user_php';
  8.         const PASSWORD = 'user_php';
  9.         const BD = 'PHP';
  10.  
  11.         private static $db;
  12.         private $conexion;
  13.  
  14.         private function __construct() {
  15.             $this->conexion = new mysqli(self::SERVIDOR,self::USUARIO,self::PASSWORD,self::BD);
  16.             $this->conexion->set_charset('utf8');  
  17.          }
  18.  
  19.         function __destruct() {
  20.             $this->conexion->close();
  21.         }
  22.  
  23.         public static function obterConexion() {
  24.             if (self::$db == null) {
  25.                 self::$db = new Database();
  26.             }
  27.             return self::$db->conexion;
  28.         }
  29.  
  30.         public static function executarSQL($consulta) {
  31.               $result=self::$db->conexion->query($consulta);
  32.               return $result;
  33.         }
  34.              
  35.         public static function executarProc($procedure) {
  36.               if(self::$db->conexion->multi_query($procedure)){
  37.                   $result[]=self::$db->conexion->store_result();
  38.                    while(self::$db->conexion->next_result()){
  39.                        $result[]= self::$db->conexion->store_result();
  40.                    }
  41.                    return $result;
  42.               }
  43.               else{
  44.                   return null;
  45.               }
  46.         }
  47. }


Nota: Lembrar que a clase anterior non tería que estar na estrutura de cartafol de acceso do Apache (en Linux sería /var/www/html/), como indicamos anteriormente na WIKI.


  • Se aplicamos a clase anterior a unha das páxinas feitas durante este manual, por exemplo, a páxina que consulta os libros da táboa LIBROS:
  1.     <?php
  2.     include ('Database.php');
  3.  
  4.     $conex = Database::obterConexion();
  5.     if ($conex->connect_error){
  6.          die('Erro de Conexi&oacute;n (' . mysqli_connect_errno() . ') ' . mysqli_connect_error());
  7.     }
  8.     ?>
  9.  
  10.  
  11.     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  12.         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  13.     <html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
  14.         <head>
  15.             <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  16.             <title>Operacións BD</title>
  17.         </head>
  18.  
  19.         <body>
  20.     <?php        
  21.  
  22.             $result=Database::executarSQL(Database::CONSULTAR_LIBROS);
  23.             if ($result && $result->num_rows>0){
  24.                 echo "<table border='1'>";
  25.                 while($row = $result->fetch_assoc()) {
  26.                     echo '<tr>';
  27.                     printf("<td>%s</td>",$row["titulo"]);
  28.                     echo '</tr>';
  29.                 }
  30.                 echo '</table>';
  31.                 $result->free();  // Liberamos da memoria os recursos
  32.             }
  33.             else {
  34.                 echo "Non hai datos que amosar!!!!";
  35.             }
  36.  
  37.     ?>        
  38.         </body>    
  39.     </html>




  • Poderíamos 'optimizar' un pouco máis e facer que a clase DataBase tamén incorpore os métodos que respondan ás peticións das páxinas, facendo que os métodos definidos devolvan xa un array cos datos.
Desta forma, nesta clase, poderíamos poñer as regras de validación en caso de engadir datos, xunto cos procedementos que devolven ou xestionan a información que reciben dende as páxinas (regras de negocio)
Aplicado ao exemplo anterior:

Arquivo: Database.php

  1. <?php
  2. class Database {
  3.  
  4.         const CONSULTAR_LIBROS='select id_libro,titulo from LIBROS order by titulo';    
  5.    
  6.         const SERVIDOR = 'localhost';
  7.         const USUARIO = 'user_php';
  8.         const PASSWORD = 'user_php';
  9.         const BD = 'PHP';
  10.  
  11.         private static $db;
  12.         private $conexion;
  13.  
  14.         private function __construct() {
  15.             $this->conexion = new mysqli(self::SERVIDOR,self::USUARIO,self::PASSWORD,self::BD);
  16.             $this->conexion->set_charset('utf8');  
  17.          }
  18.  
  19.         function __destruct() {
  20.             $this->conexion->close();
  21.         }
  22.  
  23.         public static function obterConexion() {
  24.             if (self::$db == null) {
  25.                 self::$db = new Database();
  26.             }
  27.             return self::$db->conexion;
  28.         }
  29.  
  30.         public static function executarSQL($consulta) {
  31.               $result=self::$db->conexion->query($consulta);
  32.               return $result;
  33.         }
  34.              
  35.         public static function executarProc($procedure) {
  36.               if(self::$db->conexion->multi_query($procedure)){
  37.                   $result[]=self::$db->conexion->store_result();
  38.                    while(self::$db->conexion->next_result()){
  39.                        $result[]= self::$db->conexion->store_result();
  40.                    }
  41.                    return $result;
  42.               }
  43.               else{
  44.                   return null;
  45.               }
  46.         }
  47.        
  48.         public static function consultarLibros(){
  49.            
  50.             $resultados=null;
  51.             $result=Database::executarSQL(Database::CONSULTAR_LIBROS);
  52.             if ($result && $result->num_rows>0){
  53.                 while($row = $result->fetch_assoc()) {
  54.                     $resultados[]=$row;
  55.                 }
  56.             $result->free();  // Liberamos da memoria os recursos
  57.             }
  58.             return $resultados;
  59.            
  60.         }
  61. }


Arquivo: Consultar_Libros.php

  1.     <?php
  2.     include ('Database.php');
  3.  
  4.     $conex = Database::obterConexion();
  5.     if ($conex->connect_error){
  6.          die('Erro de Conexi&oacute;n (' . mysqli_connect_errno() . ') ' . mysqli_connect_error());
  7.     }
  8.     ?>
  9.  
  10.  
  11.     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  12.         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  13.     <html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
  14.         <head>
  15.             <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  16.             <title>Operacións BD</title>
  17.         </head>
  18.  
  19.         <body>
  20.  
  21.     <?php        
  22.  
  23.        $result=Database::consultarLibros();
  24.        if (!empty($result)){
  25.            echo "<table border='1'>";
  26.            foreach ($result as $fila){
  27.                echo '<tr>';
  28.                printf("<td>%s</td>",$fila["titulo"]);
  29.                echo '</tr>';
  30.            }
  31.            echo '</table>';
  32.        }
  33.        else {
  34.            echo "Non hai datos que amosar!!!!";
  35.        }
  36.     ?>        
  37.         </body>    
  38.     </html>
  39.  
  40. <?php ob_start() ?>


  • Tamén poderíamos aplicar os conceptos da POO que aprendemos anteriormente na wiki e facer que a información que devolva a función 'consultarLibros' da clase Database, sexa un array de obxectos dunha clase definida previamente, que representaría a táboa LIBROS.

Uso de 'modelos' de páxinas

  • Outra mellora podería ser empregar 'modelos' para o sitio web.
Normalmente todas as páxinas terán a mesma estrutura de bloques (cabeceira, menús, contido), polo que, en vez de repetir o código en todas elas, poderíamos empregar un modelo que sexa utilizado en todas.


Opción 1

  • Unha forma sería utilizar arquivos de include para cada bloque, da forma (aplicado ao exemplo anterior):

Arquivo:MeuSitio.css: Arquivo de css que será aplicado a todas as páxinas do sitio web. Defínense o aspecto e tamaño de cada bloque que conforma o sitio web.

  1. #cabecera{
  2.    
  3.     width:100%;
  4.     height:25%;
  5.     margin:0px auto;
  6.     text-align: center;
  7.     background-color: blue;
  8.    
  9. }
  10.  
  11. #menus{
  12.     float:left;
  13.     height:5%;
  14.     background-color: red;
  15.     font-weight: bold;
  16.     color: yellow;
  17. }
  18.  
  19. #contido{
  20.     clear:both;
  21.     width:100%;
  22.     background-color: green;
  23.    
  24.    
  25. }


Arquivo:Cabecera.inc.php: Cabeceira do sitio web. Podería ter código PHP.

  1. <div id='cabecera'>ISTO É A CABECEIRA DO NOSO SITIO WEB
  2. <?php
  3.     echo "<p>Poderíamos engadir código php</p>";
  4. ?>
  5.  
  6. </div>


Arquivo:Menu.inc.php: Arquivo que representa o zona de menús do sitio web. Podería ter código PHP.

  1. <div id='menus'>  <!--Exemplo de menu. Os enlaces non funcionan-->
  2. <a href='Inicial.php'>Incio</a>
  3. <a href='Consulta_Libros.php'>Consultar Libros</a>
  4. </div>


Arquivo:Consultar_Libros.php

  1.     <?php
  2.     include ('Database.php');
  3.  
  4.     $conex = Database::obterConexion();
  5.     if ($conex->connect_error){
  6.          die('Erro de Conexi&oacute;n (' . mysqli_connect_errno() . ') ' . mysqli_connect_error());
  7.     }
  8.     ?>
  9.  
  10.  
  11.     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  12.         "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  13.     <html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
  14.         <head>
  15.             <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  16.             <title>Operacións BD</title>
  17.             <link href="MeuSitio.css" rel="stylesheet" />
  18.         </head>
  19.  
  20.         <body>
  21.             <?php include('Cabecera.inc.php'); ?>
  22.             <?php include('Menu.inc.php'); ?>
  23.             <div id='contido'>
  24.             <?php        
  25.  
  26.                 $result=Database::executarSQL(Database::CONSULTAR_LIBROS);
  27.                 if ($result && $result->num_rows>0){
  28.                     echo "<table border='1'>";
  29.                     while($row = $result->fetch_assoc()) {
  30.                         echo '<tr>';
  31.                         printf("<td>%s</td>",$row["titulo"]);
  32.                         echo '</tr>';
  33.                     }
  34.                     echo '</table>';
  35.                     $result->free();  // Liberamos da memoria os recursos
  36.                 }
  37.                 else {
  38.                     echo "Non hai datos que amosar!!!!";
  39.                 }
  40.  
  41.             ?>        
  42.             </div>
  43.         </body>    
  44.     </html>



Opción 2

  • En PHP temos outra forma de facer 'modelos' de páxinas. O procedemento é ao revés do feito no exemplo anterior.
Cada páxina do noso sitio web estará formado por un 'modelo' de páxina (sería a páxina na que se definen os bloques) ao que se engade o contido específico da páxina a cargar.
Para facelo desta forma temos que utilizar as funcións:


Vexamos un exemplo:

Arquivo:Layout.php: Vai ser a páxina 'modelo' de todas as páxinas do noso sitio web.

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  2.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  3. <html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
  4.     <head>
  5.         <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  6.         <title>Optimizando sitio web</title>
  7.         <link href="MeuSitio.css" rel="stylesheet" />
  8.     </head>
  9.  
  10.     <body>
  11.         <div id='cabecera'>ISTO É A CABECEIRA DO NOSO SITIO WEB
  12.             <?php
  13.                 echo "<p>Poderíamos engadir código php</p>";
  14.             ?>
  15.  
  16.         </div>
  17.         <div id='menus'>  <!--Exemplo de menu. Os enlaces non funcionan-->
  18.             <a href='Inicial.php'>Incio</a>
  19.             <a href='Consulta_Libros.php'>Consultar Libros</a>
  20.         </div>
  21.        
  22.        
  23.         <div id='contido'>
  24.             <?php echo $contido ?>
  25.         </div>
  26.  
  27.     </body>
  28.  
  29. </html>
  • Liña 24: Fixarse que o contido vai vir nunha variable de nome $contido


Arquivo:Consultar_Libros_Con_Modelo.php: Esta sería a forma de cargar cada unha das páxinas.

  1. <?php ob_start() ?>
  2.  
  3. <?php
  4.    
  5.     include ('Database.php');
  6.  
  7.     $conex = Database::obterConexion();
  8.     if ($conex->connect_error){
  9.          die('Erro de Conexi&oacute;n (' . mysqli_connect_errno() . ') ' . mysqli_connect_error());
  10.     }
  11.  
  12.     $result=Database::executarSQL(Database::CONSULTAR_LIBROS);
  13.     if ($result && $result->num_rows>0){
  14.         echo "<table border='1'>";
  15.         while($row = $result->fetch_assoc()) {
  16.             echo '<tr>';
  17.             printf("<td>%s</td>",$row["titulo"]);
  18.             echo '</tr>';
  19.         }
  20.         echo '</table>';
  21.         $result->free();  // Liberamos da memoria os recursos
  22.     }
  23.     else {
  24.         echo "Non hai datos que amosar!!!!";
  25.     }
  26.  
  27. ?>        
  28. <?php $contido = ob_get_clean() ?>
  29.  
  30. <?php include 'Layout.php' ?>
  • Liña 1,28: Utilizamos as funcións indicadas anteriormente.
Estas funcións o que fan basicamente é que a saída que fagamos (echo, printf,...) non se mande ao navegador do usuario, se non que se garde nun 'buffer'. A función ob_get_clean() devolve o contido do buffer (no noso caso o gardamos na variable $contido) e limpa o buffer.
Liña 29: Unha vez feito o anterior temos na variable $contido o resultado de executar o código PHP. Dita variable se utiliza na modelo 'Layout.php' para colocar o contido no seu sitio.



  • Como vemos, a idea é ir separando aspectos funcionais do sitio web das páxinas que se amosan ao usuario.
Aínda temos aspectos que mesturan aspectos do acceso a datos da presentación do usuario, como pode ser a validación de campos.


  • O conxunto de validacións, xunto coas regras que poidamos ter para acceder aos datos da nosa base de datos conforman as regras de negocio. No MVC dita función atópase na capa de MODELO como veremos a continuación (unha capa vai ser unha ou varias clases que van ter unha función específica).
Por exemplo, chamar a unha función que consultara os libros dun determinado autor. Dita función comprobaría previamente se o autor existe e,en caso de que o autor non exista, avisar a quen fixo a chamada. Esta función sería a encargada de facer a orde SQL contra a base de datos e devolvería un array de datos co resultado da chamada ou un código indicando que o autor non existe (regra de negocio). Tamén se encargaría de validar que o dato enviado (o autor a buscar) sexa do tipo e formato correcto (enviar o nome e apelidos, por exemplo).

Modelo-Vista-Controlador

Apuntes Offline do enlace anterior
Despois de lelo, aplicade os conceptos aprendidos as diferentes páxinas que se fixeron durante o punto de 'acceso a datos' da WIKI.






-- Ángel D. Fernández González -- (2016).