Persistencia de objetos en PHP

Uno de los problemas con el que nos encontramos al trabajar con PHP es que al utilizar un objeto y asignarle atributos, es que al cambiar de página, los valores asignados a la clase de pierden. Así que no es simple tener un proyecto enteramente en objetos.

Tuve un proyecto donde me sería muy útil si pudiera manejar gran cantidad de datos y para tener una mejor organización, quise que estuviera todo en clases, y encontrándome con el problema de que al cambio de página no persiste la información, me puse a trabajar en un método en el cual la persistencia de objetos fuera lograda.

Para entender un poco mas, veremos el siguiente ejemplo:

Normalmente:
Se crea un archivo en donde se encuentra la clase, por ejemplo persona el cual contiene las propiedades nombre, dirección, y edad.

Se incluye la clase en el archivo que carga el servidor y se le asignan las propiedades al objeto.
En cualquier momento (en el archivo que se cargó en el servidor) podemos cambiar, asignar o eliminar los datos de las propiedades del objeto.

Si cargamos otro archivo en el servidor e incluimos el archivo de la clase persona, nos encontramos con que está completamente limpia en las propiedades, y para muchos de nosotros sería perfecto que existiera una forma en que sin importar que archivo cargásemos en el servidor, pudiéramos recuperar las propiedades que ya asignamos además de poder editarlos y eliminarlos.

Con persistencia de objetos
Se crea un archivo en donde se encuentra la clase, por ejemplo persona el cual contiene las propiedades nombre, dirección, y edad.
Se crean funciones para asignar y eliminar propiedades de la clase.

Se incluye la clase en el archivo que carga el servidor.
Se incluye la clase init (que más adelante se mostrará) el cual servirá para asignar y recuperar los valores de las propiedades del objeto.

Ahora, se puede asignar los valores de las propiedades del objeto y se pueden recuperar en cualquier momento mientras no se haya cambiado de archivo en el servidor.

Si cargamos otro archivo en el servidor, incluimos de nuevo el archivo init, y ejecutamos una función que nos permita recuperar automáticamente todas las propiedades de la clase.
También podemos cargar tantas clases necesitemos y recuperar en cualquier momento, cualquier propiedad de cualquier clase en tiempo de ejecución, sin importar en qué momento se asignó los valores.

Ejemplo de persistencia de objetos

Se necesita crear el archivo init.php


<?php
/**
 *
 * @author Horacio Romero Mendez (angelos)
 * @License Copyleft 2011
 * @since Apr 4, 2011 5:50:19 PM
 * @Internal GNU/Linux Arch 2010.05 Notebook
 *
 */


class init {

public static function setPersist($clase, $var, $valor){
@session_start();
$_SESSION["{$clase}_{$var}"] = base64_encode(filter_var($valor, FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES));
}

public static function getPersist($clase, $var){
@session_start();
return filter_var(base64_decode(@$_SESSION["{$clase}_{$var}"]), FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES);
}
}


 ?>

———————————
Fin del archivo init.php



Éste archivo es el que nos permitirá asignar y recuperar los valores a través de los archivos.

Y vamos a hacer un ejemplo de una clase banco que podrá usar la persistencia de objetos:

Archivo banco.php


<?php
//Se incluye el archivo init
require_once('init.php');


class banco extends init {
        //Se crean los atributos de la clase, en este caso idBanco y bancoNombre, se deben tener en mente los nombres de las variables pues estas se usarán en las funciones set y get
private static $idBanco;
private static $bancoNombre;

        //Esta función es obligatoria, se debe dejar tal y como está, sirve para asignar las propiedades
private static function setValue($campo, $valor= "") {
self::setPersist(__CLASS__, $campo, $valor);
  self::$$campo = $valor;
}

        //Esta función es obligatoria, se debe dejar tal y como está, sirve para recuperar las propiedades
private static function getValue($campo) {
self::$$campo = init::getPersist(__CLASS__, "$campo");
}


        //Esta función es obligatoria, se debe dejar tal y como está, sirve para que cuando se cambie de archivo en el servidor, se recuperen todas las propiedades que ya han sido asignadas en cualquier parte del proyecto y en cualquier momento
public static function start(){
foreach(get_class_vars(__CLASS__) as $nombre => $valor)
self::getValue($nombre);
}
        //Esta función es para que en el momento que desees, puedas borrar todas las propiedades del objeto

        public static function reset(){
foreach(get_class_vars(__CLASS__) as $nombre => $valor)
self::setValue($nombre, "");
}



        //Para cada propiedad de la clase se debe crear 2 funciones, uno para asignar el valor que pueda ser recuperado posteriormente y otro para recuperar dicho valor. El nombre de la función puede ser el que se deseé, en el ejemplo se antepone set para las funciones en donde se asigna la propiedad, seguido del nombre de la variable de la propiedad; dentro self::setValue("") debe ir la variable a la que se desea asignar la propiedad
public static function setIdBanco($var){
self::setValue("idBanco", $var);
}

public static function getIdBanco(){
return self::$idBanco;
}


public static function setBancoNombre($var){
self::setValue("bancoNombre", $var);
}

public static function getBancoNombre(){
return self::$bancoNombre;
}
}
 ?>

——————————
fin archivo banco.php

Hasta aquí un breve y simple ejemplo de una clase que está hecha para poder asignarle propiedades y poder recuperarlas en cualquier parte del proyecto. Ahora vamos a ver un ejemplo de asignación y recuperación de dichas propiedades.

Archivo1.php


<?php
require_once('banco.php');


//En éste momento las propiedades del banco están vacías.


//Se asigna la propiedad idBanco
banco::setIdBanco("1");


//Se asigna la propiedad bancoNombre
banco::setBancoNombre("banco de prueba");


//Se imprimen las propiedades del banco
echo banco::getIdBanco(); //1
echo banco::getBancoNombre(); //banco de prueba
?>

————————————-
Fin Archivo1.php


Hasta éste momento hemos asignado y recuperado las propiedades de la clase banco solo en un mismo archivo, lo cual lo podemos hacer normalmente en PHP, ahora vamos a ver un ejemplo de recuperar la información desde un archivo diferente
Archivo2.php
<?php
require_once('banco.php');

//En éste momento las propiedades del banco están vacías.
//Se imprimen las propiedades del banco (no mostrará resultado)
echo banco::getIdBanco();
echo banco::getBancoNombre();

//Ahora vamos a recuperar las propiedades que asignamos en el anterior archivo
banco::start();

//Listo, ya hemos recuperado las propiedades y ya las podemos imprimir.

echo "ID del banco: ".banco::getIdBanco(); //1
echo " Nombre del banco: ".banco::getBancoNombre(); //banco de prueba
?>
————————————
Fin Archivo2.php

Cabe señalar, como se muestra en el archivo init,php, la persistencia de objetos es gracias a sesiones, lo cual significa que la persistencia durará mientras dure la sesión del sistema. 
La persistencia de objetos la hice pensando en proyectos donde se tienen que utilizar una gran cantidad de clases con sus respectivas propiedades y que en cualquier momento del proyecto se deba cargar los valores. Por ejemplo en la clase se puede colocar un método en el cual consulte a la BD y asigne todos o las propiedades necesarias y se puede mandar a llamar en cualquier parte del proyecto con lo que se ahorraría escribir código. 
Al igual se puede crear una sola función que guarde todos los campos de la BD y que los tome de la clase, y en el proyecto solo se mandaría a llamar la clase, se asignarían los atributos necesarios y se ejecutaría el método, por ejemplo updatePersona(); y se puede mandar a llamar en la parte donde se registran los datos personales, también en donde se registran los datos de ubicación, y tambien en donde se registran los datos de banco. 
Por el momento dejo sólo estos ejemplos muy simples, espero poco a poco colocar ejemplos mas completos de como se puede trabajar con la persistencia de clases

Author: angelinux

Desarrollador de páginas web desde el año 2000 y con experiencia en programación de sistemas para empresas desde el 2008; cofundador de CONSoluciones; autor del blog de software libre “Angelinux-slack”; docente en maestría en UPAV y fundador de la distribución Linux Falco que está en desarrollo para la Universidad Veracruzana.
Además, ponente, organizador de congreso, laborista social, impartidor de cursos de programación y servidores Linux, webmaster, y ex invitado en programa de televisión.

1 thought on “Persistencia de objetos en PHP

  1. Pingback:Persistencia de objetos para PHP – Angelinux

Deja un comentario