Symfony2: Seite anlegen

von Patrick Froch (Kommentare: 0)

Nach dem wir bereits hier ein Bundle angelegt haben, kommen wir nun zum Anlegen einer neuen Seite. Es sind in der Regel drei Dinge nötig: eine Route, ein Controller und ein Template.

Die Route

Die Routen werden in die Datei app/config/routing.yml eingetragen. In der Regel wird hier das Routing-File des Bundles importiert. So kann man die Routen der einzelnen Bundels bequem in den Konfigurationsdateien des Bundels pflegen. Wenn das Bundel mittels der Symfony-Konsole angelegt wurde, ist ein entsprechender Eintrag bereits vorhanden. Es sollte in etwa so aussehen: 
# app/config/routing.yml
acme_hello:
    resource: "@AcmeHelloBundle/Resources/config/routing.yml"
    prefix: /
@AcmeHelloBundle entspricht dem logischen Namen des Bundles. Es wird also die Datei routing.yml aus dem Verzeichnis /Resources/config/ innerhalb des Bundles AcmeHelloBundle geladen. Das Bundle befindet sich unter /src/Acme/HelloBundle/. In der Datei routing.yml des Bundles können die Routen eingetragen werden: 
# src/Acme/HelloBundle/Resources/config/routing.yml
hello:
    path: /hello/{name}
    plains: { _controller: AcmeHelloBundle:Hello:index }
Unter Path steht die URL, auf die reagiert werden soll. In diesem Fall ist es /hello/{name}. Der Teil in den Klammern ist ein Parameter. Wird also /hello/Ryan aufgerufen, trifft die Route zu und es wird der entsprechende Controller ausgeführt. Der Controller wird mit plains: { _controller: AcmeHelloBundle:Hello:index } definiert. Es wird der Controller Hello im Bundle AcmeHelloBundle ausgeführt, genauer gesagt die index-Methode. Natürlich sind die Routen noch viel leistungsfähiger, aber auf die Feinheiten gehe ich in einem eigenen Text ein.

Der Controller

Der Controller bekommt die Anfrage und erzeugt eine Rückgabe, meist ist dies ein HTML-Dokument, es kann aber auch vieles andere sein (z.B. ein Bild, ein JSON-Stiring, o.ä.). Um bei dem Beispiel aus dem Handbuch zu bleiben, legen wir jetzt einen Controller namens HelloController im Bundle AcmeHelloBundle an. Die Datei sollte unter dem Namen src/Acme/HelloBundle/Controller/HelloController.php angelegt werden und folgendes beinhalten: 
// src/Acme/HelloBundle/Controller/HelloController.php
namespace Acme\HelloBundle\Controller;

use Symfony\Component\HttpFoundation\Response;

class HelloController
{
    public function indexAction($name)
    {
        return new Response('<html><body>Hello '.$name.'!</body></html>');
    }
}
In Zeile 2 wird der Namespace für das Response-Objekt gesetzt. In Zeile 6 beginnt die Klasse und in Zeile 8 die Methode indexAction, diese übernimmt den Parameter $name. Das Response-Objekt wird in Zeile 10 erstellt und gleich zurückgegeben. Natürlich bekommen auch die Controller noch einen eigenen Text. Da es sehr umständlich ist den HTML-Code in den Controller zu schreiben (eigentlich will man ja auch gerade das durch den Einsatz eines Frameworks vermeiden), gibt es die Templates.

Die Templates

Symfony2 benutzt die Template-Engine Twig, eine sehr leistungsfähige und trotzdem einfache Template-Sprache. Damit nun das Template nachher auch ausgegeben wird, muss zuerst die Zeile 10 des Controllers angepasst werden. Hier wird nun mit $this->render() das Template ausgegeben. Der Methode wird als erster Parameter der logische Name des Templates und als zweiter ein Array mit den Parametern übergeben, die im Template benutzt werden sollen. Im ganzen sieht es dann so aus: 
// src/Acme/HelloBundle/Controller/HelloController.php
namespace Acme\HelloBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class HelloController extends Controller
{
    public function indexAction($name)
    {
        return $this->render(
            'AcmeHelloBundle:Hello:index.html.twig',
            array('name' => $name)
        );
    }
}
Bei den meisten Systemen ist es so, dass es der Inhalt von Subtemplates erzeugt und anschließend in die übergeordneten Templates eingefügt wird. Dies ist relativ unflexibel, da man den Inhalt später nicht mehr ändern kann. Twig geht den umgekehrten Weg, hier wird im Template definiert, welches übergeordnete Template erweitert wird. Man kann deshalb ein Template mit folgendem Inhalt erstellen: 
{# src/Acme/HelloBundle/Resources/views/Hello/index.html.twig #}
{% extends '::base.html.twig' %}

{% block body %}
    Hello {{ name }}!
{% endblock %}
In Zeile 2 wird das Standardtemplate base.html.twig als übergeordnetes Template definiert, hier wird der logische Name weggelassen, da es in app/Resources/views/ gespeichert ist und somit zur "Grundausstattung" von Symfony gehört. In Zeile 4 bis 6 wird ein Block definiert und in Zeile 5 die Variable $name ausgegeben. Variablen werden durch doppelte geschweifte Klammern gekennzeichnet. Eine geschweifte Klammer gefolgt von einem Prozentzeichen ist ein Befehl (z.B. ein Block, ein if-Abfrage oder eine Schleife). Das Standardtemplate sieht folgendermaßen aus: 
{# app/Resources/views/base.html.twig #}
<!DOCTYPE html>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>{% block title %}Welcome!{% endblock %}</title>
        {% block stylesheets %}{% endblock %}
        <link rel="shortcut icon" href="" />
    </head>
    <body>
        {% block body %}{% endblock %}
        {% block javascripts %}{% endblock %}
    </body>
</html>
In Zeile 11 sieht man den leeren Block body, der von dem neuen Template befüllt wird. Natürlich kann auch Twig viel mehr, auch dazu komme ich noch.

Zurück

Einen Kommentar schreiben