PHP Design Patterns

The book Design Patterns introduces a lot of these concepts. At the time I was still learning object orientation (OO), so I found many of the concepts in that book very hard to grasp. But as I became more and more familiar with OO concepts — especially the use of interfaces and inheritance — I began to see the practical value in design patterns. As an application developer, even if you never learn about any pattern, or how and when to use these patterns, it won’t have much of an impact on your career. But I found that after gaining a solid knowledge of these patterns and the ones introduced in the developerWorks article “Five Common PHP Design Patterns” (see Resources), you can accomplish two things:

Enabling high-bandwidth sessions
If you understand design patterns, you’ll be able to build reliable OO applications faster. But when the whole development team knows the various patterns, you suddenly have very high-bandwidth sessions. You no longer need to discuss all the classes that will be used everywhere. Instead, you can talk to the others in terms of patterns. “I’m going to reference a singleton here, then use an iterator to walk the object collection, and then…” is much faster than walking through the classes, methods and interfaces that make up those patterns. The communication efficiency alone makes it worth spending time studying patterns through sessions as a team.
Painful lessons reduced
Every design pattern describes a proven way to solve a common problem. So you don’t need to worry about whether your design is correct, as long as you’ve chosen a pattern that provides the benefits you need.
Flaws
There’s a saying that goes well: “When you’re holding a hammer, everything looks like a nail.” When you think you’ve found an excellent pattern, you may try to use it everywhere, even in places where it shouldn’t be used. Remember that you must consider the purpose of the pattern you’re learning, and don’t force these patterns into every part of the application just for the sake of using them.

This article will introduce five patterns that can be used to improve PHP code. Each pattern is introduced with a specific scenario. The PHP code for these patterns is available in the Downloads section.

Requirements
To get the most out of this article and to use the examples, you need the following software installed on your computer:

PHP V5 or later (this article was written using PHP V5.2.4)
A compression program, such as WinZIP (for extracting the downloadable code archive)
Note: although you can also use a plain text editor, I find an editor with syntax highlighting and syntax error checking really helpful. The examples in this article were written using Eclipse PHP Development Tools (PDT).

——Excerpted from Another Five PHP Design Patterns

• Command chain pattern

<?php

/**
 * 艾瑞可erik
 * https://erik.xyz
 * Command chain pattern
 * Interface ICommand
 */
interface ICommand
{
    function onCommand($name, $args);
}

class CommandChain
{
    private $_command = [];

    public static function load()
    {
        return new CommandChain();
    }

    public function addCommand($cmd)
    {
        $this->_command[] = $cmd;
    }

    public function runCommand($name, $args)
    {
        foreach ($this->_command as $cmd) {
            if ($cmd->onCommand($name, $args)) {
                return;
            }
        }
    }
}

class UserCommand implements ICommand
{
    public static function load()
    {
        return new UserCommand();
    }

    public function OnCommand($name, $args)
    {
        if ($name != 'addUser') return false;
        echo("UserCommand handling 'addUser'\n");
        return true;
    }
}

class MailCommand implements ICommand
{
    public static function load()
    {
        return new MailCommand();
    }

    public function onCommand($name, $args)
    {
        if ($name != 'mail') return false;
        echo("MailCommand handling 'mail'\n");
        return true;
    }
}

$cc = CommandChain::load();
$cc->addCommand(UserCommand::load());
$cc->addCommand(MailCommand::load());
$cc->runCommand('addUser', null);
$cc->runCommand('mail', null);

• Delegation pattern

<?php

/**
 * 艾瑞可erik
 * https://erik.xyz
 * Class bank
 * Delegation pattern
 */
class bank
{
    protected $info = [];

    public static function load()
    {
        return new bank();
    }

    /**
     * Pass in parameters and set the basic information
     * @param $type
     * @param $money
     * Set the bank deposit type
     */
    public function updateBankInfo($type, $money)
    {
        $this->info[$type] = $money;
    }

    public function bankWithdraw($bankType)
    {
        $obj = $bankType::load();
        return $obj->bankMain($this->info);
    }
}

/**
 * Deposit operation
 * Class bankDeposit
 */
class bankDeposit
{
    public static function load()
    {
        return new bankDeposit();
    }

    public function bankMain($data)
    {
        return $data['bankDeposit'];
    }
}

/**
 * Withdrawal operation
 * Class bankWithdraw
 */
class bankWithdraw
{
    public static function load()
    {
        return new bankWithdraw();
    }

    public function bankMain($data)
    {
        return $data['bankWithdraw'];
    }
}

$bank = bank::load();

//set the data
$bank->updateBankInfo("bankWithdraw", 500);
$bank->updateBankInfo("bankDeposit", 100);

//deposit
$bankReturn = $bank->bankWithdraw("bankDeposit");
echo "存款" . $bankReturn . PHP_EOL;
//withdraw
$bankReturn = $bank->bankWithdraw("bankWithdraw");
echo "取款" . $bankReturn . PHP_EOL;

• Factory pattern (1)

<?php
/**
 * 艾瑞可erik
 * https://erik.xyz
 * Factory pattern
 */

 /**
  * Payment interface
  */
interface PayErik{
    public function payMethodErik();
}

class AlipayErik implements PayErik{

    public function payMethodErik(){
        echo '支付宝支付';
    }

}

class WxpayErik implements PayErik
{

    public function payMethodErik(){
        echo '微信支付';
    }
    
}

/**
 * Payment factory class
 */
class PayFactoryErik{
    public static function factoryErik($class_name){
        return new $class_name();
    }
}

$obj=PayFactoryErik::factoryErik('alipayErik');
$pay=$obj->PayMethodErik();
echo PHP_EOL;
print_r($pay);
echo PHP_EOL;

• Factory pattern (2)

<?php
/**
 * 艾瑞可erik
 * https://erik.xyz
 * Factory pattern
 */

 /**
  * Payment interface
  */
interface PayErik{
    public function payMethodErik();
}

class AlipayErik implements PayErik{

    public function load(){
        return new alipayErik();
    }
    public function payMethodErik(){
        echo '支付宝支付';
    }

}

class WxpayErik implements PayErik
{
    public function load(){
        return new wxpayErik();
    }
    public function payMethodErik(){
        echo '微信支付';
    }
    
}


$alipayErik=AlipayErik::load();
$payErik=$alipayErik->payMethodErik();
echo PHP_EOL;
print_r($payErik);
unset($alipayErik);
echo PHP_EOL;

$wxpayErik=WxpayErik::load();
$payEriks=$wxpayErik->payMethodErik();
echo PHP_EOL;
print_r($payEriks);
unset($payEriks);
echo PHP_EOL;

• Observer pattern

<?php
/**
 *艾瑞可erik
 *https://erik.xyz
 * Observer pattern
 * Interface PayLoggerErik
 */
//payment log
interface PayLoggerErik
{
    public function onChangeErik($sender, $args);
}

//payment choice
interface PayTypeErik
{
    public function addObserverErik($observer);
}

class PayListErik implements PayTypeErik
{
    private $observers = [];

    public function load()
    {
        return new PayListErik();
    }

    public function addCustomerErik($method, $name)
    {
        if (empty($method)) {     
            return false;
        }
        foreach ($this->observers as $obs) {
            $obs->$method($this, $name);
        }
    }

    public function addObserverErik($observer)
    {
        $this->observers[] = $observer;
    }
}

/**  Logging
 * Class PayListLoggerErik
 */
class PayListLoggerErik implements PayLoggerErik
{
    public function load()
    {
        return new PayListLoggerErik();
    }

    public function onChangeErik($sender, $args)
    {
        echo "选择成功！" . $args . PHP_EOL;
    }

    public function setLoggerErik($sender, $args)
    {
        echo "设置成功了！" . $args. PHP_EOL;
    }
}

$payList = PayListErik::load();
$payList->addObserverErik(PayListLoggerErik::load());
$payList->addCustomerErik('onChangeErik', "艾瑞可erik(https://erik.xyz),新增日志记录引入");
$data = $payList->addCustomerErik('setLoggerErik', "艾瑞可erik(https://erik.xyz)");

• Singleton pattern

<?php
/**
 * 艾瑞可erik
 * https://erik.xyz
 * 
 * Singleton pattern
 */
class SingleErik
{
   private $props=[];
   private static $instanceErik;
   final private function __construct(){}

   //singleton method
   public static function getInstanceErik(){
      if(empty(self::$instanceErik)){
         self::$instanceErik=new SingleErik();
      }
      return self::$instanceErik;
   }
   
   //singleton definition methods
   public function setPropertyErik($key,$val){
      $this->props[$key]=$val;
   }

   public function getPropertyErik($key){
      return $this->props[$key];
   }

   final protected function __clone(){}
}

$perf=singleErik::getInstanceErik();
$perf->setPropertyErik("blog",["title"=>"艾瑞可erik","url"=>"https://erik.xyz"]);
$getData=$perf->getPropertyErik("blog");
print_r($getData);
//destroy the reference and free the space
unset($perf);

• Strategy pattern

<?php
/**
 * 艾瑞可erik
 * https://erik.xyz
 * Interface IStrategy
 * Strategy pattern
 */

interface IStrategyErik
{
    function filter($record);
}

class FindAfterStrategyErik implements IStrategyErik
{
    private $_name;

    public function __construct($name)
    {
        $this->_name = $name;
    }

    public static function load($name)
    {
        return new FindAfterStrategyErik($name);
    }

    public function filter($record)
    {
        return strcmp($this->_name, $record) <= 0;
    }
}

class RandomStrategyErik implements IStrategyErik
{
    public static function load()
    {
        return new RandomStrategyErik();
    }

    public function filter($record)
    {
        return rand(0, 1) >= 0.5;
    }
}

class UserListErik
{
    private $_list = [];

    public static function load($arr = [])
    {
        return new UserListErik($arr);
    }

    public function __construct($names)
    {
        if ($names != null) {
            foreach ($names as $name) {
                $this->_list[] = $name;
            }
        }
    }

    public function add($name)
    {
        $this->_list[] = $name;
    }

    public function find($filter)
    {

        $recs = [];
        foreach ($this->_list as $user) {
            if ($filter->filter($user)) {
                $recs[] = $user;
            }
        }

        return $recs;
    }
}

$ul = UserListErik::load(["Andy", "Jack", "Lori", "Megan"]);
$f1 = $ul->find(FindAfterStrategyErik::load("J"));
print_r($f1);

$f2 = $ul->find(RandomStrategyErik::load());
print_r($f2);

References:

Another Five PHP Design Patterns

PHPer进阶