3 Model View Controller – die Schaltzentrale · 3.1.3 View und Controller: Das Action Pack Als...

19

3 Model View Controller – dieSchaltzentrale

Eines der bekanntesten und ältesten Muster (engl. »Patterns«) der Soft-wareentwicklung ist das »Model-View-Controller«(MVC)-Muster. Eswurde von Trygve Reenskaug Ende der 70er Jahre veröffentlicht undfand seine erste Anwendung in »Smalltalk«, der damals gerade neuentstehenden, völlig objektorientierten Programmiersprache. Ziel desMVC-Musters ist die klare Trennung zwischen dem Modell – also derGeschäftslogik – und der Präsentation der Geschäftslogik. Wenn dieTrennung klar durchgeführt wird, kann der »View«-Teil der Applikati-on einfach durch eine andere ersetzt oder um eine zusätzliche Ansichtergänzt werden. Eine klare Trennung zwischen den Applikationsberei-chen verlangt natürlich auch nach klaren Schnittstellen.

Um welche Schnittstellen geht es? Das Model-View-Controller- Aufbau des

MVC-MustersKonzept baut auf drei miteinander in Beziehung stehenden Teilen auf:

Model stellt die Geschäftslogik dar und repräsentiert den aktuellen Zu-stand des Systems. Der Zustand des Modells kann über Metho-den der Objekte verändert werden.

View stellt den Zustand des Modells dar und repräsentiert die Schnitt-stelle zum Benutzer.

Controller steuert die Interaktionen des Benutzers mit den Views unddem Modell.

Schauen wir uns die drei Teile im Detail an. Das Model beinhaltet die Model

Geschäftslogik des Programms. Die Klassen des Models verwalten dieDaten, die zur Verfügung stehen müssen. Es bietet Methoden an, mitdenen die Daten manipuliert werden können. Die Daten sollen, wie esdas Grundkonzept »Kapselung« der Objektorientierung vorsieht, nichtredundant vorliegen und nur an einer Stelle geändert werden. Dies er-höht auch die Wartbarkeit – es ist immer klar ersichtlich, an welcherStelle des Codes die Veränderung durchgeführt wurde.

Views visualisieren die Daten des Modells. Die Ansicht hat Zu- View

griff auf die Daten des Modells und ist dafür verantwortlich, diese für

20 3 Model View Controller – die Schaltzentrale

die Präsentation aufzubereiten. Zwischen View und Model besteht eine1:n-Beziehung – es können mehrere Views auf gleiche Daten und Ge-schäftsobjekte zugreifen. Durch die Kapselung der Daten in den Mo-dellen ist gewährleistet, dass die Daten konsistent bleiben. Die Summeder verschiedenen Views einer Anwendung ist die Benutzerschnittstelle– die Interaktion des Benutzers mit den Views bringt uns zum drittenTeil, dem Controller.

Der Controller verbindet das Modell mit den Ansichten. Der ViewController

selbst behandelt keine vom Benutzer ausgelösten Events, sondern leitetdiese an den Controller weiter. Der Controller entscheidet nun über dieweitere Vorgangsweise – in manchen MVC-Implementierungen verän-dert er das Modell mit den in der Ansicht geänderten Daten und stelltdiese geänderten Daten wieder der Ansicht zur Verfügung. In anderenImplementierungen adaptiert die Ansicht direkt die Modelldaten, derController steuert nur, ob und wann diese Aktualisierung erfolgen soll.Rails wählt die erste Vorgangsweise: Der Controller behält die vollstän-dige Kontrolle über die Daten. Abbildung 3.1 visualisiert das MVC-Muster.

Abbildung 3.1Das Model-View-Controller-Muster

View ModelWird mit Daten aus dem Model gerendert

Bu

sin

ess-

Log

ik

Controller

Anstoß zum Rendern der neuen ViewEvent

3.1 MVC in Rails

Das Prinzip von MVC kennen wir jetzt. Aber wie ist das MVC-Musterin Rails umgesetzt?

Wird in Rails eine neue Anwendung mit dem Befehl rails appNameerstellt, dann wird unter anderem ein Ordner app erzeugt, der die An-

3.1 MVC in Rails 21

wendung beinhaltet. In diesem Ordner wird das MVC-Muster im Rails-Framework abgebildet. Es werden drei Verzeichnisse models, views undcontrollers angelegt. Diese drei Verzeichnisse beinhalten in weitererFolge die Klassen für die Models, die Views und die Controller derAnwendung. Rails gibt dem Entwickler aber nicht nur die Struktur vor,sondern übernimmt als stark ausgebautes Web-Application-Frameworkweitgehend die Funktionalität, aus den Einzelkomponenten eine laufen-de Anwendung zu generieren. So wichtig eine MVC-Architektur für dieWartbarkeit einer Software ist, so aufwändig ist die manuelle Erstel-lung einer solchen Applikation von Grund auf. Genau diesen Aufwandnimmt uns Rails ab.

Eine der Ideen hinter dem Design von Rails ist das Prinzip »Kon-vention statt Konfiguration«. Gemäß dieser Philosophie wird die MVC-Struktur fast von selbst erstellt – vorausgesetzt, die Namenskonventio-nen werden durch den Programmierer eingehalten. Vom Aufruf einerURL des dazugehörigen Controllers, über den Aufruf der Action, diedann die Daten ausliest, bis hin zur Ansicht ist der gesamte Ablauf ineiner Rails-Anwendung durch Namenskonventionen standardisiert – esist keine getrennte Konfiguration notwendig.

Eine Benutzerinteraktion in einem auf dem MVC-Muster basieren- Der Ablauf

den Framework folgt immer einem vorgegebenen Ablauf. Dieser ist inRails folgendermaßen:

Am Beginn steht der Aufruf eines Hyperlinks z.B. http://localhost:3000/TestController/testAction. Der Aufruf des Hyperlinks ergibt ei-ne HTTP-Anfrage an den Server. Der Server empfängt die Anfrageund leitet diese an das Rails-Framework weiter. Die Interpretation derURL und das Auffinden der auszuführenden Ruby-Methode ist der ers-te Schritt des Frameworks beim Aufruf einer Seite – diesen Vorgangnennt man Routing. Wie wird die zugehörige Methode gefunden? Inder Adresse entspricht der erste Teil dem Server, auf dem Rails läuft(localhost:3000). Der zweite Teil der Adresse ist der Name des Control-lers (TestController) und der dritte Teil gibt die zum Aufruf gehörigeMethode an – auch als Action bezeichnet (testAction).

Nach dem Routing wird die Action-Methode des Controllers auf-gerufen. Diese ruft üblicherweise zuerst Methoden des Models auf unddann die Ansicht, um die Daten darzustellen. Wurden die Namenskon-ventionen eingehalten, wird der Ablauf gänzlich vom Framework ge-steuert.

3.1.1 Modelle auf Schienen

Modelle bilden Daten der Anwendung in Form von Ruby-Klassen ab Modelle und

Datenbanken– die eigentlichen Daten sind in Datenbanken gespeichert. Es entsteht


eine Lücke zwischen der Datenspeicherung und der Darstellung der Da-ten im Modell. Rails hilft mit der Technologie der Active Records, dieseLücke zu schließen.

Zwei Möglichkeiten stehen beim Arbeiten mit Datenbanken zurVerfügung: Eine einfache und schnelle Methode ist das direkte Ein-binden von Datenbankabfragen in den Code1. Allerdings wird derCode durch diese Vorgangsweise schlechter lesbar und wartbar undCodefragmente wiederholen sich. Zur Vermeidung versuchen wir,den Code zur Manipulierung von Datensätzen an einer zentralenStelle zusammenzufassen. Üblicherweise werden also Methoden er-stellt, die alle Datenbankzugriffe für die gesamte Anwendung über-nehmen und eine Schnittstelle zur Datenbank bereitstellen. Alle die-se Klassen und Methoden zusammen werden als Persistenzschicht(bzw. Persistenz-Framework) bezeichnet. Active Records2 ist diesesPersistenz-Framework für Rails und dient der Verbindung der Konzep-te der relationalen Datenbanken und der Objektorientierung.

Die Welten der relationalen Datenbanken und der objektorientier-Relationale

Datenbanken und

Objektorientierung

ten Programmiersprachen sind sich über die Jahre nicht nähergekom-men. Daher ist der Aufwand für die Verbindung dieser Welten oft hoch.Es gibt zahlreiche Ansätze und Frameworks, die den Programmierer beidieser Aufgabe unterstützen. Gutes objekt-orientiertes Design zeichnetsich dadurch aus, dass die Klassenstruktur die reale Welt abbildet. Ei-genschaften werden auf Attribute von Klassen, Abläufe auf Methodenvon Klassen abgebildet. Beziehungen zwischen Klassen werden überReferenzen zwischen Klassen realisiert.

Relationale Datenbanken bilden auch die reale Struktur ab, aller-dings in der Form von Tabellen. Relationale Datenbanken bestehen ausTabellen mit Attributen als Spalten. Jede Zeile entspricht einer Instanzim objektorientierten Sinne. Die Abbildung zwischen objektorientiertenModellen und relationalen Datenmodellen wird als objektrelationalesMapping bezeichnet.

3.1.2 Objektrelationales Mapping

Ein Ansatz, die Lücke zwischen der Objektorientierung und den relatio-nalen Datenstrukturen zu schließen, ist das objektrelationale Mapping(ORM). Dabei wird eine Tabelle in ein Objekt abgebildet oder vice

1Das gilt vor allem für den Bereich der serverseitigen Skriptsprachen – aufPlattformen wie Java ist der Umstieg zu Persistenz-Frameworks schon erfolgt;Rails ist für die Skriptsprachen einer der Vorreiter.

2Rails bietet mit Active Records Unterstützung bei der Arbeit mit Daten-banken an, diese ist aber nicht zwingend.

3.1 MVC in Rails 23

versa. Ein Tupel3 einer Tabelle wird als Instanz einer entsprechendenKlasse ausgegeben. Die Spalten der Tabelle entsprechen den Attributender Klasse. Beziehungen zwischen den Tabellen werden über Objektre-ferenzen abgebildet.

Mit dem Befehl ruby script/generate model TestModel wird in Rails Active Records –

objektrelationales

Mapping in Rails

ein leeres Model erzeugt. Das erzeugte Model leitet sich von der KlasseActiveRecord::Base ab und sieht folgendermaßen aus:

class TestModel < ActiveRecord::Base

Active Records ist der Ansatz von Rails, um ein objektrelationales Datei test_model.rb

Mapping für die Schnittstelle zwischen dem Modell und der Daten-bank zu realisieren. Active Records funktionieren genauso, wie der vor-her erläuterte ORM-Standardansatz. In jeder Klasse bieten die ActiveRecords zusätzliche Methoden für den Zugriff auf auf die Datenbank-tabellen an. Dazu gehört beispielsweise die Methode find. Diese filtertin der zur Klasse gehörigen Tabelle die Zeilen, die zu den übergebenenParametern passen und gibt diese Datensätze als Instanzen der Klassezurück.

Nachdem das Prinzip der Namenskonvention die grundlegendePhilosophie von Rails ist, wird die Beziehung zwischen Tabelle undKlasse wieder ohne Konfiguration geregelt. Die Zuordnung einer Ta-belle zu einem Model wird vom Framework durchgeführt, wenn derName des Modells die Einzahl des Tabellennamens ist. Rails erkenntdie Mehrzahl auch für Mehrzahlbildungen wie in country und coun-tries – allerdings beschränkt sich das Mapping auf die englische Formder Mehrzahlbildung.

3.1.3 View und Controller: Das Action Pack

Als Action Pack wird in Rails die Verbindung aus View und Controller Action Pack

bezeichnet. Diese beiden weisen eine enge Beziehung auf: Der Benutzerinteragiert mit der Ansicht, die ein Ereignis (»Event«) auslöst. DiesesEreignis führt wiederum zum Aufruf einer Action-Methode des Con-trollers. Durch den Namen der Action-Methode ist über die Namens-konvention bereits der Aufruf einer bestimmten Ansicht vorgegeben,und der Controller veranlasst jetzt die Darstellung eines bestimmtenViews.

Mit Rails können verschiedenste Ansichten generiert werden. Der View

Grundsätzlich werden Webseiten oder Teile einer Webseite in HTMLausgegeben. Rails unterstützt auch die Ausgabe anderer Ausgabefor-mate, wie die Ausgabe von XML. Der einfachste Fall einer Ansicht ist

3Jede Zeile einer Tabelle wird als Tupel bezeichnet.


die Ausgabe statischer Texte. Web-Applikationen leben aber von dyna-mischen Inhalten. In Rails werden dynamische Inhalte über die Defi-nition von rhtml-Vorlagen in das Format HTML eingebunden. SolcheVorlagen erhalten ihre dynamische Komponente durch Einbindung vonRuby-Code – sie stellen sozusagen eine Mischung aus Ruby und HTMLdar. Die Einbindung von Ruby-Code in die Ansicht ist praktisch, abernicht unproblematisch: Die klare Trennung des MVC-Musters könntedurch zuviel Code in den Ansichten verloren gehen. Die Verantwortungzur Einhaltung des MVC-Konzepts liegt klarerweise beim Programmie-rer, daher sollte der View so wenig Code wie möglich enthalten. Codein Templates sollte nur dazu dienen, um beispielsweise mittels Schleifenauf eine dynamische Anzahl von Datenfeldern zuzugreifen oder dyna-mische Links zu generieren. Ein schneller Blick in die Ansicht zeigt oft,ob die Vorgaben des MVC-Musters eingehalten wurden: Besteht derüberwiegende Teil der Seite aus Ruby-Code, liegt in vielen Fällen einVerstoß vor.

Die Aufgabe des Controllers ist die Steuerung des Ablaufs. Er wirdDer Controller

aufgerufen, sobald eine Abfrage auf unsere Web-Applikation abgesetztwird. Zuerst extrahiert der Controller die Daten aus der Anfrage undaktualisiert das Modell. Danach wählt der Controller den View aus,übergibt die Daten und die Ansicht wird aufbereitet. Der sichtbareQuelltext im Controller ist nur ein kleiner Teil der eigentlichen Funk-tionalität – der größte Teil wird über das Framework und die Ablei-tung des Controllers von der Basisklasse ActionControllerBase zur Ver-fügung gestellt. Dadurch bleiben die Controller in Rails kleiner und bes-ser wartbar. Der Controller stellt über das Framework folgende Funk-tionalitäten bereit:

� Interpretation der URL� Caching� Hilfsmodule zur Erweiterung der Funktionen der Ansichten� Session Management

Abbildung 3.2 visualisiert das MVC-Muster, wie es in Rails umgesetztist.

3.1.4 Zusammenfassung

Das Model-View-Controller-Entwurfsmuster dient der klaren Tren-nung zwischen Modell (Geschäftslogik) und View (Benutzerschnittstel-le). Dabei ist der View für die Darstellung zuständig, das Model für dieDatenhaltung und Datenmanipulation und der Controller für die In-itialisierung, Auswahl und die Steuerung der Kommunikation zwischenView und Model.

3.2 Der Zug kommt ins Rollen – »Hello World« 25

Abbildung 3.2MVC in Rails

Browser Dispatcher

http://localhost:3001/ControllerName/ActionName

ViewActionView / RHTML

ModelActiveRecord

Wird mit Daten aus dem Model gerendert

Bu

sin

ess

Log

ik

ControllerActionController

Antoß zum Rendern eines neuen Views

DB

Das Rails-Framework basiert auf dem Model-View-Controller-Entwurfsmuster. Durch den strukturierten Aufbau einer Rails-Applikation wird dem Programmierer vorgegeben, wie die klare Tren-nung der Teile des MVC-Musters umzusetzen ist. Durch die Anwen-dung des Prinzips »Convention over Configuration« und damit diekonsequente Anwendung von Namensregeln wird der Konfigurations-aufwand verringert und somit der Programmierer entlastet. Zusätz-lich wird durch automatische Generierung von Teilen der Anwendungder Aufwand fürs Schreiben einer Basisapplikation verringert. Dadurchwird ein rasches Erstellen von Prototypen ermöglicht. Trotzdem hat derEntwickler die Möglichkeit, das Framework an seine Bedürfnisse anzu-passen.

3.2 Der Zug kommt ins Rollen – »Hello World«Zum Kennenlernen des Rails-Frameworks wollen wir ein einfaches Bei-spiel umsetzen. Ganz klar - das erste Beispiel in einem neuen Frame-work muss natürlich ein »Hello World«-Programm sein.

3.2.1 Station 1 – Erstellen des Grundgerüsts

Die erste Station beim Erstellen einer Anwendung in Rails ist das Er-zeugen des Grundgerüsts. Nach der Installation des Rails-Frameworkssteht der Befehl rails zur Verfügung. Durch Ausführung dieses Be-fehls kann auf einfache Weise das Grundgerüst einer Rails-Anwendungerstellt werden. Das Grundgerüst besteht aus einer – für eine Rails- Anlegen der

VerzeichnisstrukturAnwendung benötigten – Verzeichnisstruktur, in der die einzelnen Ele-


mente des Programms abgelegt werden. Zusätzlich werden bei der Aus-führung dieses Befehls auch Templates für die einzelnen Dateien in derVerzeichnisstruktur erzeugt4.

Wir werden in diesem Beispiel auf die vorgegebene Struktur aufbau-en. Um eine erste Rails-Anwendung zu erstellen, öffnen wir zunächstein Terminalfenster (Eingabeaufforderung unter Windows) und wech-seln in das Verzeichnis, in dem die Anwendung erstellt werden soll.Anschließend führen wir den Befehl

rails first_rails_app

aus und erhalten folgende Ausgabe:

createcreate app/apiscreate app/controllerscreate app/helperscreate app/modelscreate app/views/layouts...create log/production.logcreate log/development.logcreate log/test.log

Dieses Kommando erstellt zahlreiche Verzeichnisse, die mit ls bzw. diraufgelistet werden können. Mit dem Befehl

~ $ ls first_rails_app/

erhalten wir folgende Ausgabe:

app CHANGELOG components config db doc liblog public Rakefile README script test vendor

3.2.2 Station 2 – Starten des Webservers

Da das Rails-Framework zahlreiche Verzeichnisse und Dateien anlegt,ist es am Beginn schwer, den Überblick zu behalten. Wir wollen schritt-weise die jeweils benötigten Dateien auflisten und beschreiben. Als Ers-tes sehen wir uns das public-Verzeichnis an. Zu den wichtigsten Dateienin diesem Verzeichnis gehören die Dispatcher-Dateien:

� dispatch.cgi� dispatch.fcgi� dispatch.rb

4Wenn eine andere als die automatisch erstellte Verzeichnisstruktur benötigtwird, kann diese auch manuell erzeugt werden. Die Konfiguration des Frame-works muss danach natürlich angepasst werden.


Die Aufgabe der Dispatcher ist es, alle eingehenden Anfragen entgegen-zunehmen und dafür zu sorgen, dass abhängig vom Request das rich-tige Modul der Anwendung ausgeführt wird. Weiterhin interessant ist Der Webserver

die Datei index.html. Diese ist die Startseite des Webservers, wenn dieWeb-Anwendung ohne Zusatzparameter aufgerufen wird. Der Webser-ver (WEBrick::HTTPServer) wird gestartet, indem wir den Befehl rubymit der Skriptdatei server im Unterverzeichnis scripts aufrufen. DieEingabe

~/first_rails_app $ ruby script/server webrick

ergibt folgende Ausgabe

=> Rails application started on http://0.0.0.0:3000=> Ctrl-C to shutdown server;

call with --help for options[2005-09-25 19:03:26] INFO WEBrick 1.3.1[2005-09-25 19:03:26] INFOruby 1.8.2 (2004-12-25) [i686-linux][2005-09-25 19:03:26] INFOWEBrick::HTTPServer#start: pid=17443 port=3000

Der Server läuft so lange, bis in diesem Terminalfenster die Tas-tenkombination Strg-C gedrückt wird. Wenn wir uns nun auf denWebserver verbinden wollen, müssen wir im Web-Browser die URLhttp://localhost:3000 eingeben. Hat alles funktioniert, wird die Dateiindex.html angezeigt.

Abbildung 3.3Die Startseite desWebservers


Für den weiteren Ablauf muss der WEBrick::HTTPServer im Ter-minalfenster aktiv bleiben. Wir können in diesem Fenster die eingehen-den Anfragen auf den Webserver beobachten.

3.2.3 Station 3 – Erstellen des Models

Wie bereits erwähnt, baut Rails auf dem Model-View-Controller-Framework auf. Für unser »Hello World«-Beispiel benötigen wir nurein einfaches Model. Das Model dient dazu, die Zeichenkette »HelloDas Modell »Hello

World« World!« auszugeben. Unser Modell bekommt den Namen Message undwird im Verzeichnis app/models unter dem Namen message.rb abgespei-chert.Datei message.rb

class Messagedef say_hello

return "Hello World!"end

end

Dieses Model muss nun über einen Controller aufgerufen werden, denwir im nächsten Abschnitt erstellen.

3.2.4 Station 4 – Erstellen des Controllers

Beginnen wir mit dem Code für den Controller, der die Anfragen ver-arbeitet. Zum Erzeugen des Grundgerüsts für einen Controller benöti-gen wir wieder den Befehl rails. Diesmal müssen wir den Aufruf derSkriptdatei generate mit dem Parameter controller und dem Namendes Controllers ergänzen. In unserem Beispiel wählen wir den Namenecho für den Controller.

Somit erstellt die Eingabe

~/first_rails_app $ ruby script/generate controller echo

unseren Controller und gibt dabei Folgendes aus:

exists app/controllers/exists app/helpers/create app/views/echoexists test/functional/create app/controllers/echo_controller.rbcreate test/functional/echo_controller_test.rbcreate app/helpers/echo_helper.rb

In der Ausgabe des Skripts werden sämtliche Dateien und Verzeich-nisse überprüft beziehungsweise neu angelegt. Den Code unseres neuangelegten Controllers finden wir in der Datei echo_controller.rb imVerzeichnis app/controllers.


Datei

echo_controller.rb

class EchoController < ApplicationControllerend

In dem generierten Controller ist einzig die Controller-Deklaration zusehen. Die Klasse EchoController erbt allerdings von der Klasse Appli-cationController und erhält daher einiges an Funktionalität von dieserBasisklasse. Es sind noch keine Action-Methoden in der Controller-Klasse definiert.

3.2.5 Station 5 – Erstellen der Action

Bevor wir die erste Action anlegen, sehen wir uns einen Request näheran. Über die URL http://localhost:3000/echo/hello wollen wir unser»Hello World«-Beispiel anzeigen. Für den Webserver ist nur der ers-te Teil der URL http://localhost:3000/ relevant. Der andere Teil wirdan die Anwendung übergeben5. Der Dispatcher zerlegt im Routing-Vorgang die URL folgendermaßen:

echo ⇒ zuständiger Controllerhello ⇒ zuständige Action

Der Dispatcher verwendet den ersten Teil des Pfads, um den Namendes Controllers herauszufinden, und den zweiten Teil des Pfads, um dieaufzurufende Action zu ermitteln. Damit die obige URL für unsere An-wendung zur Verfügung steht, definieren wir eine Action. Diese Actionbezeichnen wir mit hello.

Datei

echo_controller.rb

1 class EchoController < ApplicationController2 def hello3 @message = Message.new4 end5 end

Die Action hello ist für die Aufbereitung der Daten zuständig. In derAction wird der Konstruktor der Klasse message aufgerufen, der für un-ser Modell immer »Hello World!« zurückliefert. Wenn wir jetzt die URLhttp://localhost:3000/echo/hello im Browser eingeben, kommt es zueiner Exception bei der Ausführung des Codes in der Action Control-ler-Basisklasse. Diese Ausnahme ergibt sich, weil wir noch kein Tem-plate für den »hello«-View erstellt haben.

Daher müssen wir im nächsten Schritt ein Template für den Viewerstellen.

5Bei Rails entspricht echo/hello keiner Pfadangabe, wie man es von ande-ren Webservern erwarten könnte.


Abbildung 3.4Dem View fehlt noch

ein Template

3.2.6 Station 6 – Erstellen des Views

Damit unsere Anwendung vollständig wird, schreiben wir ein Templatefür den hello-View. Das Template wird in das Verzeichnis app/views/e-cho für die Views des echo-Controllers gespeichert.

Basierend auf der Konvention von Rails, hat die Template-Dateifür den View denselben Namen wie die Action. In unserem Fall hatdie Template-Datei den Namen hello.rhtml. Die Erweiterung .rhtmldeshalb, weil sie nicht nur HTML enthalten kann, sondern auch Ruby-Befehle. Die Erweiterung ist ein Hinweis, dass es sich um eine Template-Datei handelt und nicht um eine reine HTML-Datei.

Zuerst wollen wir nur statische Inhalte einfügen. Die dynamischenfolgen dann später.

Datei hello.rhtml 1 <html>2 <head>3 <title><%[email protected]_hello %></title>4 </head>5 <body>6 <h1><%[email protected]_hello %></h1>7 (erste Ruby-on-Rails Anwendung)8 </body>9 </html>

Wenn wir jetzt die URL http://localhost:3000/echo/hello im Browseraufrufen, erhalten wir die Seite mit der gewünschten Meldung »HelloWorld!«.

Damit haben wir das erste Set Model, View, Controller komplettumgesetzt und unsere Verbindung zur Welt erstellt.


Abbildung 3.5Hello World!

3.2.7 Station 7 – Erstellen von dynamischen Inhalten

Nur dynamische Seiten können Web-Anwendungen zum Leben er-wecken. Rails verwendet dazu Embedded Ruby, um in die View-Templates Ruby-Code zu integrieren. Ähnlich wie bei PHP, JSP oderASP arbeitet Embedded Ruby mit Tags. Der Beginn jedes Ruby-Codeswird mit einem ‹%-Tag gekennzeichnet und mit %› abgeschlossen.

Wir werden nun das »Hello World!«-Beispiel um das aktuelle Da-tum und die Uhrzeit erweitern.

Datei hello.rhtml1 <html>2 <head>3 <title><%[email protected]_hello%></title>4 </head>5 <body>6 <h1><%[email protected]_hello%></h1>7 <P>8 Datum und Uhrzeit: <%= Time.now %>9 </P>

10 </body>11 </html>

Dadurch enthält die Ausgabe jetzt auch Datum und Uhrzeit.Durch ein zusätzliches »=« nach dem Tag ‹% wird der Rückgabe-

wert des ausgeführten Codes an dieser Stelle in das Template eingefügt.Durch die Verwendung dieses Tags erspart man sich den expliziten Auf-ruf einer Ausgabefunktion und das Template wird lesbarer.


Abbildung 3.6Hello World mit

dynamischem Inhalt

3.2.8 Station 8 – Model, View und Controller trennen

Ganz sauber war der letzte Schritt nicht. Dem aufmerksamen Leser istsicher nicht entgangen, dass das Ermitteln von Datum und Uhrzeit kei-ne Aufgabe des Views, sondern des Controllers ist. Wir wollen also denController die Uhrzeit ermitteln lassen und den View lediglich zur An-zeige verwenden.

Datei

echo_controller.rb

1 class EchoController < ApplicationController2 def hello3 @message = Message.new4 @time = Time.now5 end6 end

Datei hello.rhtml 1 <html>2 <head>3 <title><%[email protected]_hello%></title>4 </head>5 <body>6 <h1><%[email protected]_hello%></h1>7 <P>8 Datum und Uhrzeit: <%= @time %>9 </P>



Am Verhalten der Anwendung ändert sich nichts, allerdings können wirhier gut eine Eigenschaft von Rails beobachten. Im Controller-Objektwird ein privates Attribut namens time gesetzt, auf das der View zu-greift. Das funktioniert, weil Rails dafür sorgt, dass Attribute des Con-troller-Objektes im View-Template verfügbar sind.

3.2.9 Station 9 – Schleifen in View-Templates

Eine einfache Möglichkeit, Schleifen in Rails zu verwenden, soll fol-gendes Beispiel zeigen, in dem sich HTML-Code innerhalb einer Schleifebefindet.

Datei hello.rhtml1 <html>2 <head>3 <title><%[email protected]_hello%></title>4 </head>5 <body>6 <% 3.times do %>7 <h1><%[email protected]_hello%></h1>8 <% end %>9 <P>

10 Datum und Uhrzeit: <%= @time %>11 </P>12 </body>13 </html>

Die Schleife erzeugt HTML-Code, wobei die Daten bei jedem Durchlaufausgegeben werden.

Abbildung 3.7Hello World in einerSchleife


3.2.10 Station 10 – Seiten verbinden

Web-Anwendungen bestehen aus zahlreichen Seiten, die miteinanderüber Hyperlinks verbunden sind. Daher wollen wir nun Seiten unse-res Beispiels miteinander verbinden. Dazu definieren wir in unserembestehenden echo-Controller eine zweite Action und ein zugehörigesTemplate.

Datei

echo_controller.rb

1 class EchoController < ApplicationController2 def hello3 @time = Time.now4 end5 def second6 end7 end

Datei second.rhtml 1 <html>2 <head>3 <title>Zweite Seite</title>4 </head>5 <body>6 <h1>Zweite Seite!</h1>7 <P>8 Dies ist die zweite Seite unserer ersten Rails-Anwendung9 </P>


Abbildung 3.8Eine zweite Seite, aufdie wir jetzt verlinken

können


Mit dieser Erweiterung erhalten wir die in Abbildung 3.8 darge-stellte Seite im Browser.

Wir müssen nun die erste Seite modifizieren, damit sie einen Hy-perlink auf die zweite Seite enthält. Die einfachste Variante ist, einenHyperlink <A HREF="/echo/hello"> einzufügen. Mit dem Nachteil, dassder Hyperlink ungültig wird, sobald diese Seite in ein anderes Verzeich-nis verschoben wird. Besser ist es, die Funktion link_to zu verwenden.Diese Funktion bekommt als ersten Parameter den Text des Hyperlinksund als zweiten die Action, auf die der Hyperlink verweisen soll.

Datei hello.rhtml1 <html>2 <head>3 <title><%[email protected]_hello%></title>4 </head>5 <body>6 <h1><%[email protected]_hello%></h1>7 <%= link_to "Hier gehts auf die 2. Seite", :action => "second" %>8 <P>9 Datum und Uhrzeit: <%= @time %>

10 </P>11 </body>12 </html>

Nun haben wir auf der »Hello World!«-Seite einen Link auf die zweiteSeite.

Abbildung 3.9»Hello World«-Seite mitLink auf die zweiteSeite

3 Model View Controller – die Schaltzentrale · 3.1.3 View und Controller: Das Action Pack Als...

Documents

Transcript of 3 Model View Controller – die Schaltzentrale · 3.1.3 View und Controller: Das Action Pack Als...