Object registry and Observers...

The build on Chris's application is going well and we have finished implementing the core tiered architecture!

The first step was to construct a simple object registry so that the individual components can be shared via a composite pattern. In a nutshell, it is a basic text book Singleton with a twist. The code looks like this:

Singleton object registry class

001  002  003  004  005  006  007  008  009  010  011  012

<?php class Singleton{     function &getInstance ($class, $name = ''){         static $registry = array();         $_instanceName = notNull($name) ? $name : $class;         if ( !isset($registry[$class][$_instanceName]) || !is_object($registry[$class][$_instanceName]) ) {             $registry[$class][$_instanceName] =& new $class;         }         return $registry[$class][$_instanceName];     } } ?>

The code above is the backbone of the application since it is completely object oriented. The benefit is that the code (classes or objects) are reusable and are able to be shared among all yet only instantiated once. This adds tremendous flexibility while keeping system resource utilization to a minimum as the registry contains only references to the objects and NOT copies of the objects.

The bottom line is that the category pages are rendering in less than .03 seconds with .005 total MySQL time (of course, no caching yet). Almost forgot...only 5 queries! The performance is blistering fast and infinitely scalable * to the limits of MySQL*. The reason for the outstanding performance is that the application was coded from the bottom up with an eye on performance. Since we are sharing objects we eliminated a lot of redundant database queries and processing overhead with multiple instantiation.

In addition, we have implemented an Observer / Listener pattern. This will form the backbone of the first plug-and-play eCommerce shopping cart! Admittingly, our beta code is far from perfect but has tremendous potential. The idea is the place strategic hooks in the business logic (and maybe objects) which will enable notification to event Listeners. Thus far we have implemented 2 core systems that use the Observer pattern: error logging and also script/performance timers. Here is the base class:

Observer pattern class

001  002  003  004  005  006  007  008  009  010  011  012  013  014  015  016  017  018  019  020  021  022  023  024  025  026  027  028  029  030  031  032  033  034  035  036  037  038  039  040

<?php class Observer{     var $_observers;     var $_message;          function Observer(){         $this->_observers = array();         $this->_message = NULL;     } # end constructor          function attach(&$observer){         $this->_observers[] =& $observer;     } # end function          function detach(&$observer){         foreach ( array_keys($this->_observers) as $key ){             if ($this->_observers[$key] === $observer){                 unset($this->_observers[$key]);                 return;             } # end if         } # end foreach     } # end function          function notify(){         foreach ( array_keys($this->_observers) as $key ){             $observer =& $this->_observers[$key];             $observer->update($this);         } # end foreach     } # end function          function getState(){         return $this->_message;     } # end function          function setState($info){         $this->_message = $info;         $this->notify();     } # end function     } # end class ?>

...example instantiation of Observer object and attachment of event hander

001  002  003  004  005  006  007  008  009  010  011  012  013  014  015  016  017  018  019  020  021  022  023  024  025  026  027  028  029

<?php ///////// // This code is in application_top.php ///////// /* * Initialize the error handler (observer) class as a Singleton * and attach the screen output object */     $errorHandler =& Singleton::getInstance('Observer', 'ErrorHandler');     $errorHandler->attach(Singleton::getInstance('ScreenOutputErrorLogger')); /* * Set the custom error handler function */     set_error_handler('observerErrorHandler'); ///////// // This code is a general (callback) function /////////   function observerErrorHandler($errno, $errstr, $errfile, $errline, $errcontext){       $handler =& Singleton::getInstance('Observer', 'ErrorHandler');     $handler->setState( array('number' => $errno,                               'msg' => $errstr,                               'file' => $errfile,                               'line' => $errline                               )                       );   } ?>

ScreenOutputErrorLogger event handler class

001  002  003  004  005  006  007  008  009  010  011  012  013  014  015  016  017  018  019  020  021  022  023  024  025  026  027  028

<?php class ScreenOutputErrorLogger{     var $_errors;          function ScreenOutputErrorLogger(){         $this->_errors = array();     } # end constructor          function update(&$error_handler){         $error = $error_handler->getState();         $this->_errors[] = $error;     } # end function          function errorCount(){         return sizeof($this->_errors);     } # end function          function output($hidden = false){         if ($hidden) echo '<!--' . "\n";         echo '<h1>Errors:</h1>' . "\n";         echo '<pre>' . "\n";         print_r($this->_errors);         echo '</pre>' . "\n";         if ($hidden) echo '//-->' . "\n";     } # end function      } # end class ?>

The basic operation is that once an Observer is instantiated other objects can register as an event handler. The great benefit is that there can be multiple event handlers for each! So, the ErrorHandler object is instantiated and then directly after that the ScreenOutputErrorLogger is attached. Thus, every non-fatal error that is triggered will send the Listener state to every object that is registered for notification (right now only the screen logger). The flexibility in this system is that other objects can be registered as well. As an example, we will create the email object next which can be registered as an event handler and email the administrator on database errors (instead of killing the script). In fact, we can create as many event handlers as we want. There could easily be a logger event handler that saves the errors to database or text file. The point is that event handlers can be attached and detached as needed without affecting the function of the others.

Another development milestone is the true tiered architecture. We have implemented a classic 4 tier architecture: presentation (template engine), business logic (meat and bones manipulating object interaction), accessor (database access), and persistence (database). We have tested the architecture by placing each tier on a different server that is physically separate from the others. The application performed beautifully and is confirmation the tiered architecture is complete and bug free.

This ground-up build has enabled me to finally implement my custom rolled template engine! There is no PHP in the templates and is completely separate from the code. Thus, inexperienced webmasters can tweak and modify the templates all they want without ever corrupting the core code. In addition, I feel a robust templating engine will afford more designers to quickly create skins. Here is the template class code:

Template engine class

001  002  003  004  005  006  007  008  009  010  011  012  013  014  015  016  017  018  019  020  021  022  023  024  025  026  027  028  029  030  031  032  033  034  035  036  037  038  039  040  041  042  043  044  045  046  047  048  049  050  051  052  053  054  055  056  057

<?php class Template{          var $template;     var $variables;          function Template($template = ''){                 $this->template = notNull($template) ? file_get_contents($template) : NULL;     } # end class constructor          function Add($var_name, $var_data){         $this->variables[$var_name] = $var_data;     } # end fucntion Add()     function AddMulti($var_data){         if (is_array($var_data)){             foreach ( $var_data as $name => $data ){                 $this->variables[$name] = $data;             }         }     } # end fucntion Add()     function ResetVars(){         $this->variables = NULL;     } # end function          function EvaluateTag($data, $tag, $params = NULL){         $_tag = '<' . $tag;         if (notNull($params)){             $_tag .= ' ' . $params;         }         $_tag .= '>' . $data . '</' . $tag . '>' . "\n";         return $_tag;     } # end function          function Remove($vars){         if ( is_array($vars) ){             foreach ( $vars as $index => $varname ){                 unset( $this->variables[$varname] );             } # end foreach         } else {             unset($this->variables[$vars]);         }     } # end fucntion Add()          function Evaluate($direct_output = false){         $template = addslashes($this->template);                 foreach ( $this->variables as $variable => $data ){             $$variable = $data;         } # end foreach                 eval("\$template = \"$template\";");                 if ( $direct_output ) echo stripslashes($template);         else return stripslashes($template);             } # end function Evaluate()      } # end class ?>

As you can see, we are making good progress on the build and will soon move onto finalizing the beta version of the shopping cart! However, there is still much left to do in order to launch this project. I still need to coordinate the acquisition of a dedicated server to host the project Subversion server. In addition, we need to attract a community to help in the beta testing. It is almost time to launch!

...almost there...stay tuned!