ZF Zend Framework

Behind the Site

Programmer's Reference Guide

Einführung
Zend_CodeGenerator
Referenzhandbuch für Programmierer

Zend_CodeGenerator Beispiele

Beispiel #1 Erzeugung von PHP Klassen

Das folgende Beispiel erzeugt eine leere Klasse mit einem Klassen-level DocBlock.

  1. $foo      = new Zend_CodeGenerator_Php_Class();
  2. $docblock = new Zend_CodeGenerator_Php_Docblock(array(
  3.     'shortDescription' => 'Beispiel einer erzeugten Klasse',
  4.     'longDescription'  => 'Das ist eine mit Zend_CodeGenerator '
  5.                         . 'erzeugte Klasse.',
  6.     'tags'             => array(
  7.         array(
  8.             'name'        => 'version',
  9.             'description' => '$Rev:$',
  10.         ),
  11.         array(
  12.             'name'        => 'license',
  13.             'description' => 'New BSD',
  14.         ),
  15.     ),
  16. ));
  17. $foo->setName('Foo')
  18.     ->setDocblock($docblock);
  19. echo $foo->generate();

Der obige Code führt zu dem folgenden:

  1. /**
  2. * Beispiel einer erzeugten Klasse
  3. *
  4. * Das ist eine mit Zend_CodeGenerator erzeugte Klasse.
  5. *
  6. * @version $Rev:$
  7. * @license New BSD
  8. *
  9. */
  10. class Foo
  11. {
  12.  
  13. }

Beispiel #2 Erzeugung von PHP Klassen mit Klassen-Eigenschaften

Aufbauend auf dem vorherigen Beispiel, fügen wir jetzt Eigenschaften in unsere erzeugte Klasse ein.

  1. $foo      = new Zend_CodeGenerator_Php_Class();
  2. $docblock = new Zend_CodeGenerator_Php_Docblock(array(
  3.     'shortDescription' => 'Beispiel einer erzeugten Klasse',
  4.     'longDescription'  => 'Das ist eine mit Zend_CodeGenerator '
  5.                         . 'erzeugte Klasse.',
  6.     'tags'             => array(
  7.         array(
  8.             'name'        => 'version',
  9.             'description' => '$Rev:$',
  10.         ),
  11.         array(
  12.             'name'        => 'license',
  13.             'description' => 'New BSD',
  14.         ),
  15.     ),
  16. ));
  17. $foo->setName('Foo')
  18.     ->setDocblock($docblock)
  19.     ->setProperties(array(
  20.         array(
  21.             'name'         => '_bar',
  22.             'visibility'   => 'protected',
  23.             'defaultValue' => 'baz',
  24.         ),
  25.         array(
  26.             'name'         => 'baz',
  27.             'visibility'   => 'public',
  28.             'defaultValue' => 'bat',
  29.         ),
  30.         array(
  31.             'name'         => 'bat',
  32.             'const'        => true,
  33.             'defaultValue' => 'foobarbazbat',
  34.         ),
  35.     ));
  36. echo $foo->generate();

Das obige führt zu der folgenden Klassen-Definition:

  1. /**
  2. * Beispiel einer erzeugten Klasse
  3. *
  4. * Das ist eine mit Zend_CodeGenerator erzeugte Klasse.
  5. *
  6. * @version $Rev:$
  7. * @license New BSD
  8. *
  9. */
  10. class Foo
  11. {
  12.  
  13.     protected $_bar = 'baz';
  14.  
  15.     public $baz = 'bat';
  16.  
  17.     const bat = 'foobarbazbat';
  18.  
  19. }

Beispiel #3 Erzeugung von PHP Klassen mit Klassen-Methoden

Zend_CodeGenerator_Php_Class erlaubt es Methoden mit optionalem Inhalt zur Klasse hinzuzufügen. Methoden können entweder als Array oder als konkrete Instanzen von Zend_CodeGenerator_Php_Method hinzugefügt werden.

  1. $foo      = new Zend_CodeGenerator_Php_Class();
  2. $docblock = new Zend_CodeGenerator_Php_Docblock(array(
  3.     'shortDescription' => 'Beispiel einer erzeugten Klasse',
  4.     'longDescription'  => 'Das ist eine mit Zend_CodeGenerator '
  5.                         . 'erzeugte Klasse.',
  6.     'tags'             => array(
  7.         array(
  8.             'name'        => 'version',
  9.             'description' => '$Rev:$',
  10.         ),
  11.         array(
  12.             'name'        => 'license',
  13.             'description' => 'New BSD',
  14.         ),
  15.     ),
  16. ));
  17. $foo->setName('Foo')
  18.     ->setDocblock($docblock)
  19.     ->setProperties(array(
  20.         array(
  21.             'name'         => '_bar',
  22.             'visibility'   => 'protected',
  23.             'defaultValue' => 'baz',
  24.         ),
  25.         array(
  26.             'name'         => 'baz',
  27.             'visibility'   => 'public',
  28.             'defaultValue' => 'bat',
  29.         ),
  30.         array(
  31.             'name'         => 'bat',
  32.             'const'        => true,
  33.             'defaultValue' => 'foobarbazbat',
  34.         ),
  35.     ))
  36.     ->setMethods(array(
  37.         // Methoden als Array übergeben
  38.         array(
  39.             'name'       => 'setBar',
  40.             'parameters' => array(
  41.                 array('name' => 'bar'),
  42.             ),
  43.             'body'       => '$this->_bar = $bar;' . "\n" . 'return $this;',
  44.             'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
  45.                 'shortDescription' => 'Setzt die bar Eigenschaft',
  46.                 'tags'             => array(
  47.                     new Zend_CodeGenerator_Php_Docblock_Tag_Param(array(
  48.                         'paramName' => 'bar',
  49.                         'datatype'  => 'string'
  50.                     )),
  51.                     new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
  52.                         'datatype'  => 'string',
  53.                     )),
  54.                 ),
  55.             )),
  56.         ),
  57.         // Methoden als konkrete Instanz übergeben
  58.         new Zend_CodeGenerator_Php_Method(array(
  59.             'name' => 'getBar',
  60.             'body'       => 'return $this->_bar;',
  61.             'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
  62.                 'shortDescription' => 'Empfängt die bar Eigenschaft',
  63.                 'tags'             => array(
  64.                     new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
  65.                         'datatype'  => 'string|null',
  66.                     )),
  67.                 ),
  68.             )),
  69.         )),
  70.     ));
  71.  
  72. echo $foo->generate();

Das obige erzeugt die folgende Ausgabe:

  1. /**
  2. * Beispiel einer erzeugten Klasse
  3. *
  4. * Das ist eine mit Zend_CodeGenerator erzeugte Klasse.
  5. *
  6. * @version $Rev:$
  7. * @license New BSD
  8. */
  9. class Foo
  10. {
  11.  
  12.     protected $_bar = 'baz';
  13.  
  14.     public $baz = 'bat';
  15.  
  16.     const bat = 'foobarbazbat';
  17.  
  18.     /**
  19.      * Setzt die bar Eigenschaft
  20.      *
  21.      * @param string bar
  22.      * @return string
  23.      */
  24.     public function setBar($bar)
  25.     {
  26.         $this->_bar = $bar;
  27.         return $this;
  28.     }
  29.  
  30.     /**
  31.      * Empfängt die bar Eigenschaft
  32.      *
  33.      * @return string|null
  34.      */
  35.     public function getBar()
  36.     {
  37.         return $this->_bar;
  38.     }
  39.  
  40. }

Beispiel #4 Erzeugung von PHP Dateien

Zend_CodeGenerator_Php_File kann verwendet werden um den Inhalt einer PHP Datei zu erzeugen. Man kann Klassen inkludieren als auch eigene Inhalte. Wenn Klassen angegängt werden sollte man entweder eine konkrete Instanz von Zend_CodeGenerator_Php_Class oder ein Array das die Klasse definiert anhängen.

Das folgende Beispiel nimmt an das wir $foo mit einer der Klassen-Definitionen der vorherigen Beispiele definiert haben.

  1. $file = new Zend_CodeGenerator_Php_File(array(
  2.     'classes'  => array($foo);
  3.     'docblock' => new Zend_CodeGenerator_Php_Docblock(array(
  4.         'shortDescription' => 'Foo Klassen Datei',
  5.         'tags'             => array(
  6.             array(
  7.                 'name'        => 'license',
  8.                 'description' => 'New BSD',
  9.             ),
  10.         ),
  11.     )),
  12.     'body'     => 'define(\'APPLICATION_ENV\', \'testing\');',
  13. ));

Der Aufruf von generate() erzeugt den Code -- schreibt Ihn aber nicht in die Datei. Man muß den Inhalt holen und Ihn selbst in eine Datei schreiben. Als Beispiel:

  1. $code = $file->generate();
  2. file_put_contents('Foo.php', $code);

Das obige erzeugt die folgende Datei:

  1. <?php
  2. /**
  3. * Foo Klassen Datei
  4. *
  5. * @license New BSD
  6. */
  7.  
  8. /**
  9. * Beispiel einer erzeugten Klasse
  10. *
  11. * Das ist eine mit Zend_CodeGenerator erzeugte Klasse.
  12. *
  13. * @version $Rev:$
  14. * @license New BSD
  15. */
  16. class Foo
  17. {
  18.  
  19.     protected $_bar = 'baz';
  20.  
  21.     public $baz = 'bat';
  22.  
  23.     const bat = 'foobarbazbat';
  24.  
  25.     /**
  26.      * Set the bar property
  27.      *
  28.      * @param string bar
  29.      * @return string
  30.      */
  31.     public function setBar($bar)
  32.     {
  33.         $this->_bar = $bar;
  34.         return $this;
  35.     }
  36.  
  37.     /**
  38.      * Retrieve the bar property
  39.      *
  40.      * @return string|null
  41.      */
  42.     public function getBar()
  43.     {
  44.         return $this->_bar;
  45.     }
  46.  
  47. }
  48.  
  49. define('APPLICATION_ENV', 'testing');

Beispiel #5 Sähen der Code Erzeugung einer PHP Datei über Reflection

Man kann PHP Code zu einer existierenden PHP Datei hinzufügen indem der Code Generator verwendet wird. Um das Durchzuführen muß man auf diesem zuerst Reflection ausführen. Die statische Methode fromReflectedFileName() erlaubt es das zu tun.

  1. $generator = Zend_CodeGenerator_Php_File::fromReflectedFileName($path);
  2. $body = $generator->getBody();
  3. $body .= "\n\$foo->bar();";
  4. file_put_contents($path, $generator->generate());

Beispiel #6 Sähen der Erzeugung einer PHP Klasse über Reflection

Man kann Code zu einer bestehenden Klasse hinzufügen. Um das Durchzuführen muß die statiche fromReflection() Methode verwendet werden um die Klasse in ein Generator Objekt zu mappen. Von dort, kann man zusätzliche Eigenschaften oder Methoden hinzufügen und die Klasse neu erstellen.

  1. $generator = Zend_CodeGenerator_Php_Class::fromReflection(
  2.     new Zend_Reflection_Class($class)
  3. );
  4. $generator->setMethod(array(
  5.     'name'       => 'setBaz',
  6.     'parameters' => array(
  7.         array('name' => 'baz'),
  8.     ),
  9.     'body'       => '$this->_baz = $baz;' . "\n" . 'return $this;',
  10.     'docblock'   => new Zend_CodeGenerator_Php_Docblock(array(
  11.         'shortDescription' => 'Die baz Eigenschaft setzen',
  12.         'tags'             => array(
  13.             new Zend_CodeGenerator_Php_Docblock_Tag_Param(array(
  14.                 'paramName' => 'baz',
  15.                 'datatype'  => 'string'
  16.             )),
  17.             new Zend_CodeGenerator_Php_Docblock_Tag_Return(array(
  18.                 'datatype'  => 'string',
  19.             )),
  20.         ),
  21.     )),
  22. ));
  23. $code = $generator->generate();
Einführung
Zend_CodeGenerator
Referenzhandbuch für Programmierer
blog comments powered by Disqus

Select a Version

Languages Available

Components

Search the Manual

    • Navigation