有不同的方法来解决你的问题。其中一些已经在评论中提到。让我们采取最简单的方法来解决您的问题。

神奇的方法__call（）

正如lovelace在评论中所说的那样，对于another stack overflow article中所述的问题，已经有了一个简单的解决方案。它使用PHP自己的魔法方法__call（）。让我们看一个简单的例子。

class Foo
{
    protected function before() : void
    {
        echo "before";
    }

    protected function after() : void
    {
        echo "after";
    }

    public function __call($method, $arguments)
    {
        if (method_exists($this, $method)) {
            $this->before();
            return call_user_func_array(array($this, $method), $arguments);
        }
    }
}

// Testing
$class = new Foo();
$class->after(); // echoes "before->after"

正如您所看到的，神奇的方法__call为您的目的提供了适当的处理。首先，它检查被调用的方法是否存在，然后在执行被调用的方法之前执行before方法。before方法是在你调用一个类方法时自动调用的。

回调方法

正如在注解中提到的，回调函数可能是一个不处理类示例的可能解决方案。让我们来看看回调的例子。

$callback = function()
{
    echo "before->";
}

function foo(callable $callback, $bla)
{
    $callback();
    echo $bla;
}

// example code
foo($callback, 'go and make some coffee');
// output: "before->go and make some coffee"

这种方法比使用__call方法更简单，因为你只需要一个可调用函数作为函数的参数。很简单，嗯？

• 观察者模式**

观察者模式是php5中的标准php库附带的，而且更加复杂。我想对你的用例来说太复杂了。为了保持完整性，这里有一个简短的例子，说明观察者模式如何成为您的问题的可用解决方案。

class Group implements SplSubject
{
    /**
     * persons in this group
     * @var \SplObjectStorage
     */
    protected $persons;

    /**
     * observer active in this group
     * @var \SplObjectStorage
     */
    protected $observers;

    /**
     * the person, which actually speaks
     * @var Person
     */
    protected $speaker;

    /**
     * Initializes our class members and sets an observer for this group
     */
    public function __construct() 
    {
        $this->persons = new \SplObjectStorage();
        $this->observers = new \SplObjectStorage();

        $onSpeakObserver = new OnSpeakObserver($who, $what);
        $this->attach($onSpeakObserver);
    }

    public function add(Person $person) {
         $this->persons->attach($person);
    }

    public function speak(Person $who, $what) {
        echo $who . " says: " . $what . "<br>";

        $this->speaker = $who;  
        $this->notify();
    } 
    
    public function getSpeaker() {
        return $this->speaker;
    }

    public function getGroup() {
        return $this->persons;
    }

    public function attach(\SplObserver $observer) {
        $this->observers->attach($observer);
    }

    public function detach(\SplObserver $observer) {
        $this->observers->attach($observer);
    }

    public function notify() {
        foreach ($this->observers as $observer) {
             $observer->update($this);
        }
    }
}

这是我们的基本类group，应该遵守。一个应该被观察到的类总是被称为“主体”。一个主体接受一个或多个观察者，这些观察者由主体的notify方法调用。一个小组由几个人和一个发言人组成。总是有一个说话者，其他人是听众，当说话者说什么的时候，他们可以做出React。对于听众的React，我们需要一个观察者。如果说话者说了什么，这个观察者就会倾听。观察者直接添加到组的构造函数中。
这个类实现了\SplSubject接口，它为我们带来了处理观察者的方法attach、detach和notify，我们将观察者附加到组。接下来，我们需要一个人和观察者本身的类。

class Person 
{
    protected $name = '';

    public function __construct(string $name) : void
    {
        $this->name = $name;
    }

    public function __toString() : string
    {
        return $this->name;
    }
}

一个有名字的简单的人。

class OnSpeakObserver implements \SplObserver 
{
    public function update(\SplSubject $subject) 
    {
        foreach ($subject->getGroup() as $person) {
            if ($person !== $subject->getSpeaker()) {
                echo $person . " says: me!<br>";
            }
        }
    }
}

这是我们的观察者，它实现了原生的\SplObserver接口，这迫使我们使用update方法。每当组中有人发言时，都会调用此方法。
有了这些类，我们就有了一个简单的观察者模式。在这个简单的例子中，每当一个群体中的一个人说了什么话，观察者就会迫使他做出React。

// open a group (the subject, which is observed)
$friends = new Group();

// add some persons to our group
$sarah = new Person('Sarah');
$friends->add($sarah);    

$nicole = new Person('Nicole');
$friends->add($nicole);

$marcel = new Person('Marcel');
$friends->add($marcel);

$steffen = new Person('Steffen');
$friends->add($steffen);

// Marcel says ...
$friends->speak($marcel, 'Who likes the observer pattern?');

// result:
// Marcel says: Who likes the observer pattern?
// Sarah says: me!
// Nicole says: me!
// Steffen says: me!

你可以移植这个小例子来解决你的问题。观察者可以监听你的函数的执行，每次你的一个函数被调用时，观察者可以在之前执行另一个函数。如本例所示，观察者只不过是在组中的一个人说了一些话之后执行。你的问题也一样。这完全取决于何时调用主题的notify方法。
如果你有任何问题，请尽管问。