Hello World · PHP Framework Symfony 2.7, Lernprogramm Schritt für Schritt

Hello World · PHP Framework Symfony 2.7, Lernprogramm Schritt für Schritt. Dieser Teil des Tutorials setzt auf "Learning by Doing". Also los...

Die Motivation, sich mit dem PHP Framework Symfony 2.7 auseinanderzusetzen, sollte nicht durch zuviel Theorie gebremst werden. Deshalb gleich mal das berühmte "Hello World". Damit hat man schon mal eine Ahnung wie Symfony funktioniert.

Hello World · PHP Framework Symfony 2.7, Lernprogramm Schritt für Schritt
Hello World · PHP Framework Symfony 2.7, Lernprogramm Schritt für Schritt

Schritt für Schritt Anleitung "Hello World" mit Symfony 2.7

Die Entwicklung der Schritt für Schritt Anleitung "Hello World" mit Symfony 2.7 kann im Browser unter folgender Adresse verfolgt werden:

http://localhost/mein_projekt_name/web/app_dev.php/hello-world
  • localhost ( oder 127.0.0.1 ) -> weist auf das Verzeichnis htdocs innerhalb des Verzeichnises XAMPP
  • mein_projekt_name -> weist auf den Verzeichnis-Namen des Projektes innerhalb von htdocs ( hier symfony_lernen )
  • web -> weist auf das Verzeichnis web innerhalb des Projektes
  • app_dev.php -> ist ein vom Framework bereitgestelltes Script, welches der Kontrolle der Entwicklung dient
  • hello-world -> URL-Parameter

Screenshot Verzeichnis-Hierachie

Folgende Scripts des Frameworks werden gebraucht für diese Anleitung, bitte im Editor öffnen:

  • DefaultController.php ( Verzeichnis eigener_projekt_name/src/AppBundle/Controller )
  • base.html.twig ( Verzeichnis eigener_projekt_name/app/Resources/view )
  • index.html.twig ( Verzeichnis eigener_projekt_name/app/Resources/view/default )
In der Ausgangskonfiguration des Frameworks wird bei o.g. Adresse das Script DefaultController.php geladen, dieses Script ist der Controller. Innerhalb dieses Scriptes wird der Pfad zum Script definiert, welches seinen Inhalt unter der geforderten URL http://.../web/app_dev.php/... im Browser zurückgibt. In der Grundkonfiguration den Inhalt vom Script index.html.twig.

Die wichtigsten Vorgänge im Backend des Framework Symfony 2.7 bei Anforderung einer Seite über eine URL, werden im nächsten Teil des Tutorials erklärt. Diese Schritt für Schritt Anleitung> soll zeigen, wie ein "Hello World" in Symfony 2.7 mit aus verschieden Anforderungen erzeugt wird.

Ausgangssituation für "Hello World" im Projekt Framework

  • Die Ausgabe im Browser bei angeforderter URL http://.../web/app_dev.php/hello-world ist eine von Symfony 2.7 generierte 404 Fehlerseite aus. Ausserdem beeinhaltet diese Seite eine Information:
    No route found for "GET /hello-world"
    Screenshot Browser-Ausgabe http://localhost/mein_projekt_name/web/app_dev.php/hello-world
  • Die Datei DefaultController.php, der Controller, nimmt die Anfrage ( HTTP-Request ) entgegen und gibt letzlich die Fehler-Information ( 404 ) an den Browser aus. Also der Controller innerhalb des Frameworks steuert alle Vorgänge im Backend für die Ausgabe am Frontend. Deshalb ein erster Blick in die DefaultController.php in der Grundkonfiguration von Symfony 2.7:

    Quelltext DefaultController.php
    <?php
    // src/AppBundle/Controller/DefaultController.php
    namespace AppBundle\Controller;
    
    use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
    use Symfony\Bundle\FrameworkBundle\Controller\Controller;
    use Symfony\Component\HttpFoundation\Request;
    
    class DefaultController extends Controller
    {
        /**
         * @Route("/", name="homepage")
         */
        public function indexAction(Request $request)
        {
            // replace this example code with whatever you need
            return $this->render('default/index.html.twig', array(
                'base_dir' => realpath($this->container->getParameter('kernel.root_dir').'/..'),
            ));
        }
    }

Allgemeines zum Grundverständnis der nächsten Schritte

Der Controller DefaultController.php ist praktisch die Person hinter der Ladentheke. Er nimmt die Bestellung entgegen, sucht die einzelnen Bestandteile der Bestellung zusammen und liefert diese dann wieder aus. Die Bestellung ist die URL. Mit der URL also wird die Information übergeben, welche gebraucht wird um die Bestellung zusammenzustellen und im Browserfenster auszugeben.

Dem Controller mitzuteilen, was er zu tun hat wenn eine URL übergeben wird, ist die erste Hürde. Im diesem Fall soll der Controller "Hello World" ausgeben. Angefordert wird dies über den URL-Parameter .../hello-world. Die Übergabe bzw. Definition erfolgt in der Annotation ( Lesestoff!Symfony Annotations ).

Sollte der URL-Parameter nicht mit der in der Annotation definierten @Route übereinstimmen, gibt der Controller die o.g. Fehlerseite aus.

  • Ist der URL-Parameter in der Annotation @Route angepasst / definiert innerhalb der Klasse class DefaultController ?

    JA folgende Funktion function IndexAction() wird ausgeführt
    NEIN Fehlerseite 404 wird ausgegeben
  • Inhalt des Script index.html.twig aus dem Verzeichnis .../mein_projekt_name/app/view/default/ wird ausgegeben

    Die Ausgabe am Browser, der RESPONSE, wird mittels der TWIG Template Engine erzeugt ( Lesestoff!Homepage TWIG ).

Schritt für Schritt Fest kodiertes "Hello World" ( hard-coding )

  1. Script index.html.twig mit "Hello World" anpassen

    Tipp!Um mit der index.html.twig zu Test-Zwecken zu arbeiten, ist es hilfreich, zuerst eine Kopie der orginalen Datei zu erstellen. So kann die Grundkonfiguration des Framework Symfony 2.7 schnell wieder hergestellt werden.

    Die Anpassung des Script ist einfach: Den gesammten Inhalt des Dokumentes mit "Hello World" überschreiben.

    Quelltext index.html.twig
    Hello World
  2. Im Script DefaultController.php innerhalb der Annotation @Route definieren

    Im Script DefaultController.php soll über die Funktion function IndexAction() das Script index.html.twig aufgerufen werden. Dazu muss der URL-Parameter über der Funktion in der Annotation @Route definiert sein.

    Quelltext DefaultController.php ( Achtung!Veränderung ist rot markiert )
    <?php
    // src/AppBundle/Controller/DefaultController.php
    namespace AppBundle\Controller;

    use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route; use Symfony\Bundle\FrameworkBundle\Controller\Controller; use Symfony\Component\HttpFoundation\Request; class DefaultController extends Controller { /** * @Route("/hello-world", name="homepage") */ public function indexAction(Request $request) { // replace this example code with whatever you need return $this->render('default/index.html.twig', array( 'base_dir' => realpath($this->container->getParameter('kernel.root_dir').'/..'), )); } }
  3. Ergebnis fest kodiertes "Hello World" im Browser ausgeben

    Um das Ergebnis nun zu kontrollieren, die URL in den Browser eingeben und die Ausgabe sollte sich so oder so ähnlich darstellen, wie im Screenshot:

    Screenshot Browser-Ausgabe http://.../app_dev.php/hello-world mit fest kodierten "Hello World"

Schritt für Schritt "Hello World" als variabler URL-Parameter

Hello World in der URL wird variabel. Das heisst, index.html.twig gibt aus, was in der URL steht.

  1. Script index.html.twig variabel anpassen

    Zwei in geschweiften Klammern gefasster Inhalt in TWIG ( Lesestoff! Twig : Templatesprache für PHP ), gibt diesen wieder. Ohne Anführungszeichen wird der Inhalt als Variable definiert und der Inhalt der Variable ausgegeben.

    index.html.twig
    {{ variable }}
  2. Im Script DefaultController.php Variable des URL-Parameters in der Annotation @Route definieren

    Im Script DefaultController.php soll über die Funktion function IndexAction() das Script index.html.twig aufgerufen werden. Dazu muss in der Annotation über der Funktion die @Route definiert sein.

    DefaultController.php ( Achtung!Veränderung ist rot markiert )
    <?php 
    // src/AppBundle/Controller/DefaultController.php
    namespace AppBundle\Controller;
    use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route; use Symfony\Bundle\FrameworkBundle\Controller\Controller; use Symfony\Component\HttpFoundation\Request; class DefaultController extends Controller { /** * @Route("/{variable}", name="homepage") */ public function indexAction(Request $request, $variable ) { // replace this example code with whatever you need return $this->render('default/index.html.twig', array( 'base_dir' => realpath($this->container->getParameter('kernel.root_dir').'/..'), 'variable' => $variable )); } }
  3. Ergebnis "Hello World" als variablen URL-Parameter im Browser ausgeben

    Screenshot Browser-Ausgabe http://.../app_dev.php/hello-world mit variabler URL

Schritt für Schritt "Hello World" aus MySQL-Datenbank

Anhand des URL-Parameters wird eine Datenbankabfrage ausgeführt, welche das Ergebnis an das Script zurückgibt, und schliesslich am Browser ausgegeben wird.

Die Abfrage wird mittels Doctrine realisiert. Doctrine ist Bestandteil des Frameworks Symfony 2.7

Programmierer, die mit Doctrine arbeiten, müssen ihre Abfragen nicht länger in SQL formulieren. Der objektorientierte Ansatz ermöglicht ein abstraktes Arbeiten unabhängig von der verwendeten Datenbank.

Für Schritt für Schritt "Hello World" aus MySql-Datenbank mit Symfony 2.7 Framework wird der URL-Parameter umgeschrieben: .../mein_projekt_name/web/app_dev.php/hello-world/deutsch ( wahlweise "englisch" ).
Das "Hello World" soll mittels des URL-Parameters entweder in Deutsch oder in Englisch ausgegeben werden.

  1. MySQL-Datenbank, Vorraussetzung für die Abfrage

    • Datenbank existiert
    • Tabelle mit Daten existiert ( oder einfach mit folgenden Code erzeugen )
      CREATE TABLE `hello_world` (
      	`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT,
      	`return` CHAR(50) NOT NULL DEFAULT '0',
      	`condition` CHAR(50) NOT NULL DEFAULT '0',
      	PRIMARY KEY (`id`)
      )
      ENGINE=InnoDB;
      
      INSERT INTO 
        `hello_world` (`return`, `condition`) 
      VALUES 
        ('Hallo Welt', 'deutsch'),
        ('Hello World', 'englisch');
  2. Doctrine für die Abfrage konfigurieren

    Wie schon erwähnt, wird die Abfrage über Doctrine realisiert. Dazu benötigt es einige vorbereitende Schritte.

    1. Konfiguration der Verbindung zur Datenbank ist eingerichtet / angepasst. Das kann in der Datei .../mein_projekt_name/app/config/parameters.yml überprüft werden.
    2. Eine Entity muss eingerichtet werden. Eine Entity ist eine Klasse, die eine Tabelle der Datenbank repräsentiert. ( Lesestoff! Doctrine: Eine Einführung #Entity ).

      Entity wird am einfachsten über die Konsole ( Eingabeaufforderung ) erstellt. Der bestätigte Befehl zum Erstellen der Entity löst eine Erstellungsroutine aus (rot markiert sind die angepassten Werte):

      1. Konsole öffnen und ins Verzeichniss C:\xampp\htdocs\mein_projekt_name ( Projekt Name hier = symfony_lernen ) wechseln
      2. Der Befehl zum Erstellen: C:\xampp\htdocs\symfony_lernen> php app/console doctrine:generate:entity
      3. Name der Entity: The Entity shortcut name: AppBundle:HelloWorld
      4. Format der Konfiguration: Configuration format (yml, xml, php, or annotation) [annotation]:. Durch Bestätigung ( ↵ Enter ) wird die Voreinstellung [annotation] akzeptiert.
      5. Felder für die Entity einrichten:
        1. Feld "ausgabe"
          1. New field name (press to stop adding fields): ausgabe
          2. Field type [string]: Durch Bestätigung ( ↵ Enter ) wird die Voreinstellung [string] akzeptiert.
          3. Field length [255]: 50
        2. Feld "sprache"
          1. New field name (press to stop adding fields): sprache
          2. Field type [string]: Durch Bestätigung ( ↵ Enter ) wird die Voreinstellung [string] akzeptiert.
          3. Field length [255]: 50
        3. New field name (press to stop adding fields): Durch Bestätigung ( ↵ Enter ) wird die Einrichtung von Feldern beendet.
      6. Benutzerdefinierte Repository-Klasse erstellen: Do you want to generate an empty repository class [no]? yes. Diese Klasse wird genutzt, um später eigene Methoden / Funktionen für Abfragen definieren.
      7. Die Erstellung der Entity bestätigen: Do you confirm generation [yes]? Durch Bestätigung ( ↵ Enter ) wird die Voreinstellung [yes] akzeptiert.
      Konsole (Eingabeaufforderung) Achtung!In den Klammern ( → ... ) stehen die zugehörigen Anpassungen / Eingaben, sie sind kein Teil der Eingaben in die Konsole!
      C:\xampp\htdocs\symfony_lernen>php app/console  doctrine:generate:entity  ( → 2. )
      
        Welcome to the Doctrine2 entity generator
      
      This command helps you generate Doctrine2 entities.
      
      First, you need to give the entity name you want to generate.
      You must use the shortcut notation like AcmeBlogBundle:Post.
      
      The Entity shortcut name: AppBundle:HelloWorld  ( → 3. )
      
      Determine the format to use for the mapping information.
      
      Configuration format (yml, xml, php, or annotation) [annotation]:  ( → 4. )
      
      Instead of starting with a blank entity, you can add some fields now.
      Note that the primary key will be added automatically (named id).
      
      Available types: array, simple_array, json_array, object,
      boolean, integer, smallint, bigint, string, text, datetime, datetimetz,
      date, time, decimal, float, binary, blob, guid.
      
      New field name (press  to stop adding fields): ausgabe  ( → 5.1.1 )
      Field type [string]:  ( → 5.1.2 )
      Field length [255]: 50  ( → 5.1.3 )
      
      New field name (press  to stop adding fields): sprache  ( → 5.2.1 )
      Field type [string]:  ( → 5.2.2 )
      Field length [255]: 50  ( → 5.2.3 )
      
      New field name (press  to stop adding fields):  ( → 5.3 )
      
      Do you want to generate an empty repository class [no]? yes  ( → 6. )
      
        Summary before generation
      
      You are going to generate a "AppBundle:HelloWorld" Doctrine2 entity
      using the "annotation" format.
      
      Do you confirm generation [yes]?  ( → 7. )
      
        Entity generation
      
      Generating the entity code: OK
      
        You can now start using the generated code!
      
      C:\xampp\htdocs\symfony_lernen>
                        

    Nach Abschluss der Routine, ist ein neues Verzeichnis .../AppBundle/Entity/ mit zwei neuen Dateien erzeugt wurden, HelloWorld.php und HelloWorldRepository.php

    Screenshot generiertes EntityVerzeichnis

  3. Script index.html.twig anpassen

    Das Script index.html.twig kann einfach aus der Schritt für Schritt - "Hello World" als variabler URL-Parameter übernommen werden, Änderungen sind nicht nötig.

    index.html.twig
    {{ variable }}
  4. Script DefaultController.php für die Anfrage ( Request ) und die Rückgabe ( Response ) anpassen

    Das Script arbeitet innerhalb der Funktion indexAction zwei Aufgaben ab.

    1. Verarbeiten SQL-Query´s mit dem übergebenen URL-Parameter $variable und Rückgabe eines Array $arrSQLReturn.
    2. Entsprechend dem Inhalt des Array $arrSQLReturn wird der Response innerhalb einer Prüfung mittels if(){}else(){} aufbereitet und ausgegeben:
      1. Array leer ( if( empty( $arrSQLReturn ) ){...} ): "Nicht gefunden in der Sprache ..."
      2. Array mit Inhalt ( else{...} ): "aus der MySQL-Datenbank: Hallo Welt in ..."

    DefaultController.php ( Achtung!Veränderung ist rot markiert )
    <?php 
    // src/AppBundle/Controller/DefaultController.php
    namespace AppBundle\Controller;
    use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route; use Symfony\Bundle\FrameworkBundle\Controller\Controller; use Symfony\Component\HttpFoundation\Request; class DefaultController extends Controller { /** * @Route("/hello-world/{variable}", name="homepage") */ public function indexAction(Request $request, $variable ) { // replace this example code with whatever you need $arrSQLReturn = $this->getDoctrine() ->getRepository('AppBundle:HelloWorld') -> findby( array( 'sprache' => $variable ) ); if ( empty( $arrSQLReturn ) ) { return $this -> render( 'default/index.html.twig', array ( "variable" => 'Nicht gefunden in der Sprache '.$variable ) ); } else{ $ausgabe = $arrSQLReturn[0]->getAusgabe(); return $this -> render( 'default/index.html.twig', array ( "variable" => "aus der MySQL-Datenbank: " .$ausgabe. " in " .$variable ) ); } } }
  5. Ergebnis "Hello World" aus MySQL-Datenbank im Browser ausgeben

    Screenshot Browser-Ausgabe http://.../app_dev.php/hello-world/deutsch aus Datenbank mit variablen URL-Parameter

Zusammenfassung Schritt für Schritt Anleitung "Hello World" mit Symfony 2.7

Diese Schritt für Schritt Anleitung soll beim Einstieg in Symfony 2.7+ eine Hilfestellung geben. Mithilfe dieses "Hello World" wird ein erster Eindruck in die Struktur und die Arbeitsweise von Symfony 2.7 vermittelt.
Weiterhin werden schon einige wichtige Bestandteile von Symfony wie der Template Engine TWIG und Doctrine, dem Framework zur objektrelationalen Abbildung (englisch object-relational mapping, ORM), vorgestellt und in Action gezeigt.

Der abschliessende Teil des Symfony 2.7 als Projekt Framework, deutsches Tutorial für Einsteiger erklärt die in diesem Teil genutzten Programmteile von Symfony 2.7 genauer und geht auf die wichtigsten Verzeichnisse und Dateien näher ein.




...