Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Jifty::Manual::TutoriaUser(Contributed Perl DocumJifty::Manual::Tutorial_de(3)

NAME
       Jifty::Manual::Tutorial_de - EinfA1/4hrung in Jifty

BESCHREIBUNG
       Dieses Tutorial sollte Ihnen alles Wichtige mit auf den Weg geben, um
       erfolgreich eine	erste Applikation mit Jifty zu bauen.

WIE?
   Anforderungen
       Hier steht, was Sie installiert haben sollten --	wenigstens wenn	wir es
       schreiben.

   Jifty installieren
       Nicht wirklich eine groAe Sache.	Wir glauben stark an das DRY (Don't
       Repeat Yourself -- Keine	Wiederholungen)	Prinzip. Das ist einer der
       groAen GrA1/4nde, warum wir Perl	und das	CPAN lieben. Jifty benutzt
       viel Code aus dem CPAN. Bei der letzten ZAxhlung	waren es wenigstens 60
       Pakete. Die meisten Module sind auf vielen Plattformen einsetzbare nur
       in Perl geschriebene Module und sollten ohne Probleme funktionieren.

       Wir haben einige	Anstrengungen unternommen, damit Sie nicht Ihre	Zeit
       damit verbringen	mA1/4ssen, AbhAxngigkeiten aufzulA<paragraph>sen, nur
       um Jifty	zu installieren. Das Jifty Installationsprogramm stellt	fest,
       welche Module Ihr System	benA<paragraph>tigt und	lAxdt bei Bedarf die
       erforderlichen Module nach. Also	machen Sie sich	keine Sorgen, Sie
       werden immer gefragt, bevor Anderungen vorgenommen werden.

       Auf den meisten Systemen	wird Perl mit dem CPAN Modul ausgeliefert,
       womit die Jifty Installation einfach wird:

	 # perl	-MCPAN -e'install Jifty'       # auf Unix-Axhnlichen Systemen
	 # perl	-MCPAN -e"install Jifty"       # auf Win32 Systemen

       Falls Sie lieber	eine ".tar.gz" Datei von Jifty herunterladen wollen,
       kA<paragraph>nnen Sie diese wie folgt installieren:

	 # tar xzvf jifty-<version>.tgz
	 # cd jifty-<version>
	 # perl	Makefile.PL
	 # make
	 # make	test
	 # make	install

       Falls die Tests nicht erfolgreich verlaufen, wAxre eine RA1/4ckmeldung
       an uns interessannt. Bitte melden Sie sich bei der Liste
       "jifty-devel@lists.jifty.org" und melden	den Fehler. (Oder sehen	Sie
       nach unter "HILFE" weiter unten wo beschrieben ist, wie Sie sich	uns
       anschlieAen kA<paragraph>nnen.)

   Erstellung eines Rumpfes
       Wenn Sie	Jifty erfolgreich installiert haben, kA<paragraph>nnen Sie
       Ihre erste Applikation erstellen.

       Jifty ist geplantermaAen	Minimalistisch.	Wenn Sie eine Applikation
       erstellen mA<paragraph>chten, kopieren Sie einfach das jifty
       Kommandozeilenprogramm in das bin/ Unterverzeichnis in Ihr
       Applikations-Verzeichnis.

       OK, es ist natA1/4rlich hilfreich, ein wenig strukturierter vorzugehen.
       Jifty wird mit Werkzeugen geliefert, die	Ihnen helfen, die notwendigen
       Strukturen anzulegen.

       Wechseln	Sie in ein sicheres Verzeichnis, in dem	Sie Ihre Applikation
       anlegen mA<paragraph>chten (Jifty erstellt das notwendige
       Unterverzeichnis	fA1/4r Sie).

	 # jifty app --name MyWeblog
	 Can't guess application root from current path	(/tmp) or bin path (/usr/bin)
	 Creating new application MyWeblog
	 Creating directory lib
	 Creating directory lib/MyWeblog
	 Creating directory bin
	 Creating directory etc
	 Creating directory doc
	 Creating directory log
	 Creating directory var
	 Creating directory var/mason
	 Creating directory share
	 Creating directory share/po
	 Creating directory share/web
	 Creating directory share/web/templates
	 Creating directory share/web/static
	 Creating directory lib/MyWeblog/Model
	 Creating directory lib/MyWeblog/Action
	 Creating directory t
	 Creating configuration	file MyWeblog/etc/config.yml

       Sehen wir uns die einzelnen Verzeichnisse genauer an.

       bin Innerhalb des bin/ Verzeichnisses liegt jifty, die Jifty
	   Kommandozentrale. Einige der	wichtigsten Befehle sind "schema",
	   welches ein Datenbank-Schema	erstellt oder erneuert und "server",
	   womit ein funktionsfAxhiger Webserver gestartet wird. Um die	von
	   jifty verstandenen Kommandos	herauszufinden,	tippen Sie:

	       jifty help

       etc Konfigurationsdateien leben in etc/ und Jifty wird vernA1/4nftige
	   Standardwerte verwenden, sollte keine Konfigurationsdatei vorhanden
	   sein	oder benA<paragraph>tigte EintrAxge fehlen.

       doc Leider erstellt Jifty keine magische	Dokumentation, aber wenn Sie
	   dokumentieren, dann bitte in	das Verzeichnis	doc/.

       log Jifty setzt Log::Log4perl ein, um mitzuprotokollieren.
	   Voreingestellt ist das Erstellen der	Logs server.log	und error.log
	   in das log/ Verzeichnis.

       share/web/templates
	   Jifty nutzt HTML::Mason als sein primAxres Template System. Legen
	   Sie die Templates Ihrer Appkikation in share/web/templates/.	Von
	   Haus	aus wird Jifty mit einer vordefinierten	Applikation geliefert,
	   die im Verzeichnis share/web/templates/ installiert wird. Diese
	   vordefinierte Applikation ist ein bequemer Weg um eine einfache
	   eigene Applikation schnell zum Laufen zu bringen, jedoch sind
	   sicher Anpassungen notwendig, wenn Ihre Applikation komplexer wird.

	   Sie kA<paragraph>nnen schnell herausfinden, wo Jifty	seine
	   vordefinierten Templates ablegt:

	     perl -MJifty::Util	-e 'print Jifty::Util->share_root'

       share/web/static
	   Einige einfache Dinge, die zu Ihrer Applikation gehA<paragraph>ren,
	   brauchen nicht (oder	sollten	nicht) durch das Template-System
	   laufen.

	   Stecken Sie solche Dateien einfach in das share/web/static/
	   Verzeichnis und Jifty wird diese verwenden, wenn es nicht
	   gleichzeitig	ein Template mit identischen Namen gibt.

	   Von Hause aus wird Jifty mit	einigen	CSS Stilen, JavaScript
	   Bibliotheken	und einem Pony geliefert. Sehen	Sie einfach im
	   Verzeichnis share/web/static	der Jifty Distribution nach oder dort
	   wo Jifty seine Standard-Templates ablegt.

       lib/MyWeblog
	   Eine	nAxhere	Beschreibung des Objekt	Modells	und der
	   Verzeichnishierarchie finden	Sie unter Jifty::Manual::ObjectModel

	   Zum Bau einer funktionsfAxhigen einfachen Applikation brauchen Sie
	   sich	nur Gedanken A1/4ber zwei Arten	von Klassen, Models und
	   Actions zu machen.

       lib/MyWeblog/Model
	   Die wirkliche Basis Ihrer Applikation lebt in "lib/AppName/Model".
	   Alle	Klassen	hier definieren	die Daten(bank)strukturen Ihrer
	   Applikation und wie diese miteinander verbunden sind. Jifty benutzt
	   diese Model-Klassen zum Erstellen oder Aktualisieren	des Datenbank-
	   Schemas, wenn dies notwendig	sein sollte.

       lib/MyWeblog/Action
	   Als wir gesagt haben, daA Sie sich nur A1/4ber Models und Actions
	   den Kopf zerbrechen mA1/4ssen, haben	wir nicht die ganze Wahrheit
	   gesagt. Jifty kA1/4mmert sich um grundlegende Datenbank
	   Interaktionen ("CREATE (Anlegen), READ (Lesen), UPDATE
	   (Aktualisieren), DELETE (LA<paragraph>schen)"). Entsprechend
	   benA<paragraph>tigte	Actions	werden fA1/4r die jeweiligen Models
	   automatisch erzeugt und kA<paragraph>nnen jederzeit verAxndert
	   werden, sollte dies notwendig werden.

       t   Jifty legt bereits Test-Routinen fA1/4r Ihre	Applikation an,	kann
	   allerdings nicht die	Tests fA1/4r Sie schreiben. (Es	erstellt
	   jedoch einfache Tests fA1/4r	die Model-Klassen, die Sie anlegen.)

       var Jifty speichert Cache-Dateien hier, wAxhrend	der Server lAxuft.
	   Normalerweise werden	Sie hier nichts	tun mA1/4ssen.

   Erstellung eines Datenmodells
       Wie Sie sich aus	der Tatsache, daA diese	Tutorial-Applikation MyWeblog
       heiAt, vorstellen kA<paragraph>nnen, ist	das hier vorgestellte Beispiel
       ein einfaches Weblog. KA1/4nftige Tutorials werden Authentifizierung,
       Kommentare sowie	RSS und	Atom Feeds beschreiben.

       Posts

       Weblogs konzentrieren sich rund um Posts, daher ist es keine
       Aberraschung, daA unser erstes Model, das wir erzeugen werden, ein
       "Post" ist.

	 # cd MyWeblog
	 # jifty model --name Post
	 Writing file /tmp/MyWeblog/t/00-model-Post.t
	 Writing file /tmp/MyWeblog/lib/MyWeblog/Model/Post.pm

       GroAartig! Nun haben Sie	ein Post Model (Nur, daA es im Augenblick noch
       nichts modelliert).

       Affnen Sie lib/MyWeblog/Model/Post.pm in	Ihrem Lieblings-Editor.

       Sie sollten etwas sehen wie:

	 use strict;
	 use warnings;

	 package MyWeblog::Model::Post;
	 use Jifty::DBI::Schema;

	 use MyWeblog::Record schema {

	 };

	 # Your	model-specific methods go here.

	 1;

       Nun ist es an der Zeit, der Model Klasse	etwas A1/4ber Posts zu
       erzAxhlen. Fangen wir damit an, einem Post einen	"body" (Rumpf) und
       einen "title" (Titel) zu	geben. (In einem kommenden Tutorial wird die
       Applikation voll	"Folksonomy"-tauglich werden, was wir durch AnfA1/4gen
       einer "category"	(Kategorie) und	Erweitern der "category" zu einer
       "tags" (Indexierung, Etikett) Tabelle erreichen kA<paragraph>nnten.)

       Editieren Sie unter dieser Zeile:

	 use MyWeblog::Record schema {

       FA1/4gen	Sie diese Zeilen an:

	 column	title =>
	       type is 'text',
	       label is	'Title',
	       default is 'Ohne	Titel';

	 column	body =>
	       type is 'text',
	       label is	'Content',
	       render_as 'Textarea';

       Abspeichern bitte nicht vergessen.

   Erstellung der Datenbank
       Gut. Nun	ist es an der Zeit, die	Datenbank zu erstellen.	StandardgemAxA
       benutzt Jifty eine SQLite Datenbank. Wenn Sie lieber PostgreSQL oder
       MySQL verwenden mA<paragraph>chten, dann	kA<paragraph>nnen Sie
       Anpassungen an etc/jifty.yml vornehmen. (Sehen Sie dazu in
       "Jifty::Config" nach, um	mehr darA1/4ber	zu erfahren.)

	 # jifty schema	--setup
	 INFO -	Generating SQL for application MyWeblog...
	 INFO -	Using MyWeblog::Model::Post
	 INFO -	Using Jifty::Model::Session
	 INFO -	Using Jifty::Model::Metadata
	 INFO -	Using Jifty::Model::Schema
	 INFO -	Set up version v0.0.1, jifty version 0.607280

   Start des Jifty Application Server
       OK. Nun haben Sie eine lauffAxhige, aber	noch einfache Applikation.
       Starten Sie den Webserver und schauen Sie sich um. Werfen Sie einen
       Blick auf die AJAX gesteuerte Administrations-Umgebung, die Online
       Dokumentation und das Pony.

	 # ./bin/jifty server
	 INFO -	You can	connect	to your	server at http://localhost:8888/

       Starten Sie diese Kommandofolge immer im	Hauptverzeichnis Ihrer Jifty
       Applikation, andernfalls	werden etliche Fehlermeldungen die Folge sein.

       Auf den meisten Plattformen wird	ein einfaches "jifty server" Kommando
       ebenfalls funktionieren.	:)

   Erstellung der Benutzeroberfl~Aoxche
       Die Administrations-Umgebung gibt Ihnen zwar alles, was Sie brauchen,
       um mit den Daten	der Applikation	zu arbeiten, ist aber noch lange kein
       Weblog.

       Erstellung von Posts

       Erstellen Sie eine Seite	zum Posten eines neuen Weblog Eintrages:

	 # cd share/web/templates/

       Erstellen Sie eine neue Datei namens post in Ihrem Editor. Stellen Sie
       sicher, daA diese so aussieht:

	 <%init>
	 my $action = Jifty->web->new_action(class => 'CreatePost');
	 </%init>

	 <&| /_elements/wrapper, title => "Post	Eintrag	Erstellen" &>
	 <% Jifty->web->form->start() %>
	 <% Jifty->web->form->next_page( url =>	'/') %>
	 <% $action->form_field('title') %>
	 <% $action->form_field('body')	%>
	 <% Jifty->web->form->submit( label => 'Post' )	%>
	 <% Jifty->web->form->end() %>
	 </&>

       Ja, dies	ist eine Template Datei	in HTML::Mason Syntax. Wenn Sie	noch
       nicht genug A1/4ber Mason wissen, empfehlen wir dessen Online
       Dokumentation fA1/4r mehr Details. Mason	Templates sollten jeweils in
       der ersten Spalte der Datei beginnen. Besonders wichtig sind die
       "<%init>" und "</%init>"	BlA<paragraph>cke, die unbedingt
       lingsbA1/4ndig geschrieben werden mA1/4ssen.

       Anzeige

       Es ist relativ einfach, eine einfache Auflistung	von EintrAxgen zu
       erhalten	und ein	wenig aufwAxndiger, eine AJAX gesteuerte seitenweise
       Darstellung zu bekommen.	Hier beschreiben wir, wie man beides macht;
       Sie kA<paragraph>nnen entscheiden, welches Ihnen	besser gefAxllt.

       (Falls Sie per Kopieren und EinfA1/4gen den Beispiel-Code von unten
       A1/4bertragen, stellen Sie sicher, daA er in einer Spalte erscheint,
       ansonsten wird es nicht funktionieren.)

       Der schnelle Weg

       Erstellen Sie eine neue Datei index.html	im share/web/templates
       Verzeichnis in Ihrem Editor. (Der Webserver wird	die URL	"/index.html"
       als die Standard	Seite fA1/4r Ihre Applikation annehmen.) BefA1/4llen
       Sie die Datei wie folgt:

	 <%init>
	 my $posts = MyWeblog::Model::PostCollection->new();
	 $posts->unlimit();
	 </%init>

	 <&| /_elements/wrapper, title => Jifty->config->framework('ApplicationName') &>
	 <dl>
	 % while (my $post = $posts->next) {
	  <dt><% $post->title %></dt>
	  <dd><% $post->body %></dd>
	 % }
	 </dl>
	 </&>

       (Entfernen Sie die Leerzeichen am Zeilenanfang!)

       Die aufwAxndige Art, mit	der Sie	viele coole Dinge bekommen

       Die aufw_A_xndige Art benutzt eines von Jifty's fortgeschrittenen
       Eigenschaften: PageRegions (Seitenbereiche). Diese Bereiche erlauben
       Ihrer Applikation einzelne Bestandteile einer Seite unabhAxngig
       voneinander neu zu laden. Das funktioniert sowohl unter Benutzung von
       AJAX auf	modernen Browsern, als auch mit	GET Requests auf nicht
       JavaScript fAxhigen Browsern wie	"lynx",	"w3m" oder dem Browser Ihres
       Handys.

       Der Nachteil dieser Methode ist,	daA jeder Seiten-Bereich in einer
       eigenen Fragment	Datei vorliegen	muA.

       Die aufwAxndige Art beginnt zunAxchst genauso wie der schnelle Weg.
       Erstellen Sie eine neue Datei mit dem Namen
       share/web/templates/index.html in Ihrem Editor. BefA1/4llen Sie die
       Datei mit:

	 <&| /_elements/wrapper, title => Jifty->config->framework('ApplicationName') &>

	 <% Jifty->web->region(name => "myweblog-posts",
			       path => "/fragments/page_of_posts") %>
	 </&>

       Wenn Sie	mitgedacht haben, dann haben Sie bestimmt schon	erraten, daA
       Sie als nAxchstes eine Datei
       share/web/templates/fragments/page_of_posts mit dem nachfolgenden
       Inhalt anlegen dA1/4rfen:

	 <%args>
	 $page => 1
	 </%args>
	 <%init>
	 my $posts = MyWeblog::Model::PostCollection->new();
	 $posts->unlimit();
	 $posts->set_page_info(	current_page =>	$page,
				per_page     =>	15
			      );
	 $m->out("Keine	EintrAxge.") if	($posts->pager->total_entries == 0);

	 </%init>
	 % if ($posts->pager->last_page	> 1) {
	    Seite <% $page %> von <% $posts->pager->last_page %>
	 % }
	 <dl class="list">
	 % while (my $post = $posts->next) {
	  <dt><% $post->title %></dt>
	  <dd><% $post->body %></dd>
	 % }
	 </dl>

	 % if ($posts->pager->previous_page) {
	   <% Jifty->web->link(	label => "vorherige Seite", onclick => { args => { page	=> $posts->pager->previous_page	} } ) %>
	 % }
	 % if ($posts->pager->next_page) {
	   <% Jifty->web->link(	label => "nAxchste Seite", onclick => {	args =>	{ page => $posts->pager->next_page } } ) %>
	 % }

       Nun starten Sie den Jifty Webserver erneut. Erstellen Sie einen Post
       indem Sie die URL "/post" auf Ihrem Webserver anfahren. Erstellen Sie
       wenigstens 15 EintrAxge und beobachten Sie dabei, wie Jifty Ihnen die
       AJAX KnA<paragraph>pfe "vorherige Seite"	und "nAxchste Seite" erstellt.
       Schalten	Sie JavaScript aus oder	verwenden Sie lynx und beobachten Sie
       wie AJAX	automatisch zurA1/4ckfAxllt zum	vollstAxndigen Laden der
       jeweils neuen Seite. Alles umsonst. Danke, Jifty!

       Hey, woher kam diese Klasse?

       Wenn Sie	genau aufgepasst haben,	dann haben Sie sich sicher gefragt,
       woher die "MyWeblog::Model::PostCollection" Klasse kam. Es gibt keine
       Datei mit dem Namen PostCollection.pm. Jifty setzt "Jifty::ClassLoader"
       ein, um einige Klassen fA1/4r Sie zu erstellen. SelbstverstAxndlich
       kA<paragraph>nnten Sie das ebenfalls tun. Lesen Sie unter
       Jifty::ClassLoader mehr darA1/4ber.

   Navigation
       NatA1/4rlich ist	es unschA<paragraph>n, sich die	URL der	Post Seite
       merken zu mA1/4ssen. Um einen Post Eintrag im MenA1/4 zu	bekommen,
       mA1/4ssen Sie die Standard MenA1/4s A1/4berschreiben.

       Jifty's Standard	MenA1/4s werden	durch _elements/nav in den Standard
       Applikations Templates (die mit dem Pony) erzeugt. Im Augenblick	bleibt
       Ihnen nichts anderes A1/4brig, als _elements/nav	zu A1/4berschreiben.
       (Wir arbeiten an	Methoden, dies besser zu gestalten.)

       Legen Sie innerhalb des Verzeichnisses share/web/templates Ihrer
       Applikation ein Verzeichnis _elements an.

	 mkdir share/web/templates/_elements

       Sie mA<paragraph>chten bestimmt mit den normalen	Jifty Templates
       arbeiten, also mA1/4ssen	wir nur	den "$top->child( Post... )" Teil
       anfA1/4gen.

	 cat $(perl -MJifty::Util -e 'print Jifty::Util->share_root' \
	   )/web/templates/_elements/nav > share/web/templates/_elements/nav

       Ansonsten kA<paragraph>nnen Sie innerhalb _elements auch	gerne eine
       neue Datei namens "nav" anlegen,	die so aussehen	kA<paragraph>nnte:

	 <%init>
	 my $top = Jifty->web->navigation;
	 $top->child( Home => url => "/");
	 $top->child( Post => url => "/post",
			      label => "Neuen Eintrag");
	 </%init>

       Mehr Information	A1/4ber	das MenA1/4 System kA<paragraph>nnen Sie der
       Dokumentation unter Jifty::Web::Menu entnehmen.

   Das war's
       Das war alles, das Sie benA<paragraph>tigen, um anzufangen, Jifty
       Applikationen zu	erstellen. Wir arbeiten	hart daran, Jifty noch
       einfacher einsetzbar zu machen und die dicken Brocken dieses Tutorials
       so bald als mA<paragraph>glich zu vereinfachen.

       Bitte nehmen Sie	auf der	"jifty-devel" Mailing Liste Kontakt mit	uns
       auf, wenn Sie Fragen haben, wie man Jifty benutzt oder was Sie
       schwierig zu benutzen finden. Dies ist eine Mailing Liste in englischer
       Sprache.

HILFE
   Online Hilfe
       Das "jifty" Kommandozeilen Programm besitzt eine	eingebaute Hilfe
       Funktion.

	 jifty help

	 jifty help <kommando>

       Wenn Ihr	Server mit eingeschaltetem Administrations-Modus arbeitet (die
       Konfigurations-Einstellung "AdminMode" fehlt oder sie ist ungleich
       Null), dann kA<paragraph>nnen Sie den "Online Docs" Link	in Ihrem
       Browser benutzen, um eine ausfA1/4hrliche modulweise Dokumentation zu
       Jifty zu	erhalten.

   Beitreten der Mailing Liste
       "jifty-devel@lists.jifty.org" ist der Ort, an dem wir besprechen, wie
       wir Jifty erstellen, was	es an Problemen	oder VorschlAxgen gibt und so
       weiter.

       Um der Liste beizutreten, senden	Sie eine Mail an
       "jifty-devel-subscribe@lists.jifty.org".	Bitte beachten Sie, daA	die
       Kommunikation in	dieser Liste in	englischer Sprache gefA1/4hrt wird.

   Unser Wiki
       Wir haben ein Wiki! (TatsAxchlich ist das Wiki die hauptsAxchliche
       Website von Jifty).

       Besuchen	Sie uns	unter <http://jifty.org/>, lesen Sie und tragen	Sie
       etwas bei!

       Das Wiki	wird von Wifty betrieben, einem	Wiki das auf Jifty basiert.
       Sein Code ist frei verfA1/4gbar in unserem Subversion Repository.

FEHLER MELDEN
       In dieser frA1/4hen Phase von Jifty melden Sie bitte alle Fehler, die
       Ihnen auffallen,	an "jifty-devel@lists.jifty.org".

K~
       KA1/4nftige Tutorials werden enthalten:

       o   Zugangskontrolle und	Sicherheit

       o   Erweiterung von Datenmodellen

       o   Umfangreiche	Beschreibung des Dispatchers

       o   Einbindung einer Applikation	in einen Live Server

       o   Web Services	im Detail

       o   Continuations (Fortsetzungen) und deren Einsatz

       o   Anpassungen der Darstellung (Benutzerdefinierte Wrapper und CSS)

perl v5.32.1			  2015-04-30	 Jifty::Manual::Tutorial_de(3)

NAME | BESCHREIBUNG | WIE? | HILFE | FEHLER MELDEN | K~

Want to link to this manual page? Use this URL:
<
https://www.freebsd.org/cgi/man.cgi?query=Jifty::Manual::Tutorial_de&sektion=3&manpath=FreeBSD+13.0-RELEASE+and+Ports>

home | help