Dudas con POO: getters y setters con DB, arrays multidimensionales...

[Everu]

Tengo dos dudas que no me dejan dormir y agradecería si alguien pudiese aconsejarme. Bien, imaginemos que tengo el objeto "Usuario" y tiene las propiedades "Nombre" y "Correo". Hereda de la clase mysql para gestionar las consultas a la base de datos.

Problema 1:
¿Getters y Setters con MySQL?

Código PHP:

<?php
class usuario extends mysql {
     private $nombre;
 
     public function __construct($id = null) {
          $this->nombre = $this->getNombre();
          $this->correo = $this->getCorreo();
     }
 
     public function setNombre() {
          $query parent::query();
          while($row = results($query)) {
               return $row["nombre"];
          }
     }
 
     public function getNombre() {
          return $this->nombre;
     }
 
     public function setCorreo() {
          $query parent::query();
          while($row = results($query)) {
               return $row["correo"];
          }
     }
 
     public function getCorreo() {
          return $this->correo;
     }
}
?>
 

Bien, esto claramente es poco eficiente. Consultar dos veces la BD pudiendo consultarla una única vez es absurdo. Así pues, decidí unificar haciendo esto:

Código PHP:

<?php
class usuario extends mysql {
     private $nombre;
     private $correo;
 
     public function __construct($id = null) {
          $this->setAll();
     }
 
     public function setAll() {
          $query parent::query();
          while($row = results($query)) {
               $this->nombre = $row["nombre"];
               $this->correo = $row["correo"];
          }
     }
 
     public function getNombre() {
          return $this->nombre;
     }
 
     public function getCorreo() {
          return $this->correo;
     }
}
?>
 

El problema: Si quiero imprimir solo el correo, también consultará en la BD el nombre y tantos campos como propiedades tenga la clase. Nuevamente, pérdida de eficiencia.
¿Cuál es la mejor forma de hacer esto?

Segundo Problema:
Quiero imprimir los 5 primeros usuarios de la siguiente forma:

Código HTML:

Nombre: Nombre 1
Correo: Correo 1

Nombre: Nombre 2
Correo: Correo 2

(...)

Nombre: Nombre 5
Correo: Correo 5

Usar el siguiente código no sería eficiente. Se hacen 5 consultas a la base de datos cuando se podría hacer 1.

Código PHP:

<?php
for($i=1;$i<=5;$i++) {
     $user = new usuario($i); //creamos el objeto para el usuario 1, el 2, el 3... el 5.
     echo $user->getNombre;
     echo $user->getCorreo;
}
?>
 

Entonces, decidí crear un array multidimensional en el objeto usuario.

Código PHP:

<?php
class usuario extends mysql {
     private $nombre;
     private $correo;
 
     public function __construct($id = null) {
          $this->nombre = array();
          $this->correo = array();
          $query parent::query(/*ÚLTIMOS 5 USUARIOS*/);
          while($row = results($query)) {
               $nombre = $row["nombre"];
               $correo = $row["correo"];
 
               array_push($this->nombre, $nombre); //tenemos todos los nombres en un arreglo
               array_push($this->correo, $correo); //tenemos todos los correos en un arreglo
          }
     }
 
     public function getAll() {
          $usuarios = array(); //vamos a crear el array multidimensional
          $i = 0;
          foreach($this->nombre as $nombre) {
               $usuarios[] = array("nombre" => $nombre, "correo" => $this->correo[$i]);
               $i++
          }
}
?>
 

Ahora tengo un arreglo multidimensional con todos los datos de los 5 últimos usuarios. Y para imprimir los datos:

Código PHP:

<?php
$objeto = new usuario();
$getall = $objeto->getAll();
foreach($getall as $usuario) {
     echo "Nombre ".$usuario["nombre"];
     echo "Correo ".$usuario["correo"];
}
?>
 

¿Está ideado correctamente? ¿Hay alternativas mejores? Por favor, me gustaría que aquellos expertos en POO me comentasen cómo lo ven o dijesen cómo lo harían ellos.

Gracias.

[GatorV]

Te recomiendo leer un poco, vas bien pero te recomendaria leer precisamente de los patrones ActiveRecord y ActiveTable, con ellos vas a poder trabajar de forma más ordenada tus datos y vas a poder comprender de una forma más sencilla como manejar lo que quieres hacer

Saludos.

[fernandozunni]

La clase usuario no debiera heredar la clase mysql por el simple hecho de la conexion, creo que tendrías que leer bien el concepto de herencia.

[Everu]

Iniciado por fernandozunni

La clase usuario no debiera heredar la clase mysql por el simple hecho de la conexion, creo que tendrías que leer bien el concepto de herencia.

Bueno, en realidad el código lo escribí para ilustrar lo que quería decir en el post. En mis clases originales no hereda de una clase mysql, sino de otro objeto. Claramente tienes toda la razón, no tiene sentido heredar de la clase base de datos, sino instanciarla.

Leeré sobre ActiveRecord y ActiveTable y veré qué puedo hacer para mejorar la clase, aunque estoy viendo por internet muchos detractores de su uso.

Gracias a los dos por contestar.

[GatorV]

Claro es siempre mejor usar un ORM para mantener tus objetos lo más desacoplados de la Base de Datos y así es más transparente el uso, pero para proyectos pequeños yo prefiero usar ActiveRecord/Table para eso.

Saludos.

[limbvirgin]

Lo que hago yo es tratar de emular a un ORM en cosas básicas. Por ejemplo, una persona es una entidad, pero esa persona puede tener varios números telefónicos a los que puede ser contactado, en un esquema de base de datos SQL, necesitaríamos 2 tablas para poder encapsulara a 1 entidad que es "persona".

Este es el esquema de base de datos:

tabla persona, atributos: id, nombre, direccion.
tabla agenda, atributos: id, id_persona, telefono.

Están relacionadas por la llave local agenda.id_persona, y la llave foránea persona.id.

De tal forma que mediante POO accederé a la entidad "persona" mediante una única instancia, la cual tendrá métodos como getNombre, getDireccion, getTelefonos.

//archivo persona.php

Código PHP:

<?php
class persona {
   private $nombre;
   private $direccion;
   private $telefonos=array();
 
   public function setNombre($nombre){
      $this->nombre=$nombre;
    }
 
 public function setDireccion($direccion){
      $this->direccion=$direccion;
    }
 
 public function setTelefonos($telefonos){
      $this->telefonos=$telefonos;
    }
}
?>
 

Ahora utilizamos una clase llamada dbPersona que es la encargada de acceder a la base de datos, y llenar instancias de la clase persona con los registros tomados de la base de datos.

Archivo dbPersona.php

Código PHP:

<?php
 
require_once 'persona.php';
 
class dbPersona {
         private $host = "localhost";
     private $db = "persona";
     private $user = "root";
     private $pass = "nose";
         private $link;
  
    public function __construct(){
        $this->conectar();
     }
     private function conectar(){
        $link=mysql_connect($this->host, $this->user, $this->pass) or die ("Error."); 
          mysql_select_db($this->db ,$link) or die("Error."); 
$this->link=$link;
     }
   public function getAll(){  //DEVUELVE UNA COLECCION DE CLASES, NO UNA COLECCION DE ARRAYS
    $result=mysql_query("SELECT * FROM persona", $this->link);
    $personas=array();
    while($row=mysql_fetch_array($result)){
     $personas[]=$this->fetch($row);
     }
     return $personas;
    }
   public function getById($id){  //DEVUELVE UNA INSTANCIA DE LA CLASE PERSONA SEGUN EL ID.
      $result=mysql_query("SELECT * FROM persona WHERE id='$id'",$this->link);
      $row=mysql_fetch_array($result);
      $persona=$this->fetch($row);
      return $persona;
   }
 
   private function getTelefonos($id_persona){
   $result=mysql_query("SELECT telefono FROM agenda WHERE id_persona='$id_persona'",$this->link);
    $telefonos=array();
     while($row=mysql_fetch_array($result)) $telefonos[]=$row['telefono'];
    
     return $telefonos;
 
  }
 
 private function fetch($row){
   $persona=new persona();
   $persona->setId($row['id']);
   $persona->setNombre($row['nombre']);
   $persona->setDireccion($row['direccion'];
   $telefonos=$this->getTelefonos($row['id']);
   $persona->setTelefonos($telefonos); 
   return $persona;
  }
}
?>
 

Los archivos anteriores corresponden a la capa Modelo ( según el modelo MVC).

Para acceder a los datos de una persona:

Archivo index.php

Código PHP:

<?php
require_once 'dbPersona.php'; 
$db= new dbPersona();
$personas= $db->getAll();
 
foreach($personas as $persona){
  echo $persona->getNombre();
  foreach($persona->getTelefonos() as $telefono){
    echo $telefono;
  }
}
?>
 

De esta manera logramos encapsular los registros de una tabla relacional en entidades manejables desde una única instancia. A esto se le llama persistencia.

Debo aclarar que no utilizo la interfaz mysql de PHP sino la interfaz mysqli, así que no certifico la calidad del código jojojo ;)

También aclaro que la parte del modelo lo genero con un script que creé para facilitarme las cosas, pues escribir la parte del Modelo puede llegar a ser doloroso, pues consume tiempo, y es algo repetitivo, pero vale la pena el esfuerzo porque es mucho más fácil alimentar a los demás archivos de la capa Controlador y Vista con métodos intuitivos y objetos encapsulados (todo dentro de un mismo paquete, para una persona: su nombre, dirección, y lista de números telefónicos).

La conexión la hago en otro archivo "conectar.php" del cual heredo para todas la clases que accedan a la base de datos.

En resumen, en vez de acceder a los datos como simples arrays:
echo $persona['nombre'];

Lo hacemos mediante POO, donde $persona no es un array sino una clase:
echo $persona->getNombre();

Acceder a los atributos mediante métodos da mucha mayor flexibilidad.

A como puedes notar, el controlador "index.php" es bastante sencillo y extremadamente simple de comprender.

Recuerda que el código de la capa Modelo (en este ejemplo la clase persona y dbPersona) sólo se escribe una vez,
así que vale la pena el esfuerzo, porque así liberas de mucho peso y complejidad a la capa Controlador y Vista, que suele ser la parte dinámica
de una aplicación, y la parte que puede crecer y crecer, y es lo que cambia más durante el ciclo de vida de una aplicación.

Ahora, para el problema de "eficiencia" donde sólo quisieras mostrar el nombre de la persona, pero sin tener que cargar todos los datos de esa persona y
perder el tiempo cargando esos datos, podríamos hacer que al llamar al método getNombre, si el atributo nombre no ha sido establecido, haga una
consulta a la base de datos; así sólo se irán cargando dinámicamente los datos necesarios.

Código PHP:

require_once 'dbPersona.php';
 
class persona { 
private $id;
private $nombre;
 
public function setNombre($nombre){
 $this->nombre=$nombre;
}
 
public funcion getNombre(){
 if(!isset($this->nombre){
  $db = new dbPersona();
   $this->nombre=$db->getNombre($this->id);
   } 
 return $this->nombre;
 }
}
 

El método getAll de la clase dbPersona, de primas a primeras sólo se encargaría de devolver una colección de clases
semi vacías, donde sólo se inicialicen los id;

Código PHP:

public function getAll(){
$result="SELECT id FROM persona";
 
$personas=array(); 
 
while ($row=mysql_fetch_array($result)){
$persona=new $persona();
$persona->setId($row['id']);
$personas[]=$persona;
}
 
return $personas;
}
 
public function getNombre($id){
"SELECT nombre FROM persona WHERE id='$id'";
return $nombre;
}
 

En nuestro controlador el flujo de datos se vería así

Código PHP:

require_once 'dbPersona.php';
 
$db= new dbPersona();
$personas=$db->getAll(); //devuelve clases donde sólo los id han sido inicializados
 
foreach ($personas as $persona){
 
echo $persona->getNombre()// como el atributo nombre está vacío, hace la consulta  a la DB.
//imprime el nombre;
 
echo $persona->getNombre()//el atributo nombre ya ha sido inicalizado, por ende no ejecuta la consulta,
// y devuelve el valor inmediatamente.
 
}
 

Aunque en realidad no sé qué tan eficiente - o no- puede ser eso jojo.

A modo de tip, en mi tiempo libre durante 2 días escribí un script para crear el 80% de la capa de Modelo (me falta pulir el script :P )
una vez terminado, sólo modifico un archivo YAMAL en el cual escribo lo siguiente:

Código XML:

all:
 database:
    host: localhost
    user: root
    pass: nose
    esquema: curso
 modelo:
   persona: id, nombre, apellido, direccion
   agenda: id, id_persona, telefono
 

----

Eso es todo, luego ejecuto el script y casi casi se me genera todo el código necesario. jojojo.

Así que ánimo. Imagino que habrán mejores maneras de hacerlo, pero mientras continuo aprendiendo, seguiré trabajando así por el momento ;)

[masterpuppet]

ORM es genial, pero agrega una capa de complejidad que no todo proyecto amerita.
Te invito a que le eches un ojo a Doctrine.

Zend 2 + Doctrine 2 = Priceless :)

[ramonw]

Zend 2 + Doctrine 2 = Priceless :)

Hola, esto quiere decir que Doctrine 2, vendrá de forma nativa en ZF 2.0 ?

Si alguien me puede aclarar esto... porque no lo sabía.

Saludos.

[GatorV]

No, pero se puede integrar fácilmente, hay varios sitios en internet donde te indican como acoplar Zend y Doctrine. Zend al ser un framework desacoplado te permite intercambiar componentes sin tener que hacer mucho esfuerzo.

Saludos.

[ramonw]

Hola, y pregunto: que ventaja tiene (si es que tiene) utilizar Doctrine sobre Zend_Db ?
Yo cuando trabajo con ZF, utilizo Zend_DB.

Saludos.

[GatorV]

Zend_Db no es un ORM, ni le pisa los talones a un ORM, es un simple puente de acceso, entre tus tablas y para accesarlas de una forma orientada a objetos, pero es mejor usar un ORM como tal (para proyectos más grandes).

Saludos.