Letterlijk, het paradigma Reflectie is een proces waarin software zelf kunnen waarnemen, leren over hoe het is ontwikkeld en automatisch aangepast. Is dat duidelijk?. Reeds :P .

Stel, je hebt een klas met een aantal attributen en methoden. Stel nu dat uit een andere klas, voor welke reden nodig om uit te vinden wat attributen en methoden is dat de eerste klasse. Bovendien, stel dat je nodig hebt om de parameters van elke methode opbelt. Je kan het niet!. Nou heb je het mis :P Ja dat kan, Reflectie is het paradigma dat geeft ons de oplossing is geïmplementeerd in PHP met een reeks set van klassen , dat hij alle gedaan. Een soort van reverse engineering.

Zal wel denken, wat het gebruik is dat? Waarom heb ik het nodig?. Nou, het hangt af van wat je doet :P . Waarschijnlijk als je weet dat het bestaat en kan worden gedaan een dag gebruik van maken. In mijn geval nodig is om een dynamisch systeem voor een aantal klassen, methoden lijst te maken en in staat te lopen met al zijn parameters, dat wil zeggen een lijst van alle parameters van een methode in een vorm zijn, je kan vullen en deze methode implement de klas om het resultaat te verkrijgen. U zou kunnen worden geladen in een database van alle klassen, methoden en attributen van deze, maar we moeten een vreselijke onderhoud te maken en in aanmerking genomen, in aanvulling, elke keer dat u iets veranderen, omdat het systeem is in ontwikkeling. Reflectie geeft ons een meer elegante oplossing.

Ons systeem bestaat uit vier stappen:

  • Lijst met beschikbare classes
  • Zodra u een klas, een lijst van hun publieke methoden.
  • Bij het kiezen van een methode, de lijst van hun parameters in een formulier.
  • Voer de methode en het resultaat terug te keren naar de gebruiker.

1) Klasse Lijst

Deze stap is het eenvoudig en duidelijk zijn, in mijn geval alleen de bestanden in de map waar ik allerlei soorten te houden, er is geen truc. Alleen zou rijden in een combo op een formulier voor de gebruiker om de klas te proberen te kiezen.

  1. ( ) ; Klassen $ = array ();
  2. ( "./clases" ) ; D = $ dir (". / klassen");
  3. false !== ( $entry = $d -> read ( ) ) ) { while (false! == ($ item = $ d -> read ())) (
  4. / / Class-bestanden zijn van het type class.nombreClase.php
  5. ( "." , $entry ) ; $ Temp = ontploffen (".", $ entry);
  6. [ count ( $temp ) -1 ] ; $ Ext = $ temp [ count ($ temp) -1];
  7. $ext == 'php' ) { if ($ ext == 'php') (
  8. = $temp [ count ( $temp ) -2 ] ; Klassen $ [] = $ temp [ count ($ temp) -2];
  9. )
  10. )
  11. $clases ) ; natcasesort ($ klassen);
  12. ( array ( "Escoge Clase" ) , $clases ) ; = $ Klassen array_merge ( array ("Select Class"), $ klassen);

2) Verkrijgen van een klasse methoden

We gebruiken nu de klasse ReflectionClass voor de publieke methoden van een klasse. Er zijn veel meer methoden die in deze klasse veel dingen te zien.

  1. ( ) ; Methoden $ = array ();
  2. isset ( $_GET [ 'clase' ] ) && file_exists ( "class." . $_GET [ 'clase' ] . ".php" ) ) { if ( isset ($ _GET ['klasse']) & & file_exists ("class" .. $ _GET ['klasse'] .. "php")) (
  3. "clases/class." . $_GET [ 'clase' ] . ".php" ) ; require_once ("klassen / klasse .. $ klasse"'].." _GET [PHP ");
  4. ReflectionClass ( $_GET [ 'clase' ] ) ; $ Class = nieuwe ReflectionClass ($ _GET ['klasse']);
  5. -> getMethods ( ) ; Methoden = $ $-klasse -> getMethods ();
  6. $metodos as $m ) foreach ($ methoden als $ m)
  7. = $m -> name ; $ Methoden [] = $ m -> naam;
  8. ( array ( "Escoge Método" ) , $methods ) ; Methoden = $ array_merge ( array ("Kies Methode"), $ methoden);
  9. )

Zoals je kunt zien, krijgen we een array met de publieke methoden van de geselecteerde klas, klaar om een andere combo mounten met de beschikbare methoden.

3) Het verkrijgen van de parameters van een methode

Weten nu de methode en klasse die u wilt uitvoeren gewoon om haar punten van beroep te vinden. Het lijkt onmogelijk, maar ook de reflectiegroep API komt ons te hulp.

  1. ( ) ; $ Params = array ();
  2. isset ( $_GET [ 'method' ] ) ) { if ( isset ($ _GET ['methode'])) (
  3. ReflectionClass ( $_GET [ 'clase' ] ) ; $ Class = nieuwe ReflectionClass ($ _GET ['klasse']);
  4. proberen (
  5. -> getMethod ( $method ) ; = $ $ Asmth-klasse -> GetMethodID ($ methode);
  6. $asmth -> getParameters ( ) as $i => $param ) foreach ($ asmth -> getParameters () als $ i => $ param)
  7. = $param -> getName ( ) ; $ Params [] = $ param -> GetName ();
  8. ReflectionException $e ) { } ) Vangst (ReflectionException $ e) ()
  9. )

We hebben weer een array met de parameters van de methode. We moeten alleen een vorm mount met veel tekstvelden als parameters van de methode, zodat de gebruiker kan het proberen.

4) Run-methode

Ik ga deze nog ingewikkelder te meer. Al mijn klassen hebben een geïmplementeerd singleton , die niet kunnen geïnstantieerd worden als :P . We zouden iets hebben gedaan, zoals:

  1. [ 'clase' ] :: getInstancia ( ) ; Klasse $ = $ _GET ['klasse']:: getInstancia ();

Maar PHP biedt geen ondersteuning voor het gebruik van een variabele in de naam van de klasse bij het aanroepen van een statische methode, terug een foutmelding :

Parse error: syntax error, onverwachte T_PAAMAYIM_NEKUDOTAYIM

Wat vertaald uit hebrero :| betekent "Onverwacht dubbele dubbele punt, dat wil zeggen in de dikke darm.

Als we hadden de eenling en niet noodzakelijk op de oproep om de statische bijvoorbeeld aangifte doen van iets zou kunnen doen als:

  1. $_GET [ 'clase' ] ; $ Class = nieuwe $ _GET ['klasse'];
  2. -> metodo ( $parametros ) ; $ Res = $-klasse -> methode ($ params);

Maar we zouden nog steeds een probleem hebben met de parameters we niet weten hoeveel je moet gaan, kunnen we niet ingesteld iets dynamisch in een directe oproep aan een methode.

Het eerste wat je moet doen is bellen met de methode getInstancia in mijn klas, zodat we bijvoorbeeld een terugkeer aan. Voor dat we ingaan op de rol call_user_func vermelding van de klasse en methode uit te voeren.

  1. ( array ( $_GET [ 'clase' ] , 'getInstancia' ) ) ; $ Class = call_user_func ( array ($ _GET ['klasse'], 'getInstancia'));

Nu voeren de overeenkomstige methode op het instantievorming klasse en het passeren van de vereiste parameters in een array, dus dat maakt niet uit hoeveel ze daar, gaan allemaal in een lijst. Om dit te doen gebruiken we deze keer call_user_func_array .

  1. ( ) ; $ Params = array ();
  2. $_GET as $name => $param ) { foreach ($ _GET als $ naam => $ param) (
  3. $name != "clase" && $name != "method" && $name != "submit" ) if ($ naam! = "class" & & $ naam! = "methode" & & $ naam! = "submit")
  4. = $param ; $ Params [] = $ param;
  5. )
  6. ( array ( $class , $method ) , $params ) ; $ Res = call_user_func_array ( array ($ class, $ methode), $ params);

Dat is het. We zijn erin geslaagd om methoden van een klasse te vinden, de parameters en voer het opslaan van alle problemen die we vinden geweest.

Ik hoop dat het zal u helpen :) .

Als je hun nut hebben bewezen dit artikel ... Share!