For those of you new to serializing objects in PHP, let me emphasize an important feature that can be used for different purposes: if you use the “serialize()” function on a specific object, the PHP interpreter will check whether there is a method called “__sleep()” and run its corresponding code prior to any serialization, assuming that this method has been defined.

In a similar way, if the “unserialize()” function is applied to an object, the PHP parser will look for a method named “__wakeup()” and try to execute any code wrapped inside of it, before proceeding to unserialize the object in question.

Since these functions are called transparently by the interpreter, it’s possible to create classes that take advantage of this automated process, in order to perform some useful tasks.

To properly understand the concepts I deployed before, take a look at the following sample class, which displays a simple message each time the “__sleep()” and “__wakeup()” functions are called respectively:

class ObjectSaver{
    var $objectFile;
    function ObjectSaver($objectFile='defaultDir/objects.txt'){
        $this->objectFile=$objectFile;
        $this->save();
    }
    // save serialized object to file
    function save(){
        if(!$fp=fopen($this->objectFile,'w')){
            trigger_error('Error opening object file',E_USER_ERROR);
        }
        if(!fwrite($fp,serialize($this))){
            trigger_error('Error writing data to object
file',E_USER_ERROR);
        }
        fclose($fp);
    }
    // fetch unserialized object from file
    function open(){
        if(!$obj=unserialize(file_get_contents($this-
>objectFile))){
            trigger_error('Error fetching object from
file',E_USER_ERROR);
        }
        return $obj;
    }
    // define '__sleep()' method
    function __sleep(){
        echo 'This method was called prior to serializing the
object!<br />';
        return array_keys(get_object_vars($this));       

    }
    // define '__wakeup()' method
    function __wakeup(){
        echo 'This method was called after unserializing the
object!<br />';
    }
}

In this case, I redefined the previous “ObjectSaver” class, and added to its signature the corresponding “__sleep()” and “__wakeup()” methods, so that it will display a basic message whenever they’re called up.

After defining the modified “ObjectSaver” class, a basic -- yet illustrative -- demonstration of how these magic methods are called by the PHP interpreter is listed below:

// show the functionality of __sleep() and __wakeup() methods
$objSaver=&new ObjectSaver();
$newObj=$objSaver->open();

If you run the above script, you’ll get the following output:

This method was called prior to serializing the object!
This method was called after unserializing the object!

As you can see, the example above shows that each time the “save()” and “open()” methods are called -- remember that these methods internally use the respective “serialize()/unserilalize() PHP functions –- the “__sleep()” and “__wakeup()” methods are also invoked, in this way displaying the messages shown above.

Even though the previous example may seem rather rudimentary, it serves to demonstrate how these magic methods are called in a transparent way by the PHP interpreter. However, this recently-acquired knowledge about how these methods work can be used for performing more useful tasks than displaying basic messages.

Keeping in mind the ability that PHP offers to call internally the mentioned methods, in the next section I’ll show you how to create objects that persist across several page requests without using any session mechanism. Go ahead and keep reading.