In consonance with the concepts that I deployed a few lines above, the only piece that remains still undefined is the class that creates commanded objects. In this particular case, a commanded object must expose two concrete methods, called “save()” and load()” respectively, which will perform the saving and loading operations on the object itself.

Perhaps the previous definition sounds a little bit confusing, but in fact any possible doubts that you may have will be clarified if you take a look at the signature of the mentioned commanded class. Following only my common sense, I called this class “ObjectCommanded,” and its source code is as follows:

// define 'ObjectCommanded'class

class ObjectCommanded{

	private $objectPath;

	public function __construct($objectPath){

		$this->setObjectPath($objectPath);
	}

	public function setObjectPath($objectPath){

		if(!file_exists($objectPath)){

			throw new Exception('Invalid target file to 

save object!');

		}

		$this->objectPath=$objectPath;
	}

	// auto save commanded object

	public function save(){

		if(!$fp=fopen($this->objectPath,'w')){

			throw new Exception('Error opening target 

file!');
                }

                if(!fwrite($fp,serialize($this))){

			throw new Exception('Error writing target 

file!');
		}

		fclose($fp);
	}

	// auto load commanded object

	public function load(){

		if(!$obj=unserialize(file_get_contents

($this->objectPath))){

			throw new Exception('Error loading object 

from target file!');
		}

		return $obj;
	}
}

If you examine the above class, you’ll grasp quickly what it does. As you can see, this “ObjectCommanded” class is capable of saving an instance of itself to a given text file, aside from loading this instance from the mentioned file. All these processes are performed via a serialization-unserialization sequence, something that is clearly demonstrated by the definition of the corresponding “load()” and “save()” methods.

Nevertheless, the most interesting aspect concerning the implementation of these methods has to do with the intrinsic definition for the command pattern, since they encapsulate all the logic necessary for execution in the respective commanders. Now, do you see how a self-saving object can be programmatically instructed by the two previous command classes? I guess you do!

All right, at this point you hopefully learned not only how the object command classes were properly defined, but how the respective commanded class was created too. Thus, with all these elements at our disposal, certainly it’d be very instructive if we can develop a practical example that integrates all the pieces together, implementing the already familiar command pattern.

That’s exactly what I’m going to do in the final section of this article, therefore I suggest you click on the below link and keep reading.