反射机制与动态代理

优点
可以这么说，反射完整的描述了一个类或者对象的原型,
它可以用作文档生成，所以，我们可以用它对文档中的类进行扫描，逐个生成扫描文档。
反射可以探知类的内部结构
也可以用作hook来实现插件功能，还有就是可以做动态代理
缺点
反射的消耗也是不小的，我们在有另外一种方案的时候，尽量不要选择反射。
很多时候，善用某个东西，会使得我们的代码，简洁又优雅，但是不能贪多，比如这个反射API，用的多了，会破坏我们类的封装性，使得本不应该暴露的方法暴露了出来，这是优点也是缺点

反射类 可得到的信息
ReflectionObject 对象信息
ReflectionFunction() 函数定义所在的文件以及起始位置
ReflectionClass() 常量、属性、方法、命名空间、类是否为final或abstract等
ReflectionMethod() 方法修饰类型、方法名、方法注释等

反射机制的应用
动态代理：也叫委托请求，在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理
插件系统：利用反射机制自动获取插件列表以及其他相关信息

/**
 * 类A
 * zeng
 */
class A 
{
    public function t1() {
         echo '我是一个不带参数的方法
';
    }

    public function t2($str) {
          echo "我是一个带参数的方法t2，参数是：" .$str,'
';
    }

    private function t3() {

    }

    static function t4() {
        echo '我是一个静态方法';
    }
}
$a = new A();
$ref_cls = new ReflectionClass('A');
$ref_method = $ref_cls->getMethod('t1');// 相当于new ReflectionMethod('A','t1')

//var_dump($ref_cls->hasMethod('t1'));//true
//var_dump($ref_method->isPublic());//true

//执行方法
//静态方法调用 invoke(null,参数)
//普通方法调用 invoke(实例对象,参数)
//私有方法不能用invoke调用
if( $ref_method->isPublic() && !$ref_method->isAbstract() )
{
    if( $ref_method->isStatic() )
    {
        $ref_method->invoke(null);
    } 
    else
    {
        $ref_method->invoke($a);//$a可以换成$ref_cls->newInstance();
    }
}

/*
 * isPublic
 * isPrivate
 * ....
 * */
//$ref_cls_all_method = $ref_cls->getMethods();
//echo '
';
//print_r($ref_cls_all_method);
/*
Array
(
    [0] => ReflectionMethod Object
        (
            [name] => t1
            [class] => A
        )

    [1] => ReflectionMethod Object
        (
            [name] => t2
            [class] => A
        )

    [2] => ReflectionMethod Object
        (
            [name] => t3
            [class] => A
        )

    [3] => ReflectionMethod Object
        (
            [name] => t4
            [class] => A
        )
)
 */
 
 
class A
{
    function showInfo() {
        echo 'Class A showinfo';
    }
}

class B
{
    private $obj;

    function __construct() {
        $this->obj = new A();
    }

    /*function addObj($obj) {
         $this->obj[] = $obj;
    }*/

    function __call($name,$args) {
        $ref_cls = new ReflectionClass($this->obj);

        if($ref_cls->hasMethod($name))
        {
            $ref_method = $ref_cls->getMethod($name);

            if( $ref_method->isPublic() && !$ref_method->isAbstract() )
            {
                if( $ref_method->isStatic() )
                {
                    $ref_method->invoke(null);
                } 
                else
                {
                    $ref_method->invoke($this->obj);
                }
            }

        }
    }


}

$b = new B();

$b->showInfo();
 
 
Plugin.php
interface Plugin 
{
    function showMenu();
}

class MyPlugin implements Plugin
{
    function showMenu() {
        $menu = [
             [
                'name' => 'menu1',
                'link' => 'index.php?id=1'
             ],
             [
                'name' => 'menu2',
                'link' => 'index.php?id=2'
             ],
             [
                'name' => 'menu3',
                'link' => 'index.php?id=3'
             ]
        ];
        return $menu;
    }
}

class HisPlugin implements Plugin
{
    function showMenu() {
        $menu = [
             [
                'name' => 'menu4',
                'link' => 'index.php?id=4'
             ],
             [
                'name' => 'menu5',
                'link' => 'index.php?id=5'
             ],
             [
                'name' => 'menu6',
                'link' => 'index.php?id=6'
             ]
        ];
        return $menu;
    }
}

------------------------------------------
demo.php
include __DIR__ . '/Plugin.php';

function get_plugin_menus() {
    $all_class = get_declared_classes();
    $menus = $menu = [];
    foreach ($all_class as $cls) {
        $ref_cls = new ReflectionClass($cls);
        //判断这个类是否实现了某个接口
        if($ref_cls->implementsInterface('Plugin')) {
            //echo $cls; //MyPlugin HisPlugin
            if($ref_cls->hasMethod('showMenu')){
                $ref_method = $ref_cls->getMethod('showMenu');
                if( $ref_method->isPublic() && !$ref_method->isAbstract() )
                {
                    if( $ref_method->isStatic() )
                    {
                        $menu = $ref_method->invoke(null);
                    }
                    else
                    {
                        //$ref_method->invoke(new $cls());
                        //通过反射类获取类的一个实例
                        $instance = $ref_cls->newInstance();
                        $menu = $ref_method->invoke($instance);
                    }
                }
                $menus = array_merge($menus,$menu);
            }
        }
    }

    return $menus;
}

$menu = get_plugin_menus();
echo '
';
print_r($menu);
/*
 Array
(
    [0] => Array
        (
            [name] => menu1
            [link] => index.php?id=1
        )

    [1] => Array
        (
            [name] => menu2
            [link] => index.php?id=2
        )

    [2] => Array
        (
            [name] => menu3
            [link] => index.php?id=3
        )

    [3] => Array
        (
            [name] => menu4
            [link] => index.php?id=4
        )

    [4] => Array
        (
            [name] => menu5
            [link] => index.php?id=5
        )

    [5] => Array
        (
            [name] => menu6
            [link] => index.php?id=6
        )

)
  */