__destruct() 和 __call() 创建无限循环

Question

我大大简化了我的代码，但我正在做的是这样的：

class App{

    protected $apps = [];

    public function __construct($name, $dependencies){
        $this->name = $name;

        $apps = [];
        foreach($dependencies as $dependName){
            $apps[$name] = $dependName($this); // returns an instance of App
        }
        $this->apps = $apps;
    }

    public function __destruct(){
        foreach($this->apps as $dep){
            $result = $dep->cleanup($this);
        }
    }

    public function __call($name, $arguments){
        if(is_callable([$this, $name])){
            return call_user_func_array([$this, $name], $arguments);
        }
    }
}


function PredefinedApp(){
    $app = new App('PredefinedApp', []);

    $app->cleanup = function($parent){
        // Do some stuff
    };
    return $app;
}

然后我创建一个这样的应用程序：

$app = new App('App1', ['PredefinedApp']);

它创建一个App 实例，然后数组中的项目创建任何定义的新应用程序实例，并将它们放入内部应用程序数组中。

当我在主应用程序上执行我的析构函数时，它应该在所有子应用程序上调用cleanup()。但是发生了什么，它正在执行一个无限循环，我不知道为什么。

我确实注意到，如果我注释掉 call_user_func_array，那么 __call() 只会被调用一次，但它不会执行实际的 closure。

我还注意到，如果我在__call() 中执行var_dump()，它会无休止地转储。如果我在 cleanup() 中执行 var_dump() 而不是 http 502 错误。

Answer 1

将您的 __call() 函数替换为以下内容将防止您看到的递归：

public function __call( $method, $arguments ) {
    if ( $this->{$method} instanceof Closure ) {
        return call_user_func_array( $this->{$method}, $arguments );
    } else {
        throw new Exception( "Invalid Function" );
    }
}

---

更多详情请参阅@Rizier123 的回答，但 TLDR 版本是：

问题是您最初调用cleanup() 作为一个方法调用$dep->cleanup() 调用__call()。如果您随后使用call_user_func_array() 并传递[$this, $method]，它会将其作为方法调用，从而再次调用_call() 并触发循环（并且永远实际上 调用cleanup() 方法），而使用$this->{$method} 将调用它作为 Closure 并防止循环。

Answer 2

那么让我们看一下代码，看看这里发生了什么以及为什么：

01|    class App{ 
02|
03|        protected $apps = [];
04|
05|        public function __construct($name, $dependencies){
06|            $this->name = $name;
07|
08|            $apps = [];
09|            foreach($dependencies as $dependName){
10|                $apps[$name] = $dependName($this);
11|            }
12|            $this->apps = $apps;
13|        }
14|
15|        public function __destruct(){
16|            foreach($this->apps as $dep){
17|                $result = $dep->cleanup($this);
18|            }
19|        }
20|
21|        public function __call($name, $arguments){
22|            if(is_callable([$this, $name])){
23|                return call_user_func_array([$this, $name], $arguments);
24|            }
25|        }
26|    }
27|	
28|    function PredefinedApp(){
29|        $app = new App('PredefinedApp', []);
30|
31|        $app->cleanup = function($parent){
32|            //Do stuff like: echo "I'm saved";
33|        };
34|        return $app;
35|    }
36|		
37|    $app = new App('App1', ['PredefinedApp']);

_{注意：为每一行代码添加了行号，所以我可以在下面的答案中引用这些行}

问题

1. 您使用以下行创建：App 的实例：

   $app = new App('App1', ['PredefinedApp']); //第 37 行

2. 构造函数被调用：

   public function __construct($name, $dependencies){ /* 代码在这里 */ } //Line: 05

   2.1。传递以下参数：

   • $name = "App1"
   • $dependencies = ["PredefinedApp"]

3. 您使用此行将$name 分配给$this->name：

   $this->name = $name; //行：06

4. 你用一个空数组初始化$apps：

   $apps = []; //行：08

5. 现在循环遍历$dependencies 的每个元素，这里有1 个元素(["PredefinedApp"])

6. 在循环中执行以下操作：

   6.1 将函数调用的返回值赋给数组索引：

   $apps[$name] = $dependName($this); //行：10
   //$apps["App1"] = PredefinedApp($this);

7. 你调用函数：

   PredefinedApp(){ /* 这里是代码 */} //Line: 28

8. 现在您再次创建一个新实例：App in PredefinedApp() 与以前相同（第 2 - 6 点，期望在构造函数中您有其他变量值 + 您不进入循环，因为数组为空）

9. 您将closure 分配给类属性：

   $app->cleanup = function($parent){ //第 31 行
       // 做类似的事情： echo "I'm saved";
   };

10. 你返回App的新创建对象：

    返回 $app; //第 34 行

11. 这里已经是 __destruct() gets called，因为当函数结束时，refcount 会变为 zval 的 0，并且会触发 __destruct()。但是由于$this->apps 是空的，这里什么也没有发生。

12. 该函数中新创建的对象被返回并分配给数组索引（注意：我们从函数返回到第 6.1 点）：

    $apps[$name] = $dependName($this); //行：10
    //$apps["App1"] = PredefinedApp($this);

13. 构造函数以将本地数组分配给类属性结束：

    $this->apps = $apps; //第 12 行

14. 现在整个脚本结束（我们已经完成了第 37 行）！这意味着对象$app __destruct() is triggered 的原因与函数$app 中的$app 相同

15. 这意味着你现在循环遍历来自$this->apps 的每个元素，它只保存函数的返回对象：

    public function __destruct(){ //Line: 15
        foreach($this->apps as $dep){
            $result = $dep->cleanup($this);
        }
    }

    Array(
        "App1" => App Object
            (
                [apps:protected] => Array
                    (
                    )
    
                [name] => PredefinedApp
                [cleanup] => Closure Object
                    (
                        [parameter] => Array
                            (
                                [$parent] => <required>
                            )
    
                    )
    
            )
    )
    

16. 对于您执行的每个元素（这里只有 1 个）：

    $result = $dep->cleanup($this); //第 17 行

    But you don't call the closure! It tries to call a class method. 所以没有cleanup 类方法，它只是一个类属性。这意味着__call() gets invoked：

    public function __call($name, $arguments){ //第 21 行
        if(is_callable([$this, $name])){
            返回 call_user_func_array([$this, $name], $arguments);
        }
    }

17. $arguments 包含自身 ($this)。而is_callable([$this, $name]) 是TRUE，因为cleanup 可以作为闭包调用。

18. 所以现在我们进入了无穷无尽的东西，因为：

    return call_user_func_array([$this, $name], $arguments); //第 23 行

    被执行，然后看起来像这样：

    return call_user_func_array([$this, "cleanup"], $this);

    然后再次尝试将cleanup 作为方法调用，然后再次调用__call()，依此类推...

因此，在整个脚本的结尾，漏洞灾难开始了。但我有一个好消息，听起来很复杂，但解决方案要简单得多！

解决方案

只是改变：

return call_user_func_array([$this, $name], $arguments); //第 23 行

用这个：

return call_user_func_array($this->$name, $arguments);
                           //^^^^^^^^^^^ See here

因为通过这样更改它，您不会尝试调用方法，而是调用闭包。所以如果你也放：

echo "I'm saved";

在你分配它的闭包中，你最终会得到输出：

I'm saved