Will Fitch&#039;s Blog

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

The Observer Pattern: OOP Techniques in PHP

Posted on 09. Mar, 2009 by Will Fitch.

0

The observer pattern provides another way to maintain loose coupling within your code. It’s an extremely simple pattern and is implemented similarly across languages. There are two parts: the observer and the observable object. Let’s address them both starting with the observer.

The Observer

PHP

<?php
interface IObserver
{
        /**
         * Method called on event change
         * 
         * @param mixed $sender
         * @param mixed $args
         */
        public function onChange($sender, $args);
}
?>

As you can see from above, the observer implements a single method called onChange. This method is executed when the observable class changes. The first parameter is typically the instance of the class changing and the second arguments relative to the change. Now let’s look at the IObservable interface:

The Observable Object

PHP

<?php
interface IObserverable
{
        /**
         * Add an observer
         * 
         * @param mixed $obj
         */
        public function addObserver($obj);
}
?>

The observable class provides a method for one or more observers to be notified. The observable class needs to maintain a list of these observers and notify them when necessary. A common usage of this is a logging mechanism that needs to be notified when data is created, updated and deleted.

PHP

_observers);
			 $i < $count; $i++)
		{
			$this->_observers[$i]->onChange($this, $args);
		}
	}

	public function deleteUser($id)
	{
		$db->deleteUser($id);
		$this->notifyObservers(array('user_id'=>$id));
	}

	public function addObserver($obj)
	{
		// Add logic for interface implementation check here if you want.
		$this->_observers[] = $obj;
	}
}

$user = new User();
$user->addObserver(new UserLogging());
$user->deleteUser(55);
?>

PHP

<?php
 
class UserLogging implements IObserver
{
                
        public function onChange($sender, $args)
        {
                // Log the changes (we echo here)
                echo ‘The class is ‘.get_class($sender).‘ and the arguments are ‘.print_r($args,1);
        }
}
 
class User implements IObserverable 
{
        private $_observers=array();
        
        private function notifyObservers($args)
        {
                for ($i=0, $count=count($this->_observers); 
                         $i < $count; $i++)
                {
                        $this->_observers[$i]->onChange($this, $args);
                }
        }
        
        public function deleteUser($id)
        {
                $db->deleteUser($id);
                $this->notifyObservers(array(‘user_id’=>$id));
        }
        
        public function addObserver($obj)
        {
                // Add logic for interface implementation check here if you want.
                $this->_observers[] = $obj;
        }
}
 
$user = new User();
$user->addObserver(new UserLogging());
$user->deleteUser(55);
?>

Not only does this provide you some pseudo event access, but this is a much cleaner, maintainable implementation of observing a particular object.

Conclusion

I hope you find ways at work to implement this use pattern. We more often than not get caught up with getting code written (it comes with the territory) and lose sight of these power and proven designs to get the job done. I’m certainly just as much to blame as the next developer! Hope this helps!

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

The Iterator Pattern: OOP Techniques in PHP

Posted on 04. Mar, 2009 by Will Fitch.

2

The iterator pattern is one of the most useful, yet unused patterns defined. It provides a way for class users to count and iterate over a set of objects related to the class. This is very useful in MVC (Model-View-Controller) models as they handle data and the logic that pertains to it.

PHP provides two interfaces that already define what you should include in an iterator pattern: Iterator and Countable. Below are their definitions:

Iterator Interface

PHP

<?php
interface Iterator implements Traversable
{
    public mixed current();
    public scalar key();
    public void next();
    public void rewind();
    public bool valid();
}
?>

Countable Interface

PHP

<?php
interface Countable
{
    public int count();
}
?>

You can already iterate over class properties using the foreach() loop, so the Iterator and Countable interfaces are domain specific — meaning the iteration logic is specific to the functionality of the class.

As an example, let’s assume we have a domain model that manages users (CRUD). We have an additional class that acts as a structure (you don’t have to do this, but it’s easier to read in a blog) for each individual user. You also have a method that retrieves an arbitrary number of users, assigns each to a User class (acting as a struct), and gives back an array. While this is certainly doable, the iterator pattern defines an easier way to process the data.

Example Before Iterator Pattern

PHP

<?php
 
class User
{
        public $email;
        public $address;
        public $city;
        public $state;
        public $zip;
}
 
class User_Management
{
        /**
         * List of users
         */
        private $users=array();
        
        public function getUserByID($id)
        {
                // go get a user and assign it an instance of User
        }
        
        public function getAllUsers()
        {
                // go get all users, assign each to User class, and add to the self::users array
        }
        
}
 
?>

The above example is pretty typical for domain models without the use of iterator. Adding the iterator, we provide an interface to bi-directionally traverse, get key information and count records.

With the Iterator Pattern Implemented

PHP

users[$this->position];
	}

	/**
	 * Return the current key index
	 */
	public function key()
	{
		return $this->position;
	}

	/**
	 * Increment the iterator index
	 */
	public function next()
	{
		++$this->position;
	}

	/**
	 * Reset the position
	 */
	public function rewind()
	{
		$this->position = 0;
	}

	public function getUserByID($id)
	{
		// go get a user and assign it an instance of User
	}

	/**
	 * Validate whether a record at current
	 * position exists
	 */
	public function valid()
	{
		return (isset($this->users[$this->position]));
	}

	/**
	 * Return the total number of users
	 */
	public function count()
	{
		return count($this->users);
	}

	public function getAllUsers()
	{
		// go get all users, assign each to User class, and add to the self::users array
	}

}

?>

PHP

<?php
 
class User
{
        public $email;
        public $address;
        public $city;
        public $state;
        public $zip;
}
 
class User_Management implements Iterator, Countable
{
        /**
         * List of users
         */
        private $users=array();
        
        /**
         * Position of the iterator
         */
        private $position=0;
        
        /**
         * Retrieve the current record
         */
        public function current()
        {
                return $this->users[$this->position];           
        }
        
        /**
         * Return the current key index
         */
        public function key()
        {
                return $this->position;
        }
        
        /**
         * Increment the iterator index
         */
        public function next()
        {
                ++$this->position;
        }
        
        /**
         * Reset the position
         */
        public function rewind()
        {
                $this->position = 0;
        }
        
        public function getUserByID($id)
        {
                // go get a user and assign it an instance of User
        }
        
        /**
         * Validate whether a record at current 
         * position exists
         */
        public function valid()
        {
                return (isset($this->users[$this->position]));
        }
        
        /**
         * Return the total number of users
         */
        public function count()
        {
                return count($this->users);
        }
        
        public function getAllUsers()
        {
                // go get all users, assign each to User class, and add to the self::users array
        }
        
}
 
?>

The domain model now implements Countable and Iterator. The below example shows a couple of uses for this:

PHP

 $value)
{
	// The $index will contain the current key
	// while the $value will contain the user
	// at the current position
	echo $value->address;
}
// Rewind the iterator
$iterator->rewind();

while ($iterator->valid())
{
	$value = $iterator->current();
	echo $value->address;
	$iterator->next();
}

// Rewind the iterator
$iterator->rewind();

for ($iterator->key(); $iterator->valid(); $iterator->next())
{
	$value = $iterator->current();
	echo $value->address;
}

?>

PHP

<?php
 
$iterator = new User_Management();
foreach ($iterator as $index => $value)
{
        // The $index will contain the current key
        // while the $value will contain the user 
        // at the current position 
        echo $value->address;
}
// Rewind the iterator
$iterator->rewind();
 
while ($iterator->valid())
{
        $value = $iterator->current();
        echo $value->address;
        $iterator->next();
}
 
// Rewind the iterator
$iterator->rewind();
 
for ($iterator->key(); $iterator->valid(); $iterator->next())
{
        $value = $iterator->current();
        echo $value->address;
}
 
?>

Conclusion
This is a much cleaner, easier approach to iterating over objects. I hope you find this usable in your domain models!

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

The Factory Pattern: OOP Techniques in PHP

Posted on 02. Mar, 2009 by Will Fitch.

0

The purpose of the factory pattern is to assist with maintaining loose coupling. Code that is tightly coupled is error prone in that if a class is changed, it can have a domino affect to other scripts using it. This is typical to large-scale systems and smaller systems that grow very fast.

For example, let’s assume you have a relatively small system that contains a class called Users. This class reads user data from a small file located on disk. Your system booms, and you need to move to a RDBMS (Relational Database Management System). Because of this, your methods in the class, data source and other items change, breaking the code that is utilizing the Users class. This is where the factory pattern comes in.

The factory pattern’s purpose is to contain methods that create objects for you. Instead of directly instantiating the Users class, you request an instance from a factory class (we’ll call it UsersFactory), and call a static method (we’ll call it getInstance).

Example

PHP

_userId = $id;
	}
}

class UsersFactory
{
	public static function getInstance($id)
	{
		return new Users($id);
	}
}

$user = UsersFactory::getInstance($id);
?>

PHP

<?php
class Users
{
        private $_userId;
        public function getUserById()
        {
                // go get a user
        }
        
        public function __construct($id)
        {
                $this->_userId = $id;
        }
}
 
class UsersFactory
{
        public static function getInstance($id)
        {
                return new Users($id);
        }
}
 
$user = UsersFactory::getInstance($id);
?>

The example above demonstrates how a factory method would work. Now, let’s add in that new class that gets the users from the database. Let’s assume you have 25 other scripts that use the existing class. You can create the new Users_From_DB class and create a static method to reference that as well.

PHP

_userId = $id;
	}
}

class Users_From_DB
{
	// same class only from db
}

class UsersFactory
{
	public static function getInstance($id)
	{
		return new Users($id);
	}

	public static function getUsersFromDB($id)
	{
		return new Users_From_DB($id);
	}
}
?>

PHP

<?php
 
class Users
{
        private $_userId;
        public function getUserById()
        {
                // go get a user
        }
        
        public function __construct($id)
        {
                $this->_userId = $id;
        }
}
 
class Users_From_DB
{
        // same class only from db 
}
 
class UsersFactory
{
        public static function getInstance($id)
        {
                return new Users($id);
        }
        
        public static function getUsersFromDB($id)
        {
                return new Users_From_DB($id);
        }
}
?>

This allows you to maintain a loose coupling with a class that could create major problems in the event it goes through major changes.

Conclusion

I have seen where some use the factory pattern as a singleton. They look similar but serve two very different purposes. Take the code below:

PHP

<?php
 
class Users_Model
{
        public function getUserById($id)
        {
                // do something
        }
}
 
class Model
{
        private static $instances=array();
        
        public static function factory($model_name)
        {
                if (array_key_exists($model_name, self::$instances))
                {
                        return self::$instances[$model_name];
                }
                return self::$instances[$model_name] = new $model_name();
        }
}
 
$model = Model::factory(‘Users_Model’);
$model2 = Model::factory(‘Users_Model’);
?>

While the case could be made that it is acting as a factory pattern, it is being used more as a singleton, maintaining a single instance of a class.

The factory pattern does a really good job, and like the singleton, it serves a very specific purpose.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

The Singleton Pattern: OOP Techniques in PHP

Posted on 02. Mar, 2009 by Will Fitch.

4

The singleton pattern is a common pattern used to make resources exclusive in that there is one of a particular type of resource. The most common usage of this is database connectivity. Typically, an application only wants a single connection to a single database server at any given time. Another use could be restricting the instance to a specific number of objects. This is where the singleton pattern comes in.

The singleton pattern is defined as a design pattern that is used to restrict instantiation of a class to one object (or limit number of instances). This is a pretty straight forward concept and works well with many other OOP techniques including the factory pattern. The easiest implementation is to create a public static method within that class that instantiates a new instance.

Example

PHP

_con->close();
    }

    private function __construct()
    {
    	$this->_con = new DB::connect('connection_string');
    }

}
?>

PHP

<?php
class DB_Connection
{
        private $_con = null;
        
    public static function getInstance()
    {
        static $instance=null;
        if ($instance === null)
            $instance = new DB_Connection();
        return $instance;
    }
    
    public function query($sql)
    {
        // DO SOME CODE TO RUN A QUERY HERE
    }
    
    public function __destruct()
    {
        $this->_con->close();
    }
 
    private function __construct()
    {
        $this->_con = new DB::connect(‘connection_string’);
    }
 
}
?>

You’re probably wondering why the class constructor is private. This seems odd as it’s impossible to create an object from outside the class, right? That’s the point. If we don’t limit the class instantiation, the singleton pattern is useless. The method getInstance() can create an object as it’s a member of that class.

How does the static method work?

The static method getInstance() declares a static variable called instance ($instance). The first time this method is called, the $instance variable’s value is null. We then check if the value is null — if it is, we create a new instance of DB_Connection — if it is not, we return the current instance.

Static variables work by declaring the static keyword, then continuing on with the normal variable initialization. The variable will maintain it’s assigned value (whether changed or not) throughout the life of the script.

The second time the getInstance() is called, the $instance variable contains the instance of DB_Connection, and we will return that value. Regardless of how many instances are created of this class, only one object is initialized.

Conclusion

As you can see, the singleton pattern certainly has it’s uses, albeit specific. Keeping the OOP design patterns in mind makes for a cleaner, easier to maintain code base for future developers picking up your projects.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

Zip Code Web Service Updates

Posted on 12. Jan, 2009 by Will Fitch.

0

I have updated the zip code web service to fix some issues with the data returned from getLocalTime. Prior to this fix, only the 12 hour format was displayed without the proper meridiem (AM or PM). The time was also off by one hour.

This fix adds two additional children:

currentMilitaryTime – The 24 hour time format
currentMeridiemTime – The 12 hour time format with AM or PM

I have left the currentTime element for backwards compatibility. I do plan on removing it when I release the new zip code web service some time this month.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

Call for Zip Code Web Service Methods

Posted on 15. Aug, 2008 by Will Fitch.

0

I have developed a new version of the zip code web service. This new service offers much more functionality than the previous, including 100% document-literal WS-I/WSDL 1.1 compliancy and SOAP 1.1 and 1.2 capabilities.

Along with this, a Java, PHP, .NET and Ruby SDK will be developed so that you only have to worry about making class calls rather than interfacing with SOAP and the network. I will also be increasing the number of elements returned from 300 to 500.

This new service will require that you register your application (domain only, no login) so that I can get an idea of the usage of this service. Your data will not be shared/sold to anyone, I just want some statistics.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

The Zend Certification Exam: What to Expect

Posted on 27. Apr, 2008 by Will Fitch.

11

The Zend Certification Exam is a step in the right direction for PHP developers looking to enhance their resume and prove their skills. It is becoming accepted by recruiters worldwide and in some cases, demanded by corporations seeking employees. Achieving this certification is no easy task, though. It requires working experience with PHP, as well as the technologies associated with it.

The test consists of 70 questions and you have 90 minutes to complete them. You may skip between questions and revisit those that you skipped. You will likely finish the examination in 30 to 45 minutes (purely personal experience), so take the other half and check your answers.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

Using PHP Namespaces

Posted on 24. Apr, 2008 by Will Fitch.

9

PHP 5.3 introduces a much requested feature for object-oriented programmers: namespaces. At the time of this writing, version 5.3 of PHP was in development, but is planned on being released in the near future.

One of the purposes object-oriented programming is to remove ambiguous development and data access items. This basically means identifying common functionality and creating the most reusable framework possible, typically in the form of classes. When creating this functionality, you will begin to have issues with naming conventions and narrowing down functionality even further. To resolve this scoping issue, namespaces allow you to contain those bits of code even more.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

Simple XML (SimpleXML) Tutorial Part 1

Posted on 23. Apr, 2008 by Will Fitch.

17

With the increasing use of web services and communications via HTTP, XML has become an industry standard for sending and receiving data among systems. Every language seems to have multiple ways to parse XML, each more complicated than the other. This presents a problem for developers.

The majority of the time, developers need to read/write XML files without complex features such as advanced namespacing and XSD validation. It seems that opening an XML file, reading and using the content takes forever as you constantly need to reference hundreds of pages of documentation, Google examples of each method or function in the documentation; it never ends.

Since the release of PHP5, SimpleXML has been available for creating and editing XML files or strings. Don’t let the name fool you, it doesn’t represent the simplicity of its capabilities. It does, however, mean the implementation of this extension is simple! PHP has other XML capabilities such as DOM, XMLWriter and XMLReader in the event you need those advanced features not offered by the native SimpleXML extension.

Close Bookmark and Share This Page

Copy HTML:

If you like this then please subscribe to the RSS Feed.

Continue Reading

SOAP Zip Code Web Service!

Posted on 26. Jul, 2007 by Will Fitch.

22

I have completed the major functionality to the SOAP integration of the zip code services. The following methods can be used to get the data you need:

getDistanceByZip – Get the distance from one zip code to another
getZipsByRadius – Get GPS information within (X) miles of a zip code
getLocalTime – Get the local time for a zip code

I am going to describe each function in depth, and give examples of each in a few languages. If you have suggestions to this service, feel free to contact me using the contact form.

About the Service

This web service is provided absolutely free. Please don’t abuse this. If requests start getting out of hand and bringing my server to its knees, I will start limiting the number of queries per user per day. I don’t want to do this, but I do like my server actually serving .

It is an RPC style web service, as it really isn’t complicated and is limited to a very specific audience. It’s also easier for developers to use and understand in comparison to document-literal.