Aggregating objects within PHP5

by Emmanuel Ndayiragije, Jun. 26, 2010 at 12:19 PM

Scripts: PHP, MySQL

If you did not know, it is worth to know  that from PHP5 the full (OOP) Object Oriented programming paradigm is totally integrated.

In this article, i am going talk about one of the technics of OOP with PHP. If you do not have any notion in Object oriented programming, in any programming languages like Java, C++, C#, Ruby, ...
i will advise to first learn OOP paradigm or find some introduction to Object oriented programming  on the internet. You may purchase some book on this matter, if you want.
When you go OOP programming, you will in one or other way interact with some objects. Thus aggregation of object refers to a situation where one or more objects( the Aggregated objects ) are passed to another object( the Aggregating object ) to perform some operations or methods within that object that called it.

The aggregating object instatiates or creates an object of the aggregated class in its constructor method. To be able for the aggregating object calling methods or public properties of the aggragated objects, the PHP5 magic method (__call) come in handful. Within this __call method, another PHP function (call_user_func_array) comes in handy for matching the aggregated object to its called method.

May be it is not easy to figure out how it is all about. But in the classes defined here underneath, you can get it. You can also check the demonstration of this code

<?php
/**
 * Description of Product
 *
 * @author Emmanuel
 */
class Product
{
    private $name = null;
    private $price = null;
 
    public function setProdName($name=null){
        $this->name = ucfirst($name);
    }
    public function getProdName(){
        if(isset($this->name)) return $this->name;
        else return null;
    }
    public function setProdPrice($price = null){
        if(isset($price))$this->price = $price;
    }
    public function getProdPrice(){
        if(isset($this->price)) return $this->price;
    }
}
 
/**
 * Description of Buyer of the product
 *
 */
class Buyer{
    private $name = null;
 
    public function setBuyername($name){
        if(isset($name)) $this->name = $name;
    }
    public function getBuyerName(){
      if(isset($this->name)) return $this->name;
    }
}
 
/**
 * Description of ProductCategory
 *
 */
class Manufacturer
{    
    private $name = null;
    protected $product;
    protected $buyer;
 
    public function  __construct(){
        $this->product = new Product;
        $this->buyer = new Buyer;
    }
 
    //
    public function setName($name){
        if(isset($name)){
          $this->name = $name;
        }
    }
 
    //
    public function getName(){
      return $this->name ;
    }
 
    public function __call($method, $arguments){
        if(method_exists($this->product, $method)){
            return call_user_func_array(
                    array($this->product, $method),
                    $arguments
                );
        }
        //
        if(method_exists($this->buyer, $method)){
            return call_user_func_array(
                    array($this->buyer, $method),
                    $arguments
                );
        }
    }
}
 
$factory = new Manufacturer();
$factory->setName("FACTORY_1");
//Call methods from aggregated Product object
$factory->setProdName("PRODUCT_1");
$factory->setProdPrice("&euro;150,-");
//Call methods from aggregated Buyer object
$factory->setBuyerName("Emmanuel Manu");
 
echo "Manufacturer's name : ".$factory->getName()."<br/>";
echo "Product's name : ".$factory->getProdName()."<br/>";
echo "Product's price : ".$factory->getProdPrice()."<br/>";
echo "Buyer : ".$factory->getBuyerName()."<br/>";
?>

If you would want to see the code of the classes above in action, go to this link for demonstration. The echo's in the code will print up the name of the factory, product's name and its price, the  name of the buyer

DEMONSTRATION>>

If we talk about performance issues, the advantages of aggregating objects within other objects mainly come from its lower overload, since most of the time only one object is shared by other objects. However, this advantage might be discarded in the case of having a class for database connection shared by other multiple classes. You may run into difficulties if multiple database connections are established to the same server, causing a noticeable detriment to the system, particularly if your site is attracting many visitors.

Of course it is not a good idea to design your DB object with Objects Aggregation, instead the Singleton Pattern may be in this case, providing one and only existing object for DB, very useful. This is to avoid creating new instances of a DB class with key (new) and end up with overheading the system beacause every instantiated object is kept in the memory of the system.

Patterns in PHP is also very important to effectively and efficiently design not only webapplications but also any soft. applications. Patterns topics will come in the latter articles.

Post Comment|

Permant links

Tweet

Available Comments :

Your Attention! Please do not post message with spam on this blog. We try to be cool to each other and post relevant comments and relating to the appropriated topic or entry. Let's try to get a nice conversation over here.

Leave a comment

Name :Required!
(Valid) Email :Required!
Website :
Fill with the code : Required!
Comments :Required!