ScotlandPHP 2016

La interfaz Serializable

(PHP 5 >= 5.1.0, PHP 7)

Introducción

Interfaz para personalizar la serialización.

Las clases que implementan esta interfaz ya no admiten __sleep() ni __wakeup(). El método serialize se llama cuando una instancia requiere ser serializada. Esto no invoca a __destruct() ni tiene ningún efecto adicional a menos que se programe dentro del método. Cuando los datos son deserializados, la clase es conocida y se llama al correspondiente método unserialize() como constructor en lugar de llamar al método __construct(). Se puede ejecutar el constructor estándar en el método si fuera necesario.

Observe que cuando una antigua instancia de una clase que implemente ahora esta interfaz, la cual haya sido serializada antes de que la clase haya implementado la interfaz, es deserializada y se llama a __wakeup() en lugar de al método serialize, lo que podría ser útil para migraciones.

Sinopsis de la Interfaz

Serializable {
/* Métodos */
abstract public string serialize ( void )
abstract public void unserialize ( string $serialized )
}

Ejemplo #1 Uso básico

<?php
class obj implements Serializable {
    private 
$datos;
    public function 
__construct() {
        
$this->datos "Mis datos privados";
    }
    public function 
serialize() {
        return 
serialize($this->datos);
    }
    public function 
unserialize($datos) {
        
$this->datos unserialize($datos);
    }
    public function 
getDatos() {
        return 
$this->datos;
    }
}

$obj = new obj;
$ser serialize($obj);

var_dump($ser);

$obj_nuevo unserialize($ser);

var_dump($obj_nuevo->getDatos());
?>

El resultado del ejemplo sería algo similar a:

string(38) "C:3:"obj":23:{s:15:"Mis datos privados";}"
string(15) "Mis datos privados"

Tabla de contenidos

add a note add a note

User Contributed Notes 5 notes

up
6
grzeniufication
9 months ago
Here's an example how to un-, serialize more than one property:

class Example implements \Serializable
{
    protected $property1;
    protected $property2;
    protected $property3;

    public function __construct($property1, $property2, $property3)
    {
        $this->property1 = $property1;
        $this->property2 = $property2;
        $this->property3 = $property3;
    }

    public function serialize()
    {
        return serialize([
            $this->property1,
            $this->property2,
            $this->property3,
        ]);
    }

    public function unserialize($data)
    {
        list(
            $this->property1,
            $this->property2,
            $this->property3
        ) = unserialize($data);
    }

}
up
0
Wojciech Brozyna
24 days ago
My solution that let you serialize inherited objects.
Without specify what need to be serialized.
We want to get rid of PDO object in this example.

abstract class DefaultModel() implements \Serializable
{

    /**
    * @var PDO
    */
    private $pdo;

    /**
     * Serialize object
     *
     * @return string
     */
    public function serialize()
    {
       
        $serializable = get_object_vars($this);
       
        // unset property name that hold PDO instance
        unset($serializable['pdo']);
       
        return serialize($serializable);
       
    }

    /**
     * Unserialize object
     *
     * @param string $serialized Serialized object
     * @return DefaultModel
     */
    public function unserialize($serialized)
    {
       
        $unserialized = unserialize($serialized);
       
       // recreate PDO object
        $this->pdo = $this->createDBObject();
       
        if(is_array($unserialized) === true) {
           
            foreach($unserialized as $property => $value) {
               
                $this->{$property} = $value;
               
            }
           
        }
       
    }

}

class RealModel extends DefaultModel
{

    private $myVar;

    public function setMyVar($value)
    {

        $this->myVar = $value;

    }

}

$model = new RealModel();
$model->setMyVar('123456');

$serialized = serialize($model);
$serialized = $model->serialize();   // will also work

print_r($serialized);

$unserialized = unserialize($serialized);

print_r($unserialized);

Hope this help.
up
-1
marcos dot gottardi at folha dot REM0VE-THIS dot com dot br
4 years ago
Serializing child and parent classes:

<?php
class MyClass implements Serializable {
    private
$data;
   
    public function
__construct($data) {
       
$this->data = $data;
    }
   
    public function
getData() {
        return
$this->data;
    }
   
    public function
serialize() {
        echo
"Serializing MyClass...\n";
        return
serialize($this->data);
    }
   
    public function
unserialize($data) {
        echo
"Unserializing MyClass...\n";
       
$this->data = unserialize($data);
    }
}

class
MyChildClass extends MyClass {
    private
$id;
    private
$name;
   
    public function
__construct($id, $name, $data) {
       
parent::__construct($data);
       
$this->id = $id;
       
$this->name = $name;
    }
   
    public function
serialize() {
        echo
"Serializing MyChildClass...\n";
        return
serialize(
            array(
               
'id' => $this->id,
               
'name' => $this->name,
               
'parentData' => parent::serialize()
            )
        );
    }
   
    public function
unserialize($data) {
        echo
"Unserializing MyChildClass...\n";
       
$data = unserialize($data);
       
       
$this->id = $data['id'];
       
$this->name = $data['name'];
       
parent::unserialize($data['parentData']);
    }
   
    public function
getId() {
        return
$this->id;
    }
   
    public function
getName() {
        return
$this->name;
    }
}

$obj = new MyChildClass(15, 'My class name', 'My data');

$serial = serialize($obj);
$newObject = unserialize($serial);

echo
$newObject->getId() . PHP_EOL;
echo
$newObject->getName() . PHP_EOL;
echo
$newObject->getData() . PHP_EOL;

?>

This will output:

Serializing MyChildClass...
Serializing MyClass...
Unserializing MyChildClass...
Unserializing MyClass...
15
My class name
My data
up
-4
Olivier Pons
2 years ago
Here's the way you could implement serializable so that *ALL* descendant serialize themselves without the need of re-writing for all descendant the functions serialize() and unserialize().

Note : this will only serialize "visible" properties, this it won't serialize private descendant properties. If you dont want a property of a descendant to be serialized, make it private.

class Pot implements Serializable
{
    protected $_a;
    protected $_b;

    public function serialize()
    {
        return serialize(get_object_vars($this));
    }
    public function unserialize($data)
    {
        $values = unserialize($data);
        foreach ($values as $key=>$value) {
            $this->$key = $value;
        }
    }
}

And now one descendant:

class PotId implements Pot
{
    protected $_k;
}

class Pots implements PotId
{
    protected $_l;
}

$pots = new Pots();

and calling serialize($pots) will serialize all properties ($_a, $_b, $_k, $l).
up
-6
Anonymous
5 years ago
You can prevent an object getting unserialized by returning NULL. Instead of a serialized object, PHP will return the serialized form of NULL:

<?php
class testNull implements Serializable {
    public function
serialize() {       
        return
NULL;
    }
    public function
unserialize($data) {
    }
}

$obj = new testNull;
$string = serialize($obj);
echo
$string; // "N;"
?>

That's perhaps better than throwing exceptions inside of the serialize function if you want to prevent serialization of certain objects.
To Top