Claudiu Persoiu

Blog-ul lui Claudiu Persoiu


Archive for 10 October 2009

Singleton pattern in PHP

without comments

Probably the most popular pattern form PHP and not only.

Motivation:

Restriction to a single instance of a resource across the app, accessible from anywhere.

Diagram:

singleton

Implementation:

The classic example for PHP is the database resource. The database connection must be unique across the app, not to establish multiple connections to the database and as a consequence resources to be wasted.

For a single instance to exist the constructor must only be accessible from a static method, and the resulting object must not have the posibillity to be cloned. Also the class must not be extensible.

Example:

// db connection information
define ( 'DB_HOST', 'localhost' );
define ( 'DB_USER', 'user' );
define ( 'DB_PASS', 'pass' );
define ( 'DB_DATABASE', 'db' );

/**
 * Singleton class for database connection management using mysqli
 */
final class SingletonDB {

     /**
      * Singleton instance
      *
      * @var SingletonDB
      */
     protected static $_instance = null;

     /**
      * Connection resource
      *
      * @var resource
      */
     protected $_connection = null;

     /**
      * Constructor which also connects to the database
      *
      */
     protected function __construct() {
          // connection to database server
          $this->_connection = new mysqli ( DB_HOST, DB_USER, DB_PASS );

          // in case of an error connection an exception is thrown
          if ($this->_connection->connect_error) {
               throw new Exception ( 'Error connection to mysql server' );
          }

          // selecting the database
          $this->_connection->select_db ( DB_DATABASE );

          // in case of an error selecting the database an exception is thrown
          if ($this->_connection->error) {
               throw new Exception ( 'Error selecting database' );
          }

     }

     /**
      * Run SQL queries
      *
      * @param string $query SQL query
      * @return mysqli_result
      */
     public function query($query) {
          return $this->_connection->query ( $query );
     }

     /**
      * Access for error messages
      *
      * @return string
      */
     public function error() {
          return $this->_connection->error;
     }

     /**
      * Method that is called when cloning an object
      * Is protected so is not possible to clone the object
      *
      */
     protected function __clone() {
     }

     /**
      * Close connection and destroy the object
      *
      */
     public function __destruct() {
          $this->_connection->close ();
     }

     /**
      * Method that returns an SingletonDB instance
      *
      * @return SingletonDB
      */
     public static function getInstance() {
          if (self::$_instance == null) {
               self::$_instance = new SingletonDB ( );
          }

          return self::$_instance;
     }
}

try {
     // SingletonDB instance
     $db = SingletonDB::getInstance ();

     // Query to be run
     $q = 'SELECT * FROM test';

     // the query will return an mysqli_result object
     $result = $db->query ( $q );

     // check for errors and display them
     if ($db->error ()) {

          echo $db->error ();

     } else {
          // extract the result and display
          while ( $row = $result->fetch_assoc () ) {
               var_dump ( $row );
          }
          // close mysqli_result object
          $result->close ();
     }
// in case of exception there is displayed
} catch ( Exception $e ) {
     echo $e->getMessage ();
}

Written by Claudiu Persoiu

10 October 2009 at 8:33 PM

Iterating objects using PHP and SPL

without comments

Iterator patter is probably the most popular pattern from SPL. Is a very simple way to demonstrate the advantages of an interface and SPL.

Motivation:
The possibility of iterating object type structures, using functions like foreach(), var_dump(), print_r() etc.

Diagram:

iterator diagram

Iterator structure:

In SPL there are a lot of interfaces and classes for iteration.

Iterator interface base structure:

/**
 * Iterator interface from SPL
 */
Iterator extends Traversable {
      /**
       * Returns the current element
       */
      abstract public mixed current ( void )

      /**
       * Returns the key of the current element
       */
      abstract public scalar key ( void )

      /**
       * Moves to the next element in the array
       */
      abstract public void next ( void )

      /**
       * Reset the iteration to the initial position
       */
      abstract public void rewind ( void )

      /**
       * Check to see if the current position is valid
       */
      abstract public boolean valid ( void )
}

Example 1:

A simple iterator object.

/**
 * The class for the iterator object
 */
class Iterabil implements Iterator {

	/**
	 * The index for the iterated element
	 */
	private $_current = 0;

	/**
	 * Array with elements to iterate
	 */
	private $_elements = array();

	/**
	 * Constructor
	 *
	 * @param array $elements Elements to iterate
	 */
	public function __construct($elements) {
		$this->_elements = $elements;
	}

	/**
	 * Current element
	 *
	 * @return mixed Current element
	 */
	public function current() {
		return $this->_elements[$this->_current];
	}

	/**
	 * Current index
	 *
	 * @return integer Current index
	 */
	public function key() {
		return $this->_current;
	}

	/**
	 * Move to the next index
	 */
	public function next() {
		$this->_current++;
	}

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

	/**
	 * Check if the current element is set
	 *
	 * @return boolean If the current element is set
	 */
	public function valid() {
          return isset($this->_elements[$this->_current]);
     }
}

// class instance
$obj = new Iterabil(array(1, 2, 3, 4, 5));

// iterate object
foreach ($obj as $value) {
     echo $value.PHP_EOL;
}

// output:
// 1
// 2
// 3
// 4
// 5

Example 2:

Another example a little more complex, a class that allows to iterate through the public properties of a class which extends it. Iterator and Reflection are used.

/**
 * Class which iterates through the public properties of a class which extends it
 */
class Iterabil implements Iterator {

     /**
       * The index for the iterated element
       */
     private $_current = 0;

     /**
      * Array with elements to iterate
      */
     private $_elements = array();

     /**
      * Current element
      *
      * @return mixed Current element
      */
     public function current() {
          return $this->_elements[$this->_current]->name;
     }

     /**
      * Current index
      *
      * @return integer Current index
      */
     public function key() {
          return $this->_current;
     }

     /**
      * Move to next index
      */
     public function next() {
          $this->_current++;
     }

     /**
      * Reset index and get the properties
      */
     public function rewind() {
          // rewind is the first to be called
          // here the properties list should be obtained
          // ReflectionClass is initialized
          // with the current class name as a parameter
          $reflection = new ReflectionClass(get_class($this));

          // we get the public properties
          $this->_elements = $reflection->getProperties(ReflectionMethod::IS_PUBLIC);

          // set the current index
          $this->_current = 0;
     }

     /**
      * Check if the current element is set
      *
      * @return boolean If the current element is set
      */
     public function valid() {
         return isset($this->_elements[$this->_current]);
    }
}

/**
 * A new class with public properties
 *
 */
class Testing extends Iterabil {
     public $proprietate1;
     public $proprietate2;
}

// class instance
$obj = new Testing();

// iterate object
foreach ($obj as $value) {
     echo $value.PHP_EOL;
}

// output:
// proprietate1
// proprietate2

And if you what the above example to be accessible as an array you just have to implement ArrayAccess from SPL.

ArrayAccess structure:

ArrayAccess   {
    /**
     * Check if the offset exists
     */
    abstract public boolean offsetExists ( string $offset );

    /**
     * Returns the element of an offset or NULL if it does not exist
     */
    abstract public mixed offsetGet ( string $offset );

    /**
     * Set a value for an offset
     */
    abstract public void offsetSet ( string $offset , string $value );

    /**
     * Unset a value for an offset
     */
    abstract public void offsetUnset ( string $offset )
}

Example 3:

An even more complicated example which shows the power of interfaces from SPL. Iterator object accessible like an array.

To simplify the array access logic I’ve used the php native functions for iterating an array (next(), reset()).

/**
 * The class for the iterator object
 */
class Iterabil implements Iterator, ArrayAccess, Countable {

     /**
      * Array with elements to iterate
      */
     private $_elements = array();

     /**
      * Constructor
      *
      * @param array $elements Elementele de iterat
      */
     public function __construct($elements) {
          $this->_elements = $elements;
     }

     /**
      * Current element
      *
      * @return mixed Current element
      */
     public function current() {
          return current($this->_elements);
     }

     /**
      * Current index
      *
      * @return integer Current index
      */
     public function key() {
          return key($this->_elements);
     }

     /**
      * Move to the next index
      */
     public function next() {
          next($this->_elements);
     }

     /**
      * Reset index
      */
     public function rewind() {
          reset($this->_elements);
     }

     /**
      * Check if the current element is set
      *
      * @return boolean If the current element is set
      */
     public function valid() {
          return current($this->_elements)?true:false;
    }
    /**
     * Check if the offset exists
     *
     * @param string $offset Element key
     * @return boolean If the element is set
     */
    public function offsetExists($offset) {
         return isset($this->_elements[$offset]);
    }

    /**
     * Returns the element of an offset or NULL if it does not exist
     *
     * @param string $offset Array offset
     * @return mixed Element or NULL
     */
    public function offsetGet($offset) {
         return $this->_elements[$offset];
    }

    /**
     * Set a value for an offset
     *
     * @param string $offset Element offset
     * @param mixed $value Value of the element in the array
     */
    public function offsetSet($offset, $value) {
         $this->_elements[$offset] = $value;
    }

    /**
     * Unset a value for an offset
     *
     * @param string $offset Element offset
     */
    public function offsetUnset($offset) {
         unset($this->_elements[$offset]);
    }

    /**
     * Number of elements in the array
     *
     * @return integer Number of elements in array
     */
    public function count() {
         return count($this->_elements);
    }
}

// Class instance
$obj = new Iterabil(array(1, 2, 3, 4, 5));

echo 'Iteration using "for":'.PHP_EOL;

// iterate the object like a simple array
for($i = 0; $i < count($obj); $i++) {
     echo $obj[$i].PHP_EOL;
}

echo 'Element to delete: '.$obj[1].PHP_EOL;

unset($obj[1]);

echo 'Iteration using "foreach":'.PHP_EOL;

// iterate the object using foreach
foreach ($obj as $element) {
     echo $element.PHP_EOL;
}

// Output:
//Iteration using "for":
//1
//2
//3
//4
//5
//Element to delete: 2
//Iteration using "foreach":
//1
//3
//4
//5

Written by Claudiu Persoiu

8 October 2009 at 8:38 AM

Bad code and frameworks

without comments

Why there is so much talking about “bad code” or “bad practices”? Because they are important!
Lately I had an unpleasant experience with uncommented code, bad design, bad implemented oop, unoptimized and badly designed  databases.

Comments

Is a great mystery to me how it’s possible that every book and tutorial (not just PHP) to say that comments are not optional but MANDATORY and most often there entirely missing. Zend Studio has a very simple and efficient auto-complete system, you just have to tap “/**” and press enter, and then just complete the text. Netbeans has a similar system, just as easy.

And still, I’ve came over thousands of lines of code with almost no comments at all. The outcome? Hours and hours wasted trying to follow the logic!

Why is this happening? First reason: is boring, a developer want’s to write code not stories, usually seems like wasted time. The second reason: everything seems very logic when it’s written, if it’s so logic and fluent why waste time with stories? Because time passes, projects change, and with time is inevitable that the logic will be forgotten. Or another reason, new employees will come, in companies developers come and go, and the new guy can’t follow the logic with the same ease, in fact it is almost impossible to follow.  Even the author of the code can’t follow the steps after a long period of time, sometimes the author was me.

In my opinion this should be a rule of thumb for every company, no class/method/property should be left uncommented. Time spend now on commentaries is time gain later when will be done debugging,optimization etc.

Bad design

I’ve encounter a question on an on-line  “mini interview”: “do you see the importance of architect analysis before writing code?”, I’m sorry if the I didn’t get the exact question. The first time I’ve seen that question I had an “deja-vu” moment, a lot of the time I’ve started writing code only to realize that was the wrong approach.

A lot of the times, the issue is solved (apparently) with time and experience. Basically, if you get a beginner to write code, most likely he will have some bad approaches before getting a good one, and this is not abnormal, that’s why I think a beginner should be guided before he will begin to write code, and the resulting code to have a suggested logic by a “mentor”.

On the other extreme there are “software architects” which using UML they describe the logic and the structures using diagrams. When diagrams exist is much easier to follow the entire process and structure of the app. An experienced architect will be able to see the possible issues that may appear before beginning to write code, and when code is starting to be written everyone knows just what they have to do.

OOP is probably the most affected by poor design. Lately I’ve seen a lot of classes which had no internal structure, there ware just simple wrappers for SQL queries. That’s not OOP!

OOP is about abstracting elements in classes and objects. For instance the keyboard is a class which has keys (a child class) with various properties (letters, key code, position), some LEDs (another child class) etc. The way there organize in the database is not necessary in a tight relation with the resulting objects, as it may seem.

If your using OOP and what you are reading now sounds weird, try drawing on a piece of paper a diagram of the objects in your app and the references between them. If you can’t, it means that your approach to the OOP is wrong (or you just don’t know to draw a diagram 🙂 )!

We all make mistakes when it comes to OOP, but that’s not an excuse not to correct them, and to try to make architecture before code.

A bad app design may have very important financial implications. Time is money, and if an app has poor design, is not correctly structured, the debugging time is big, changes and enhancements require a lot of time, is a lot of code redundancy, etc. , then you can be sure your losing money.

A tool that I sometimes use is Violet UML Editor, is not a true UML editor like Rational Rose for instance, but rather an open-source toy. With Violet you can only build visual diagrams, but they can be useful to visually structure an app.

Databases

Why are PHP developers avoiding to truly learn MySQL? Sounds strange? Is very true though. Modifying PHP code is usually not very difficult (I mean the practical rewriting the code), but a bad database design is most of the times more difficult to change because is the risk of losing data.

A few weeks ago I’ve made a diagram of the database using MySQL Dump and MySQL Workbench. I was quite surprise to see tables which didn’t have relation keys with the tables from which the information came from (I don’t mean settings tables or other tables which logically don’t have a relation with the other tables), then the data source was completely lost.

Another classic problem with beginners is that when they have a relation table between two other tables, like categories and products for instance, the primary key is on a field like “id” which has no relevance. A primary key can be set on multiple fields, like for the previous example “id_category, id_product” not “id”, this way you ensure the uniqueness of a product in a category using the primary key restriction.

Another thing that is usually avoided are the indexes. In a previous blog post I was shortly explaining them, insufficient even though there important. An index can significantly reduce the search time in a table, from tenths of a second to a thousandths of a second. A badly optimized app from this point of view can have a significant bigger response time then normal.

Frameworks

To quote a classical phrase in the PHP community:

All frameworks suck.

and Laura Thomson had some strong reasons to back this up.

Somebody was saying last week that the reason for bad code is actually PHP and it’s loose typing. Let’s be honest, if we take in consideration a language like C++ there are a lot more issues that can arise. I remember in faculty how bad my C++ code was, and  the problem wasn’t the language but rather my skills at that time. PHP allows approaches from OOP to spaghetti code (OOP, procedural, closures, labels). The fact that many developers chose bad approaches is not a language problem, there is the same approach issue with a language like C++, or in fact with any programming language out there.

Why are less design problems in Ruby on Rails for instance? Because is a framework! I’ve never heard of anybody doing web developing just using Ruby (there are developers out there, especially for desktop apps, but that’s another story), of course there are less issues when using a framework. The same way PHP issues can be reduced using an popular framework.

There are tens or even hundreds of open-source PHP frameworks. Of this there are a few really popular, like Zend Framework, CakePHP, Symfony, Solar, CodeIgniter etc. An great advantage when using a popular framework is that is easy to find professionals. Another big advantage is that you have a well tested and documented code base, thing that is very hard to achieve in a small company.

Or even if your using an in-house framework I thing is a good idea to adopt a structure of an popular framework to reduce the learning curve for new developers.

Using an popular open-source framework usually you reduce the working time and the time to develop nu features because usually there included in the framework, so economical advantages bay arise (money), a better structure and last but not least happier developers (which I’m not at this time).

Concluding:

  • set some rules for the code standards, don’t forget to add the comments to the list,
  • make sure the app design is according to a plan that allows for scalability and minimal code redundancy,
  • make sure the database is well structured and optimized,
  • consider an open-source popular framework over building an internal one.

Using this simple rules will save resources, time, and probably developers will be more happy with there result.

Written by Claudiu Persoiu

4 October 2009 at 2:07 PM

Posted in MySQL,PHP

Tagged with , ,