Rufen Sie private Methoden und private Eigenschaften von außerhalb einer Klasse in PHP auf

Ich möchte in sehr seltenen Einzelfällen von außerhalb der Klassen auf private Methoden und Variablen zugreifen.

Ich habe gesehen, dass dies nicht möglich ist, obwohl Introspektion verwendet wird.

Der Spezialfall ist der nächste:

Ich hätte gerne sowas:

class Console
{
    final public static function run() {

        while (TRUE != FALSE) {
            echo "\n> ";
            $command = trim(fgets(STDIN));

            switch ($command) {
                case 'exit':
                case 'q':
                case 'quit':
                    echo "OK+\n";
                    return;
                default:
                    ob_start();
                    eval($command);
                    $out = ob_get_contents();
                    ob_end_clean();

                    print("Command: $command");
                    print("Output:\n$out");         

                    break;
            }
        }
    }
}

Diese Methode sollte wie folgt in den Code eingefügt werden können:

Class Demo
{
    private $a;

    final public function myMethod()
    {
        // some code
        Console::run();
        // some other code
    }

    final public function myPublicMethod()
    {
        return "I can run through eval()";
    }

    private function myPrivateMethod()
    {
        return "I cannot run through eval()";
    }
}

(Dies ist nur eine Vereinfachung. Die echte geht durch einen Socket und implementiert eine Reihe weiterer Dinge …)

Damit…

Wenn Sie die Klasse Demo instanziieren und $demo->myMethod() aufrufen, erhalten Sie eine Konsole: Diese Konsole kann auf die erste Methode zugreifen und einen Befehl schreiben wie:

> $this->myPublicMethod();

Aber Sie können den zweiten nicht erfolgreich ausführen:

> $this->myPrivateMethod();

Hat jemand von euch eine Idee oder gibt es eine Bibliothek für PHP, mit der Sie dies tun können?

Vielen Dank!

Machen Sie die Methode einfach öffentlich. Aber wenn Sie knifflig werden wollen, können Sie dies versuchen (PHP 5.3):

class LockedGate
{
    private function open()
    {
        return 'how did you get in here?!!';
    }
}

$object = new LockedGate();
$reflector = new ReflectionObject($object);
$method = $reflector->getMethod('open');
$method->setAccessible(true);
echo $method->invoke($object);

BEARBEITEN:
Aktualisiert, um Beispiele für private Funktionsaufrufe mit Parametern aufzunehmen.

Ab PHP5.4können Sie die vordefinierten verwenden Closure Klasse, um eine Methode/Eigenschaft einer Klasse an eine Delta-Funktion zu binden, die sogar Zugriff auf private Mitglieder hat.

Die Closure-Klasse

Zum Beispiel haben wir eine Klasse mit einer privaten Variablen und möchten außerhalb der Klasse darauf zugreifen:

class Foo {
    private $bar = "Foo::Bar";
    private function add_ab($a, $b) {
        return $a + $b;
    }
}

PHP5.4+

$foo = new Foo;

// Single variable example
$getFooBarCallback = function() {
    return $this->bar;
};

$getFooBar = $getFooBarCallback->bindTo($foo, 'Foo');

echo $getFooBar(); // Prints Foo::Bar

// Function call with parameters example
$getFooAddABCallback = function() {
    // As of PHP 5.6 we can use $this->fn(...func_get_args()) instead of call_user_func_array
    return call_user_func_array(array($this, 'add_ab'), func_get_args());
};

$getFooAddAB = $getFooAddABCallback->bindTo($foo, 'Foo');

echo $getFooAddAB(33, 6); // Prints 39

Ab PHP 7 können Sie die neue verwenden Closure::call Methode, um jede Methode/Eigenschaft eines Objekts an eine Callback-Funktion zu binden, auch für private Mitglieder:

PHP7+

$foo = new Foo;

// Single variable example
$getFooBar = function() {
    return $this->bar;
};

echo $getFooBar->call($foo); // Prints Foo::Bar

// Function call with parameters example
$getFooAddAB = function() {
    return $this->add_ab(...func_get_args());
};

echo $getFooAddAB->call($foo, 33, 6); // Prints 39

Die erste Frage, die Sie stellen sollten, lautet: Wenn Sie von außerhalb der Klasse darauf zugreifen müssen, warum haben Sie es als privat deklariert? Wenn es nicht Ihr Code ist, hatte der Urheber wahrscheinlich einen guten Grund, ihn als privat zu deklarieren, und der direkte Zugriff darauf ist a sehr schlechte (und weitgehend unhaltbare) Praxis.

BEARBEITEN: Wie Adam V. in den Kommentaren betont, müssen Sie die private Methode zugänglich machen, bevor Sie sie aufrufen. Codebeispiel wurde aktualisiert, um dies einzuschließen. Ich habe es jedoch nicht getestet – nur hier hinzugefügt, um die Antwort auf dem neuesten Stand zu halten.

Davon abgesehen können Sie verwenden Betrachtung um das zu erreichen. Instanziieren ReflectionClassAnruf getMethod für die Methode, die Sie aufrufen möchten, und rufen Sie dann auf invoke auf dem Retournierten ReflectionMethod.

Ein Codebeispiel (obwohl ich es nicht getestet habe, daher können Fehler auftreten) könnte so aussehen

$demo = new Demo();
$reflection_class = new ReflectionClass("Demo");
$reflection_method = $reflection_class->getMethod("myPrivateMethod");
$reflection_method->setAccessible(true);
$result = $reflection_method->invoke($demo, NULL);

Hier ist eine Variation der anderen Antworten, die verwendet werden können, um solche Anrufe auf einer Leitung zu tätigen:

public function callPrivateMethod($object, $methodName)
{
    $reflectionClass = new \ReflectionClass($object);
    $reflectionMethod = $reflectionClass->getMethod($methodName);
    $reflectionMethod->setAccessible(true);

    $params = array_slice(func_get_args(), 2); //get all the parameters after $methodName
    return $reflectionMethod->invokeArgs($object, $params);
}

Ich habe diese Probleme auch manchmal, aber ich umgehe sie durch meine Codierungsstandards. Private oder geschützte Funktionen werden mit einem vorangestellten Unterstrich gekennzeichnet, dh

private function _myPrivateMethod()

Dann mache ich die Funktion einfach öffentlich.

public function _myPrivateMethod()

Obwohl die Funktion öffentlich ist, gibt die Namenskonvention die Benachrichtigung, dass während öffentlich ist, privat ist und nicht wirklich verwendet werden sollte.

Wenn Sie in der Klasse, in der die Methode definiert ist, eine Methode hinzufügen können, können Sie eine Methode hinzufügen, die intern call_user_method() verwendet. Dies funktioniert auch mit PHP 5.2.x

<?php
class SomeClass {
    public function callprivate($methodName) {
         call_user_method(array($this, $methodName));
    }

    private function somePrivateMethod() {
         echo 'test';
    }
}


$object = new SomeClass();
$object->callprivate('somePrivateMethod');

Die Antwort wird der Methode öffentlich zugänglich gemacht. Welchen Trick Sie auch immer machen werden, es wäre für andere Entwickler nicht verständlich. Zum Beispiel wissen sie nicht, dass bei einem anderen Code auf diese Funktion als öffentlich zugegriffen wurde, indem sie sich die Demo-Klasse ansehen.

Eine Sache noch. Diese Konsole kann auf die erste Methode zugreifen und einen Befehl schreiben wie:. Wie kann das überhaupt möglich sein? Die Konsole kann mit $this nicht auf Funktionen der Demoklasse zugreifen.