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);
}
}


 ?>

É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;
}
}
 ?>

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
?>