2017年2月 – LeoKim's Blog

设计模式 – 工厂模式

leokim / 2017年2月28日2017年3月17日 / 技术, 设计模式

简单的说就是类似于pdo 根据不同的数据库需要执行不同的操作。
这个不像自己敲代码了昨晚失眠有点累，上网找了篇不错的介绍直接拿过来留作以后参考吧。

==============================================

1 简单工厂模式简介

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

2 模式组成

1）工厂（Creator）角色

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

2）抽象产品（Product）角色

简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

3）具体产品（Concrete Product）角色

是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

3 模式核心思想

简单工厂模式的核心思想就是：用一个单独的工厂类去创建实例化的过程。

4 模式架构图

5 项目应用

5.1 需求说明

实现一个计算机控制台程序，要求输入两个数和预算符号，得到结果。（来之《大话设计模式》）

5.2 需求分析

按照需求，可以将运算操作设计成为一个抽象类，加法操作，减法操作，乘法操作，除法操作都继承这个抽象类。然后设计一个工厂类，去创建具体的实例。

5.3 设计架构图

5.5 程序说明

在operation.php与simpleFactoryPattern.php中。

1）抽象产品（Product）角色：运算抽象类(Operation)。

// 运算抽象类  
class Operation{  
       
    // 数字A  
    protected $_numberA = null;  
       
    // 数字B  
    protected $_numberB = null;  
   
    /** 
     * 设置成员A 
     * 
     * @param double $num 数字 
     * @return void 
     */  
    public function setNumberA($num){  
        $this->_numberA = $num;  
    }  
   
    /** 
     * 获取成员A 
     * 
     * @return double 数字 
     */  
    public function getNumberA(){  
        return $this->_numberA;  
    }  
   
    /** 
     * 设置成员B 
     * 
     * @param double $num 数字 
     * @return void 
     */  
    public function setNumberB($num){  
        $this->_numberB = $num;  
    }  
   
    /** 
     * 获取成员B 
     * 
     * @return double 数字 
     */  
    public function getNumberB(){  
        return $this->_numberA;  
    }  
   
    /** 
     * 获取运算结果 
     * 
     * @return double 数字 
     */  
    public function getResult(){  
        return null;  
    }  
}

2）具体产品（Concrete Product）角色：加法运算(OperationAdd)，减法运算(OperationSub)，乘法运算(OperationMul)，除法运算(OperationDiv)。

// 加法类  
class OperationAdd extends Operation{  
   
    /** 
     * 获取运算结果 
     * 
     * @return double 数字 
     */  
    public function getResult(){  
        return $this->_numberA + $this->_numberB;  
    }  
}  
   
// 减法类  
class OperationSub extends Operation{  
   
    /** 
     * 获取运算结果 
     * 
     * @return double 数字 
     */  
    public function getResult(){  
        return $this->_numberA - $this->_numberB;  
    }  
}  
   
// 乘法类  
class OperationMul extends Operation{  
   
    /** 
     * 获取运算结果 
     * 
     * @return double 数字 
     */  
    public function getResult(){  
        return $this->_numberA * $this->_numberB;  
    }  
}  
   
// 除法类  
class OperationDiv extends Operation{  
   
    /** 
     * 获取运算结果 
     * 
     * @return double 数字 
     */  
    public function getResult(){  
        if ($this->_numberB == 0) {  
            return null;  
        }  
        return $this->_numberA / $this->_numberB;  
    }  
}

3）工厂（Creator）角色：工厂类(OperationFactory)。

<?php  
/** 
 * simpleFactoryPattern.php 
 * 
 * 设计模式：简单工厂模式 
 *  
 * 模式简介：用一个单独的类来创造实例化的过程，叫做简单工厂。好处将来增加或减少 
 * 实例只需要修改工厂即可。 
 *  
 * 特别声明：本源代码是根据《大话设计模式》一书中的C#案例改成成PHP代码，和书中的 
 * 代码会有改变和优化。 
 * 
 * Copyright (c) 2015 http://blog.csdn.net/CleverCode 
 * 
 * modification history: 
 * -------------------- 
 * 2015/5/5, by CleverCode, Create 
 * 
 */  
   
// 加载所有的实例类  
include_once ('operation.php');  
   
// 创建一个工程，用来生产实例  
class OperationFactory{  
   
    /** 
     * 根据运算不同实例不同的对象 
     * 
     * @return object 返回实例化的对象 
     */  
    public static function createOperate($operate){  
        $oper = null;  
        switch ($operate) {  
               
            // 实例加法类  
            case '+' :  
                $oper = new OperationAdd();  
                break;  
               
            // 实例减法类  
            case '-' :  
                $oper = new OperationSub();  
                break;  
               
            // 实例乘法类  
            case '*' :  
                $oper = new OperationMul();  
                break;  
               
            // 实例乘法类  
            case '/' :  
                $oper = new OperationDiv();  
                break;  
               
            default :  
                $oper = null;  
        }  
           
        return $oper;  
    }  
}  
   
// 客户端  
class Client{  
   
    /** 
     * 主函数 
     */  
    public function main(){  
        // 工厂创建实例  
        $operObject = OperationFactory::createOperate('+');  
           
        if ($operObject == null) {  
            return '$operate not found';  
        }  
           
        // 设置数字A  
        $operObject->setNumberA(5);  
           
        // 设置数字B  
        $operObject->setNumberB(2);  
           
        // 运算  
        echo $operObject->getResult();  
    }  
}  
   
// 程序入口  
function start(){  
    // 调用客户端主函数  
    $client = new Client();  
    $client->main();  
}  
   
start();  
   
?>

6 总结

1）优点：

工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。不需要了解实例是如何工作的，只需要在工厂里面创建它即可。

2）缺点：

由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。

当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

每当需要添加或者删除实例时候，都需要修改工厂。然而一旦工厂出了问题，所有的实例都不能够使用。

设计模式 – 单例模式

leokim / 2017年2月28日2017年3月17日 / 技术, 设计模式

缺点：

单例和全局变量都可能被误用。

因为单例在系统任何地方都可以被访问，所以它们可会导致很难调试的依赖关系。

如果改变一个单例，那么所有使用该单例的类可能都会受到影响。

在这里依赖本身并不是问题。

毕竟，我们在每次声明一个特定类型参数的方法时，也就创建了依赖关系。

问题是，单例对象的全局化的性质会使程序员绕过类接口定义的通信线路。

当单例被使用时，依赖便会被隐藏在方法内部，而并不会出现在方法声明中。

这使得系统中的依赖关系更加难以追踪，因此需要谨慎小心地部署单例类。

优点：

适度地使用单例模式可以改进系统的设计。在系统中传递那些不必要的对象令人厌烦，而单例可以让你从中解放出来。

在面向对象的开发环境中，单例模式是一种对于全局变量的改进。

你无法用错误类型的数据复写一个单例。

<?php
class Preferences{
    private $props = array();
    private static $instance;
 
    private function __construct(){}
 
    public static function getInstance(){
        if(empty(self::$instance)){
            self::$instance = new Preferences();
        }
        return self::$instance;
    }
 
    public function setProperty($key, $val){
        $this->props[$key] = $val;
    }
 
    public function getProperty($key){
        return $this->props[$key];
    }
}
 
$pref = Preferences::getInstance();
$pref->setProperty("name","matt");
 
unset($pref); //移除引用
 
$pref2 = Preferences::getInstance();
print  $pref2->getProperty("name");
 
//输出  matt
?>

日记

leokim / 2017年2月27日2017年2月27日 / PHP, 技术, 记事

看《深入PHP 面向对象，模式与时间》有几天了

虽然看了前1/4了但是感觉还是步子迈的有点大了

很多东西在头脑里还是只是有模糊印象并没有完全吸收

一方面自身接受能力有限猛的补充了那么多知识一下也接受不了

既然没有别人学的快那就利用自己的时间多复习多练习多记忆吧

明天也不打算继续往后面读了

先把前面这些内容弄得很熟悉之后再继续下去

要不然还和上周看的Android一样

虽然全部看完了但是并没有完全理解其中细节

照着书中代码敲出了不少app但是如果手里没有书可能独立也写不出来

一步一个脚印好了好歹也在进步不要放弃

啊哈哈哈哈

leokim / 2017年2月27日 / 技术

                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
           佛祖保佑       永无BUG

组合&把不同的实现隐藏在父类所定义的共同接口下

leokim / 2017年2月27日2017年3月17日 / 技术, 设计模式

组合使用对象比集成体系更灵活，因为组合可以以多种方式动态的处理任务。

把不同的实现隐藏在父类所定义的共同接口下.

然后客户端代码需要一个父类的对象,从而使客户端代码可以不用关心它实际得到的是哪个具体的实现.

<?php
 
abstract class Lesson{
    private $duration;
    private $costStrategy;//支付策略
 
    function __construct($duration, CostStrategy $strategy)
    {
        $this->duration = $duration;
        $this->costStrategy = $strategy;
    }
 
    function cost(){
        return $this->costStrategy->cost($this);
    }
 
    function chargeType(){
        return $this->costStrategy->chargeType();
    }
 
    function getDuration(){
        return $this->duration;
    }
 
    //Lesson类的更多方法
}
 
class Lecture extends Lesson{
    //Lecture特定的实现
}
 
 class Seminar extends Lesson{
    //Seminar特定的实现
 }
 
 abstract class CostStrategy{
    abstract function cost(Lesson $lesson);
    abstract function chargeType();
 }
 
class TimedCostStrategy extends CostStrategy{
    function cost(Lesson $lesson){
        return ($lesson->getDuration() * 5);
    }
 
    function chargeType(){
        return "hourly rate";
    }
}
 
class FixedCostStrategy extends CostStrategy{
    function cost(Lesson $lesson){
        return 30;
    }
 
    function chargeType(){
        return "fixed rate";
    }
}
 
$lessons[] = new Seminar(4, new TimedCostStrategy());
$lessons[] = new Lecture(4, new FixedCostStrategy());
 
foreach($lessons as $lesson){
    print "lesson charge {$lesson->cost()}.";
    print "Charge type: {$lesson->chargeType()} <br />";
}
 
 
?>

小实验 – 直接调用抽象方法内的静态方法来实例化子类

leokim / 2017年2月26日2017年2月27日 / PHP, 技术, 设计模式

<?php
 
abstract class ParamHandler{
    protected $source;
    protected $params = array();
 
    function __construct($source){
        $this->source = $source;
    }
 
    function addParam($key, $val){
        $this->params[$key] = $val;
    }
 
    function getAllParams(){
        return $this->params;
    }
 
    static function getInstance($filename){
        if(preg_match("/\.xml$/i", $filename)){
            return New XmlParamHandler($filename);
       }
 
       return New TextParamHandler($filename);
    }
 
    abstract function write();
    abstract function read();
}
 
class XmlParamHandler extends ParamHandler{
    function read(){
        echo 'XmlParamHandler Read.';
    }
 
    function write(){
        echo 'XmlParamHandler Write.';
    }
}
 
class TextParamHandler extends ParamHandler{
    function read(){
        echo 'TextParamHandler Read.';
    }
 
    function write(){
        echo 'TextParamHandler Write.';
    }
}
 
//抽象方法不能直接实例化，直接调用抽象方法内的静态方法来实例化子类
//这样也行 尼玛......
$test = ParamHandler::getInstance("./params.xml");
$test->addParam("key1","value1");
$test->addParam("key2","value2");
$test->addParam("key3","value3");
$test->write();
?>

php 反射API

leokim / 2017年2月26日2017年2月27日 / PHP, 技术, 设计模式

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

<?php
 
class Person{
    public $name;
    function __construct($name){
        $this->name = $name;
    }
}
 
interface Module{
    function execute();
}
 
class FtpModule implements Module{
    private $host;
    private $user; 
 
    function setHost($host){
        $this->host = $host;
        echo "FtpModule::setHost() : {$this->host} <br/>";
    }
 
    function setUser($user){
        $this->user = $user;
        echo "FtpModule::setUser() : {$this->user} <br/>";
    }
 
    function execute(){
        //执行一些操作
        echo "Host: {$this->host} & User: {$this->user} <br/>";
    }
}
 
class PersonModule implements Module{
    private $name;
 
    function setPerson( Person $person ){
        $this->name = $person->name;
        echo "PersonModule::setPerson() :  {$person->name} <br/>";
    }
 
    function execute(){
        //执行一些操作
        echo "Name: {$this->name}<br />";
    }
}
 
class ModuleRunner{
    private $configData = array(
            "PersonModule" => array('person'=>'leokim'),
            "FtpModule" => array('host'=>'www.leokim.cn','user'=>'leokim')
        );
 
    private $modules = array();
 
    function init(){
        $interface = new ReflectionClass('Module');
 
        foreach($this->configData as $modulename => $params){
            $module_class = new ReflectionClass($modulename);
 
            if( !$module_class->isSubclassOf($interface)){
                throw new Exception("unknow module type:$modulename");
            }
            $module = $module_class->newInstance();
 
            foreach($module_class->getMethods() as $method){
                //module，module内的方法，方法的参数
                $this->handleMethod($module, $method, $params);
            }
            array_push($this->modules, $module);
        }
    }
 
    //handleMethod()检验并调用Module对象的setter方法
    function handleMethod(Module $module, ReflectionMethod $method, $params){
        $name = $method->getName();
        //所需要的参数
        $args = $method->getParameters();
         
        if(count($args) != 1 || substr($name, 0, 3) != "set"){
            return false;
        }
 
        $property = strtolower(substr($name, 3));
        if(!isset($params[$property])){
            return false;
        }
 
        print_r($args[0]);
        echo ' | ';
 
        //ReflectionMethod::invoke()。它以一个对象和任意数目的方法作为参数
        //可以通过两种途径调用invoke()方法：
        //1.如果setter方法不需要对象参数，可以用用户提供的属性字符串来调用ReflectionMethod::invoke()。
        //2.如果方法需要对象作为参数，可以使用属性字符串来实例化正确类型的对象，然后传递给setter。
        //这个例子里 Person是有Class的 所以在else里执行，Ftp并没有Class所以在if里执行
        $arg_class = $args[0]->getClass();
 
        if(empty($arg_class)){
            $method->invoke($module, $params[$property]);
        }else{
            $method->invoke($module, $arg_class->newInstance($params[$property]));
        }
 
        //执行固有的function execure()
        $module->execute();
 
    }
}
 
 
//在ModuleRunner::init()方法运行时，ModuleRunner对象存储着许多Module对象，而所有Module对象都包含着数据。
//ModuleRunner类现在可以用一个类方法来循环遍历没个Module对象，并逐一调用各Module对象中的excute()方法
$test = new ModuleRunner();
$test->init();
 
?>

CI 3.1.3 源码分析(一)

leokim / 2017年2月26日 / PHP, 技术

仅是自己分析源码时的笔记参考并不是教程之类的文章

入口文件index.php

主要定义了报错类型以及设置各种路径常量
CodeIgniter.php

load application文件夹下的常量文件（constants .php）

load system 文件夹下的common.php

自定义加载目录下的class，默认加载libraries目录下的class，首先加载core/下的，然后加载application/下的

默认用“CI_”这个prefix，其次使用自定义prefix 例如“MY_”

function &load_class($class, $directory = 'libraries', $param = NULL)
{
   static $_classes = array();
 
   // Does the class exist? If so, we're done...
   if (isset($_classes[$class]))
   {
      return $_classes[$class];
   }
 
   $name = FALSE;
 
   // Look for the class first in the local application/libraries folder
   // then in the native system/libraries folder
   foreach (array(APPPATH, BASEPATH) as $path)
   {
      if (file_exists($path.$directory.'/'.$class.'.php'))
      {
         $name = 'CI_'.$class;
 
         if (class_exists($name, FALSE) === FALSE)
         {
            require_once($path.$directory.'/'.$class.'.php');
         }
 
         break;
      }
   }
 
   // Is the request a class extension? If so we load it too
   if (file_exists(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.'.php'))
   {
      $name = config_item('subclass_prefix').$class;
 
      if (class_exists($name, FALSE) === FALSE)
      {
         require_once(APPPATH.$directory.'/'.$name.'.php');
      }
   }
 
   // Did we find the class?
   if ($name === FALSE)
   {
      // Note: We use exit() rather than show_error() in order to avoid a
      // self-referencing loop with the Exceptions class
      set_status_header(503);
      echo 'Unable to locate the specified class: '.$class.'.php';
      exit(5); // EXIT_UNK_CLASS
   }
 
   // Keep track of what we just loaded
   is_loaded($class);
 
   $_classes[$class] = isset($param)
      ? new $name($param)
      : new $name();
   return $_classes[$class];
}

然后加载config文件，默认加载Application目录下config/config.php，找不到才会检查config.php是否再自定义的路径里

function &get_config(Array $replace = array())
{
   static $config;
 
   if (empty($config))
   {
      $file_path = APPPATH.'config/config.php';
      $found = FALSE;
      if (file_exists($file_path))
      {
         $found = TRUE;
         require($file_path);
      }
 
      // Is the config file in the environment folder?
      if (file_exists($file_path = APPPATH.'config/'.ENVIRONMENT.'/config.php'))
      {
         require($file_path);
      }
      elseif ( ! $found)
      {
         set_status_header(503);
         echo 'The configuration file does not exist.';
         exit(3); // EXIT_CONFIG
      }
 
      // Does the $config array exist in the file?
      if ( ! isset($config) OR ! is_array($config))
      {
         set_status_header(503);
         echo 'Your config file does not appear to be formatted correctly.';
         exit(3); // EXIT_CONFIG
      }
   }
 
   // Are any values being dynamically added or replaced?
   foreach ($replace as $key => $val)
   {
      $config[$key] = $val;
   }
 
   return $config;
}

基本上其他的function 都是一些基础function简单过一下就看完了

下面要看的是core/libraries文件夹下的这些类库了

php中引用&的真正理解-变量引用、函数引用、对象引用

leokim / 2017年2月26日2017年2月27日 / PHP, 技术, 设计模式

5.3以后已经不赞成使用引用来传递参数了貌似

只是再分析CI3的源码的时候还是能看到函数引用

总之再复习一下吧

总没有坏处

====================================================================

php的引用（就是在变量或者函数、对象等前面加上&符号） //最重要就是删除引用的变量，只是引用的变量访问不了，但是内容并没有销毁在PHP 中引用的意思是：不同的名字访问同一个变量内容.

变量的引用

PHP 的引用允许你用两个变量来指向同一个内容

<?php
$a="ABC"; 
$b =&$a; 
echo $a;//这里输出:ABC 
echo $b;//这里输出:ABC 
$b="EFG"; 
echo $a;//这里$a的值变为EFG 所以输出EFG echo $b;//这里输出EFG 
?>

函数的传址调用传址调用我就不多说了下面直接给出代码

<?php
function test(&$a){ 
    $a=$a+100; 
} 
$b=1; 
echo $b;//输出１ test($b);   //这里$b传递给函数的其实是$b的变量内容所处的内存地址，通过在函数里改变$a的值　就可以改变$b的值了 echo "<br>"; echo $b;//输出101
?>

要注意的是，在这里test(１);的话就会出错，原因是：PHP规定传递的引用不能为常量（可以看错误提示）。

<?php
function &test(){ 
    static $b=0;//申明一个静态变量 
    $b=$b+1; 
    echo $b; 
    return $b; }
}
$a=test();//这条语句会输出　$b的值　为１ 
$a=5; $a=test();//这条语句会输出　$b的值　为2
$a=&test();//这条语句会输出　$b的值　为3 
$a=5; $a=test();//这条语句会输出　$b的值　为6
?>

下面解释下：　通过这种方式$a=test();得到的其实不是函数的引用返回，这跟普通的函数调用没有区别　至于原因：　这是ＰＨＰ的规定ＰＨＰ规定通过$a=&test(); 方式得到的才是函数的引用返回至于什么是引用返回呢（ＰＨＰ手册上说：引用返回用在当想用函数找到引用应该被绑定在哪一个变量上面时。) 这句狗屁话　害我半天没看懂

用上面的例子来解释就是 $a=test()方式调用函数，只是将函数的值赋给$a而已，　而$a做任何改变，都不会影响到函数中的$b，而通过$a=&test()方式调用函数呢, 他的作用是　将return $b中的　$b变量的内存地址与$a变量的内存地址　指向了同一个地方即产生了相当于这样的效果($a=&b;) 所以改变$a的值　也同时改变了$b的值　所以在执行了 $a=&test(); $a=5; 以后，$b的值变为了5

这里是为了让大家理解函数的引用返回才使用静态变量的，其实函数的引用返回多用在对象中

对象的引用

<?php
class a{
    var $abc="ABC";
} 
$b=new a; 
$c=$b; 
echo $b->abc;//这里输出ABC 
echo $c->abc;//这里输出ABC $b->abc="DEF"; 
echo $c->abc;//这里输出DEF
?>

以上代码是在PHP5中的运行效果在PHP5中对象的复制是通过引用来实现的。上列中$b=new a; $c=$b; 其实等效于$b=new a; $c=&$b; PHP5中默认就是通过引用来调用对象，但有时你可能想建立一个对象的副本，并希望原来的对象的改变不影响到副本 . 为了这样的目的，PHP定义了一个特殊的方法，称为__clone.

引用的作用

如果程序比较大,引用同一个对象的变量比较多,并且希望用完该对象后手工清除它,个人建议用 "&" 方式,然后用$var=null的方式清除. 其它时候还是用php5的默认方式吧. 另外, php5中对于大数组的传递,建议用 "&" 方式, 毕竟节省内存空间使用。

取消引用当你 unset 一个引用，只是断开了变量名和变量内容之间的绑定。这并不意味着变量内容被销毁了。例如：

<?php $a = 1; $b =& $a; unset ($a); ?>

不会 unset $b，只是 $a。 function quoteTest(){ global $var ; //相当于 $var = &$GLOBALS['var']; unset($var); //删除只是删除引用，而引用的内容还存在,同上这并不意味着变量内容被销毁了}$var=1;quoteTest();echo $var; // 结果 1

———————————————————————————————-

不会 unset $b，只是 $a。

function quoteTest(){ global $var ; //相当于 $var = &$GLOBALS['var']; $var = 5; //因为他们都指向同一内存内容}$var=1;quoteTest();echo $var; //结果 5———————————————————————————————-

'&' 这就是引用

global 引用当用 global $var 声明一个变量时实际上建立了一个到全局变量的引用。也就是说和这样做是相同的：

<?php $var =& $GLOBALS["var"]; ?>

这意味着，例如，unset $var 不会 unset 全局变量。

$this 在一个对象的方法中，$this 永远是调用它的对象的引用。

//下面再来个小插曲 php中对于地址的指向（类似指针）功能不是由用户自己来实现的，是由Zend核心实现的，php中引用采用的是“写时拷贝”的原理，就是除非发生写操作，指向同一个地址的变量或者对象是不会被拷贝的。

通俗的讲 1:如果有下面的代码 [php] $a="ABC"; $b=$a; [/php] 其实此时　$a与$b都是指向同一内存地址　而并不是$a与$b占用不同的内存

２:如果在上面的代码基础上再加上如下代码 [php] $a="EFG"; [/php] 由于$a与$b所指向的内存的数据要重新写一次了，此时Zend核心会自动判断　自动为$b生产一个$a的数据拷贝，重新申请一块内存进行存储

PHP __call拦截器实现委托

leokim / 2017年2月25日2017年2月27日 / PHP, 技术, 设计模式

__call方法可能是最有用的拦截器方法。

当客户端代码要调用类中未定义的方法时，__call会被调用。

__call()接受2个参数，一个是方法的名称，另一个是传递给要调用方法的所有参数(数组)。

__call()方法返回的任何值都会返回给客户，就好像调用一个真实存在的方法一样。

__call()方法对于实现委托也很有用。委托是指一个对象转发或者委托一个请求给另一个对象，被委托的一方替原先对象处理请求。

这类似于继承，和在子类中调用父类的方法有点相似。

但再继承时，父类与子类的关系是固定的，而使用委托则可以再代码运行时改变使用的对象，这意味着委托比继承具有更大的灵活性。

//将Person类信息格式化并输出
class personWriter{
    function writeName(Person $p){
        print $p->getName();
    }
 
    function writeAge(Person $p){
            print $p->getAge();
    }
 
}
 
 
//当然我们可以通过集成PersonWrite类以不同的方式输出Person类的信息。
//下面的的代码结合使用__call()方法和PersonWriter对象来实现Person类:
class Person{
    private $writer;
 
    function __construct(PersonWriter $write){
        $this->write = $write;
    }
 
    function __call($methodname, $args){
        if(method_exists($this->writer, $methodname)){
            return $this->writer->$methodname($this);
        }
    }
 
    function getName(){ return "LeoKim"; };
    function getAge(){ return 31; }
}

代码中Person类接受一个PersonWriter对象作为构造方法的参数，并将它存储再属性变量$writer中。

在__call()方法中，我们使用参数$methodname,检查PersonWriter对象中是否存在同名的方法。

如果相应的方法存在，我们就委托PersonWriter对象来处理对方法的调用，把当前类(Person)的实例作为参数传递给PersonWriter对象(使用$this伪变量)。

因此，可以这样调用Person类：

1 2	`$person` `=` `new` `Person(new` `PersonWriter());` `$person->writeName();`

2017年2月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28