Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Geleitwort des Fachgutachters
Einleitung
1 Einführung
2 Installation
3 Erste Schritte
4 Einführung in Ruby
5 Eine einfache Bookmarkverwaltung
6 Test-Driven Development
7 Rails-Projekte erstellen
8 Templatesystem mit ActionView
9 Steuerzentrale mit ActionController
10 Datenbankzugriff mit ActiveRecord
11 E-Mails verwalten mit ActionMailer
12 Nützliche Helfer mit ActiveSupport
13 Ajax on Rails
14 RESTful Rails und Webservices
15 Rails mit Plug-ins erweitern
16 Performancesteigerung
17 Sicherheit
18 Veröffentlichen einer Rails-Applikation auf einem Server

Download:
- ZIP, ca. 6,7 MB
Buch bestellen
Ihre Meinung?

Spacer
 <<   zurück
Ruby on Rails 2 von Hussein Morsy, Tanja Otto
Das Entwickler-Handbuch
Buch: Ruby on Rails 2

Ruby on Rails 2
geb., mit DVD
699 S., 39,90 Euro
Galileo Computing
ISBN 978-3-89842-779-1
Online bestellenPrint-Version jetzt bestellen
* versandkostenfrei in (D) und (A)
Pfeil 9 Steuerzentrale mit ActionController
  Pfeil 9.1 Grundlagen
  Pfeil 9.2 Aufgaben des Controllers
  Pfeil 9.3 Filter
  Pfeil 9.4 Routing


Galileo Computing - Zum Seitenanfang

9.4 Routing  Zur nächsten ÜberschriftZur vorigen Überschrift

routes.rb

Das sogenannte Routing legt innerhalb von Rails fest, welcher interne Aufruf aus der URL erfolgt. Das heißt, das Routing ist für die Verteilung zuständig. Es wird im Routing festgelegt, welcher Controller und welche Action aufgerufen wird bzw. zuständig ist. Die Datei, in der das Routing definiert wird, heißt routes.rb und befindet sich im Verzeichnis config:

Listing  config/routes.rb

ActionController::Routing::Routes.draw do |map|
 # ...
 map.connect ':controller/:action/:id'
 map.connect ':controller/:action/:id.:format'
end

Galileo Computing - Zum Seitenanfang

Das Standard-Routing  Zur nächsten ÜberschriftZur vorigen Überschrift

:controller/ :action/:id

Rails hat ein vorkonfiguriertes Routing, das beim Erzeugen einer Rails-Ap- plikation in der Datei routes.rb angelegt wird:

map.connect ':controller/:action/:id'

Dieser Eintrag legt fest, das, wenn zum Beispiel folgende URL aufgerufen wird:

http://localhost:3000/bookmarks/show/1

es zu folgender Zuordnung kommt:

Der erste Teil des Aufrufs entspricht dem Hostanteil, in unserem Fall localhost:3000, normalerweise eine Domain. Der zweite Teil wird dem Controller zugeordnet, der dritte der Action und der vierte der ID. Konkret passiert intern folgende Zuordnung:

  1. params[:controller] = "bookmarks"
  2. params[:action] = "show"
  3. params[:id] = 1

Bookmarks- Controller

Die Controller-Klasse heißt BookmarksController, wird also über den Namen gefunden. Auch die Action innerhalb des Controllers wird über den Namen gefunden. Innerhalb der Action kann der Zugriff auf die ID über params[:id] erfolgen.

Um einen Datensatz zu löschen, würde man folgende URL aufrufen:

http://localhost:3000/bookmarks/destroy/1

Intern würde im Bookmarks-Controller die Action destroy aufgerufen, die den Datensatz mit der ID=1 löschen würde.

Abbildung  Beispiel eines Standard-Routings

Links

Innerhalb eines Templates kann ein Link zum Anzeigen, Bearbeiten oder Löschen eines Bookmarks wie folgt angelegt werden:

<%= link_to "anzeigen", :controller => 'bookmarks',
:action => "show", :id => 1 %>

<%= link_to "bearbeiten", :controller => 'bookmarks',
:action => "edit", :id => 1 %>

<%= link_to "löschen", :controller => 'bookmarks',
:action => "destroy", :id => 1 %>

Galileo Computing - Zum Seitenanfang

Routing-Regeln erstellen  Zur nächsten ÜberschriftZur vorigen Überschrift

Vereinfachte URLs

Viele Webapplikationen, insbesondere Content-Management-Systeme, haben sehr lange URLs. Rails erlaubt es, eigene Routing-Regeln festzulegen, was vor allem den Vorteil bietet, dass wir Routing-Regeln festlegen können, die die URL vereinfachen.

Angenommen, wir haben einen Controller authentication mit den Actions login und logout . Nach dem Standard-Routing erfolgt der Aufruf der login - und der logout -Action wie folgt:

  • http://localhost:3000/authentication/login
  • http://localhost:3000/authentication/logout

Da es in der Webapplikation nur eine Log-in- und eine Log-out-Seite gibt, wäre es praktisch, wenn man die Seiten über folgende URLs aufrufen könnte:

  • http://localhost:3000/login
  • http://localhost:3000/logout

Rails stellt uns u. a. den Befehl map.connect zur Verfügung, um eigene Routing-Regeln zu definieren.

Um das gewünschte Ergebnis zu erzielen, fügen Sie die folgenden Regeln in die Routing-Datei config/routes.rb ein.

Achten Sie darauf, dass Sie die Regeln oberhalb des Standard-Routing-Eintrags definieren. Es gilt nämlich das Prinzip, dass die Routing-Regel, die zuerst zutrifft, auch als Erstes ausgeführt wird.

Listing  config/routes.rb

ActionController::Routing::Routes.draw do |map|
  ...

  map.connect 'login', :controller => "authentication",
  :action => "login"
  map.connect 'logout', :controller => "authentication",
  :action => "logout"

  # Install the default route as the lowest priority.
  map.connect ':controller/:action/:id.:format'
  map.connect ':controller/:action/:id'
end
Immer Server nach Änderungen am Routing neu starten
Immer wenn wir Änderungen am Routing vornehmen, müssen wir den lokalen Server neu starten. Der lokale Server kann mit + gestoppt und mit ruby script/server wieder gestartet werden.


Galileo Computing - Zum Seitenanfang

Benannte Routen  Zur nächsten ÜberschriftZur vorigen Überschrift

map.»name«

Eine bessere Alternative ist jedoch, die Routing-Einträge in routes.rb zu benennen, also sogenannte benannte Routes anzugeben. Statt mit map.connect werden benannte Routes mit map.»name« angelegt. Als Name kann man frei gewählte Begriffe nehmen, in unserem Fall bieten sich »login« und »logout« für das An- und Abmelden an:

map.login 'login', :controller => "authentication",
		   :action => "login"

Das Benennen der Einträge bewirkt, dass automatisch zwei Methoden pro Eintrag definiert werden:

name_url, name_path

login_url, login_path, logout_url, logout_path . name_url liefert die absolute URL inklusive des Hosts. name_path liefert den relativen Pfad ohne den Host, also das, was dem Methodenaufruf map.name als erster Parameter übergeben wurde, mit führendem Slash.

In der Definition der Links innerhalb eines Templates können wir diese Pfade wie folgt einsetzen:

<%= link_to "logout", logout_path %>
<%= link_to "login", login_path %>

Benannte Routen vereinfachen also die Verlinkung innerhalb des Rails- Projekts.


Galileo Computing - Zum Seitenanfang

Die root-Route  Zur nächsten ÜberschriftZur vorigen Überschrift

Zur Startseite einer Applikation, z. B. unserer Bookmarkverwaltung, gelangen wir, ohne dass wir im Routing eine Route für die Startseite definiert haben, nur über den Aufruf:

http://localhost:3000/bookmarks

map.root

Wenn wir in der URL keinen Controller angeben, also nur den Host (»http://localhost:3000«) aufrufen, wird die Willkommen-Seite von Rails angezeigt. Das liegt u. a. daran, dass Rails nicht weiß, welcher Controller in diesem Fall angezeigt werden soll. Noch nicht. In routes.rb existiert ein Beispieleintrag, wie man eine Route für den Root-Pfad der Applikation anlegt:

Listing  config/routes.rb

# You can have the root of your site routed with map.root --
just remember to delete public/index.html.
# map.root :controller => "welcome"

Wenn unsere Bookmarkverwaltung ohne Pfadangabe aufgerufen wird, soll die Index-Seite des Controllers bookmarks angezeigt werden:

map.root :controller => "bookmarks"

Wir haben keine Action angegeben, die aufgerufen werden soll, da per Konvention die Action index aufgerufen wird, wenn keine Action angegeben wird.

public/index.html

Wenn Sie den Rails-Server neu starten und dann http://localhost:3000 aufrufen, wird immer noch die Willkommen-Seite von Rails angezeigt. Das liegt nicht daran, dass unser Routing-Eintrag fehlerhaft ist, sondern daran, dass sich diese Willkommen-Seite im Verzeichnis public befindet und index.html heißt. Alles, was im Public-Ordner liegt, wird bevorzugt verwendet. Wenn sich dort eine index.html befindet, wird der Routing-Eintrag für den Aufruf ohne Pfadangabe ignoriert. Das heißt, wir müssen die Datei umbenennen oder löschen. Wenn Sie das tun und anschließend noch einmal http://localhost:3000 aufrufen, wird die von uns eingetragene Index-Seite unserer Bookmarkverwaltung angezeigt.

root_path

Da wir mit map.root eine benannte Route für den Root-Pfad unserer Applikation angelegt haben, steht uns jetzt die Methode root_path zur Verfügung, um diese in unseren Links, die zurück zur Startseite führen, einzusetzen:

link_to("Zurück zur Liste", root_path)

Über das Routing haben wir jetzt zwei Dinge gelernt:

  1. Wenn wir benannte Routing-Einträge vornehmen, stehen uns die Methoden name_url und name_path zur Verfügung.
  2. Beim Anlegen eines Routing-Eintrags für den Root-Pfad der Applikation müssen wir daran denken, im Verzeichnis public die Datei index.html umzubenennen oder zu löschen.

Galileo Computing - Zum Seitenanfang

Komplexe Routings mit Regulären Ausdrücken  Zur nächsten ÜberschriftZur vorigen Überschrift

Das Routing-System von Rails ist sehr flexibel. Angenommen, wir möchten alle Flüge von Düsseldorf (DUS) nach München (MUC) am 24.12.2008 anzeigen lassen, könnte nach dem Standard-Routing die URL wie folgt aussehen:

http://localhost:3000/flights/search?departure=dus&arrival=muc
&date=2008-12-24

Es wird dann der Flights-Controller mit der Action search aufgerufen.

Viel schöner wäre jedoch die folgende URL:

http://localhost:3000/flights/dus/mus/2008-12-24

Dafür ist jedoch folgender Routing-Eintrag erforderlich:

map.connect 'flights/:departure/:arrival/:date',
	   :controller => 'flights',
	   :action     => 'search',
	   :departure  => /\w{3}/,
	   :arrival    => /\w{3}/,
	   :date       => /\d{4}-\d{1,2}-\d{1,2}/

Der Reguläre Ausdruck \w{3} bedeutet, dass genau drei Buchstaben vorkommen müssen, und \d{1-2} bedeutet, dass ein bis zwei Zahlen vorkommen sollen.

Nur wenn alle Regulären Ausdrücke passen, wird die Action search des Flights-Controller aufgerufen. In der Action kann mit der Methode params auf die Parameter arrival, departure und date zugegriffen werden:

class FlightsController < ApplicationController

  def search
    @departure = params[:departure]
    @arrival = params[:arrival]
    @date = params[:date]
    ...
  end

end

Wenn die URL nicht exakt den im Routing festgelegten Regeln entspricht, wird ein Routing Error ausgegeben, der in der folgenden Abbildung gezeigt wird:

Abbildung  Routing Error


Galileo Computing - Zum Seitenanfang

Routing mit Angabe der HTTP-Methode  Zur nächsten ÜberschriftZur vorigen Überschrift

Die Abfrage einer URL erfolgt mit einer HTTP-Methode. Die häufigsten Anfragen erfolgen mit der GET- und POST-Methode. Es gibt auch noch weitere HTTP-Methoden, wie PUT und DELETE.

Im Routing kann man durch die Option :conditions festlegen, für welche HTTP-Methode die Routing-Regel gültig sein soll. Dies vereinfacht die URL zum Teil erheblich.

Im Folgenden definieren wir zwei Routing-Regeln, die beide die gleiche URL verwenden, jedoch mit unterschiedlichen HTTP-Methoden.

map.connect 'bookmarks/:id', :controller  =>  'bookmarks',
			     :action => 'show',
			     :conditions => { :method => :get }

map.connect 'bookmarks/:id', :controller  =>  'bookmarks',
			     :action => 'destroy',
			     :conditions => { :method => :delete }

Die folgende Liste zeigt, welche URL mit welcher HTTP-Methode zu welchem internen Aufruf führt.

  • GET /bookmarks/12
    Führt zum Aufruf der Action show des Bookmarks-Controllers mit dem Parameter params[:id]=12 .
  • DELETE /bookmarks/12
    Führt zum Aufruf der Action destroy des Bookmarks-Controllers mit dem Parameter params[:id]=12 .

Wenn im Browser die URL http://localhost:3000/bookmarks/12 aufgerufen wird, so wird die erste Regel angewandt, da es sich um einen Aufruf einer URL mit der GET-Methode handelt. Ein Link innerhalb eines Templates könnte wie folgt aussehen:

<%= link_to 'Bookmark 12 anzeigen', '/bookmarks/12' %>

# oder etwas umständlicher, aber mit dem gleichen Ergebnis
<%= link_to 'Bookmark 12 anzeigen', :controller => 'bookmarks',
:action => 'show', :id => 12 %>

Stellt sich die Frage, wie ein Link mit der HTTP-Methode DELETE erfolgen kann. Dazu kann die Option method verwendet werden.

<%= link_to 'Bookmark 12 anzeigen', '/bookmarks/12',
:method => :delete %>

# oder etwas umständlicher, aber mit dem gleichen Ergebnis
<%= link_to 'Bookmark 12 anzeigen',
    :controller => 'bookmarks', :action => 'show', :id => 12,
    :method => :delete %>
DELETE- und PUT-Methoden nur mit einem Trick möglich
Da im HTML nur GET- und POST-Methoden vorgesehen sind, muss Rails einen Trick anwenden, damit ein Link z. B. mit der DELETE-Methode möglich ist. Dazu generiert die link_to -Methode JavaScript, das entsprechend den Aufruf durchführt. Werfen Sie einen Blick in den Quelltext der Seite im Browser, um hinter die Kulissen von Rails zu schauen.


Galileo Computing - Zum Seitenanfang

Ressourcen  topZur vorigen Überschrift

Im letzten Abschnitt haben wir gelernt, wie Routing-Regeln erstellt werden, die sowohl auf der URL als auch auf der HTTP-Methode basieren.

Die URL legt dabei das Objekt bzw. die Ressource (z. B. Bookmark mit der ID 12) fest, und die HTTP-Methode, mit der die URL aufgerufen wird, legt fest, ob die Ressource z. B. angezeigt (GET-Methode) oder gelöscht (DELETE-Methode) werden soll.

REST-Standard

Auf diesem Prinzip basiert der sogenannte REST-Standard, der definiert, mit welchen HTTP-Methoden auf eine Ressource zugegriffen werden kann und welche Bedeutung dieser Zugriff hat.

map.resources

Mit dem Routing-Eintrag map.resources :bookmarks wird automatisch eine Menge von Routing-Regeln definiert, die einen Zugriff nach dem REST-Standard auf die Ressource bookmarks erlauben.

In Kapitel 14 werden Ressourcen ausführlich beschrieben.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






 <<   zurück
  Zum Katalog
Zum Katalog: Ruby on Rails 2






Ruby on Rails 2
Jetzt bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Zend Framework






 Zend Framework


Zum Katalog: AJAX






 AJAX


Zum Katalog: Praxisbuch Web 2.0






 Praxisbuch Web 2.0


Zum Katalog: CSS-Layouts






 CSS-Layouts


Zum Katalog: JavaScript und Ajax






 JavaScript und Ajax


Zum Katalog: Professionelles Webdesign mit (X)HTML und CSS






 Professionelles Webdesign
 mit (X)HTML und CSS


Zum Katalog: Suchmaschinen-Optimierung






 Suchmaschinen-Optimierung


Zum Katalog: XHTML, HTML und CSS






 XHTML, HTML und CSS


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de