PHP反射与代理模式

面向对象编程中对象被赋予了自省的能力,而这自省的过程就是反射.
给出一个对象,我们可以通过该对象知道它所属的类,有用的方法,属性.

PHP反射API

下面通过反射的API获取person类的原型

<?php
    //构造一个类
    class person{
        public $name;
        public $gender;
        public function say(){

        }
        public function __set($name,$v){

        }
        public function __get($name){

        }
    }

    $obj = new ReflectionClass('person');//获取类
    $classname = $obj->getName();
    $methods = $properties = array();
    foreach($obj->getProperties() as $p)//获取类的属性
    {
        $properties[$p->getName()] = $p;
    }

    foreach($obj->getMethods() as $p)//获取类的方法
    {
        $methods[$p->getName()] = $p;
    }

    echo "class {$classname} {<br>";
    is_array($properties) && ksort($properties);//如果属性数组不为空,就根据key排序

    foreach($properties as $key => $v)
    {
        echo "\t";
        echo $v->isPublic()?'public':'',
             $v->isPrivate()?'private':'',
             $v->isProtected()?'protected':'',
             $v->isStatic()?'static':'';
        echo "\t{$key}<br>";
    }

    echo "<br>";

    if(is_array($methods)) ksort($methods);

    foreach($methods as $key => $v)
    {
        echo "\tfunction {$key}(){}<br>";
    }

    echo "}";

//输出如下
class person {
public  gender
public  name

function __get(){}
function __set(){}
function say(){}
}

反射有什么用

一个常见的应用是实现动态代理和文档生成.
我们先说说静态代理

<?php
    interface work{
        function todo();
    }
    //委托类
    class realobj implements work{
        function todo(){
            echo "realobj do something";
        }
    }
    //代理类,其中target就是委托类的引用,通过依赖注入或者手动创建
    class staticproxy implements work{
        public $target ;
        function __construct(){
            $this->target = new realobj();
        }
        function todo(){
            $this->target->todo();
        }
    }

    //测试
    $proxy = new staticproxy();
    $proxy->todo();

静态代理就是以上的模式,他可以隐藏委托类的实现;可以实现客户与委托类间的解耦，在不修改委托类代码的情况下能够做一些额外的处理.但是静态代理这个模式本身有个大问题，如果类方法数量越来越多的时候，代理类的代码量是十分庞大的。所以引入动态代理来解决此类问题。

动态代理:

<?php
interface work{
    function todo();
}
interface run{
    function run();
}
//委托类
class realobj implements work{
    function todo(){
        echo "realobj do something<br>";
    }
}
class realobj2 implements run{
    function run(){
        echo "i can run <br>";
    }
}
class proxy{
    public $target;
    public function bind($tar){
        $this->target = new $tar();
    }
    function __call($name,$args){
        if(!isset($this->target))
        {
            exit("未绑定委托类");
        }
        $r = new ReflectionClass($this->target);
        if($method = $r->getMethod($name))
        {
            if(!$method->isAbstract() && $method->isPublic())//查找target内有没有这个方法
            {
                echo "在调用方法前可以做一些操作<br>";
                $method->invoke($this->target,$args);//调用target的方法
                echo "在调用方法后可以做一些操作<br>";
            }
        }
    }
}

$obj = new proxy();
$obj->bind('realobj');//绑定委托类
$obj->todo();
$obj->bind('realobj2');
$obj->run();

输出:

在调用方法前可以做一些操作
realobj do something
在调用方法后可以做一些操作
在调用方法前可以做一些操作
i can run 
在调用方法后可以做一些操作

明显,Proxy类的代码量被固定下来，不会因为业务的逐渐庞大而庞大；解耦，通过参数就可以判断真实类，不需要事先实例化，更加灵活多变。