Accentsconagua

Rapid Application Prototyping in PHP mit einem Micro Framework

Code
Share

Seien wir ehrlich: Wir haben alle großartige Ideen für eine Webanwendung. Egal, ob Sie sie zu Papier bringen oder sich an Ihr Gedächtnisgedächtnis erinnern, es ist ein Punkt, an dem Sie testen möchten, ob Ihre Idee wirklich realisierbar ist.

In diesem Lernprogramm verwenden wir ein Mikro-Framework, eine Templatiersprache und ein ORM, um schnell einen Anwendungsprototyp zu entwickeln.

Schritt 1: Einführung und Einrichtung

Wir hatten alle dieses Gefühl. Weißt du, derjenige, bei dem du weißt, dass du eine großartige Webanwendungsidee hast, nur hast du nicht die Zeit, einen schnellen Prototyp zu erstellen und zu testen, dass die Idee wirklich funktionieren wird. Mit einem Mikro-Framework, einer Templatiersprache und einem ORM können Sie es in wenigen Minuten einrichten.

Für dieses Tutorial verwenden wir das exzellente Micro-Framework Slim, die Templatiersprache Twig und das leichte, fließende ORM Paris und Idiorm. Unsere Beispielanwendung wird ein Blog sein. Sie haben wahrscheinlich schon einen Blog erstellt, aber wir sind hier, um etwas über Mikro-Frameworks zu lernen, und ein Blog passt gut dazu!

Als Erstes sollten Sie diese Pakete von ihrer jeweiligen Website herunterladen:

  • Slim 1.5.02 (stabile Veröffentlichung)
  • Schlanke Extras
  • Zweig 1.1
  • Paris und Idiorm

Nachdem Sie nun alle Pakete auf Ihren Computer heruntergeladen haben, müssen Sie Ihre Verzeichnisstruktur einrichten. Wir legen die Dateien in den Stammordner der Site, sodass Ihr Projektordner so aussehen sollte:

"Vergessen Sie nicht, die mit Slim gelieferte .htaccess-Datei einzuschließen."

Nachdem wir unser Projekt strukturiert haben, löschen Sie den Inhalt des Slim index.php Datei - wir werden später etwas schreiben. Sie können auch alles außer dem verschrotten TwigView.php Klassendatei im Slim-Extras-Paket.

Schritt 2: Bootstrapping

Unsere index.php file wird als Bootstrap fungieren, wodurch Slim, Twig und Paris und Idiorm gut zusammenarbeiten. Slim leitet hier alle Anfragen an unsere Anwendung weiter, prüft, ob passende Routenmuster vorliegen, und sendet dann die entsprechende Antwort. Diese Datei enthält eventuell unsere gesamte Anwendungskonfiguration und -logik.

Das erste, was wir tun müssen, ist, alle Bibliotheken einzubeziehen, die die Magie verwirklichen. Fügen Sie Folgendes dem hinzu index.php Bootstrap-Datei: 

  
Wenn alles gut geht, sollte eine Anfrage an Ihre Bewerbung absolut nichts tun, was großartig ist!
 
Lassen Sie uns jetzt Twig zum Laufen bringen. Mit dem Slim-Zusatzpaket können wir eine Twig-Umgebung für uns einrichten lassen. Alles, was es wissen muss, ist das Verzeichnis, in dem sich Twig befindet, also fügen wir es in unseren Bootstrap ein. Erstellen Sie auch ein Vorlagenverzeichnis mit dem Namen Vorlagen in der Site-Root, während Sie dabei sind. 
 
 // Konfiguration TwigView :: $ twigDirectory = __DIR__. '/ Zweig / lib / Zweig /';
 
Die nächste Komponente in unserem Stack sind Paris und Idiorm, unser ORM. Es verwendet das eingebaute PHP-PDO-Objekt, sodass Sie Postgres oder SQLite für Ihren Prototyp verwenden können. Für dieses Tutorial verwenden wir jedoch MySQL. Stellen Sie sicher, dass Sie die entsprechenden Datenbankanmeldeinformationen angeben: 
 
 ORM :: configure ('mysql: host = localhost; dbname = blog'); ORM :: configure ('Benutzername', 'root'); ORM :: configure ('Passwort', ");
 
Schliesslich wollen wir Slim zum Laufen bringen. Es ist ziemlich kompliziert, ich denke, Sie werden zustimmen: 
 
 // Schlank starten. $ app = new Slim (Array ('view' => new TwigView));
 
Ein Wort der Warnung. Wenn Sie versuchen, Ihre Anwendung jetzt auszuführen, wird möglicherweise ein kryptischer Fehler angezeigt. Keine Panik! Wir werden das gleich beheben, indem wir einige Routen hinzufügen.
 
 
 Schritt 3: Routing
 
Das Hinzufügen von Routen in Slim ist einfach. Alles, was Slim wissen muss, ist die Routenanforderungsmethode (z. B. GET, POST, PUT usw.) und die URI, auf die zu antworten ist, und wie sie reagieren sollen. Wir werden zunächst die grundlegenden Wege unserer Anwendung ausarbeiten und in diesem Tutorial den Kern des Prototyps erstellen.
 
Lassen Sie uns zuerst eine Startseite erstellen: 
 
 // Blog-Startseite. $ app-> get ('/', function () use ($ app) );
 
Hier sagen wir Slim, dass er auf jede GET-Anfrage antworten soll, die auf das Stammverzeichnis unserer App verweist. Der endgültige Abschlussparameter enthält schließlich die Logik zum Generieren der Seitenausgabe.
 
Fügen Sie eine weitere Route hinzu, um einen einzelnen Blogartikel anzuzeigen: 
 
 // Blogansicht. $ app-> get ('/ view / (: id)', Funktion ($ id) use ($ app) );
 
Beachten Sie den Unterschied hier? In unserem URI-Parameter haben wir einen Slug hinzugefügt (:Ich würde), was bedeutet, dass Slim einen Wert am Ende der URI erwartet. 
 
Wenn Sie jemals ein anderes PHP-Framework verwendet haben, kennen Sie dieses Konzept wahrscheinlich. Wenn nicht, würde unser Beispiel passen / view / 1, / view / 2 usw. 
 
Wir haben diesen Parameter auch an unsere Schließungsfunktion übergeben, sodass wir ihn auch in unserer Anwendungslogik verwenden können. Beachten Sie, wie wir auch unsere Anwendungsvariable mit dem Closures in den Closures-Bereich übergeben haben benutzen Aussage? Auf diese Weise können wir auf die internen Komponenten von Slim zugreifen, mit denen Anfragedaten erfasst und Antworten ausgegeben werden.
 
Für unsere Administrationsrouten müssen verschiedene Anforderungsmethoden verwendet werden. Fügen wir sie also hinzu: 
 
 // Admin-Startseite. $ app-> get ('/ admin', function () use ($ app) ); // Admin hinzufügen. $ app-> get ('/ admin / add', function () use ($ app) ); // Admin hinzufügen - POST. $ app-> post ('/ admin / add', function () use ($ app) ); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', Funktion ($ id) use ($ app) ); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', Funktion ($ id) use ($ app) ); // Admin löschen. $ app-> get ('/ admin / delete / (: id)', Funktion ($ id) use ($ app) );
 
Sie werden feststellen, dass wir hier einige POST-Routen haben. Später verwenden wir diese zur Bearbeitung von Formularen in unserem Admin Center.
 
Schließlich sollten wir Slim sagen, dass er unsere Anwendung ausführen soll.
 
 $ app-> run ();
 
 
 Schritt 4: Modelle
 
Paris und Idiorm machen das Erstellen von Modellen zur Darstellung Ihrer Daten einfach, da dies die meisten Grunzarbeiten erledigt, was sich für schnelles Prototyping eignet. Wir speichern unsere Modelle in einem Verzeichnis mit dem Namen Modelle, Also machen Sie weiter und erstellen Sie dieses Verzeichnis. In ihm das Grundlegende schaffen Artikel Modell in einer Datei namens Artikel.php:
 
  
Ganz einfach, oder? Paris und Idiorm extrahieren alle erforderlichen Informationen aus dem Namen der Modellklasse und der Datenbanktabelle. Wenn wir gerade dabei sind, sollten wir wahrscheinlich die Datenbank erstellen und einige Beispieldaten hinzufügen: 
 
 CREATE DATABASE 'blog' DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; USE 'Blog'; CREATE TABLE WENN NOT EXISTS 'article' ('id' int (10) nicht vorzeichenlos NOT NULL AUTO_INCREMENT, 'timestamp' datetime NOT NULL), 'title' varchar (128) NOT NULL, 'summary' varchar (128) NOT NULL, Inhalt 'text NOT NULL,' author 'varchar (128) NOT NULL, PRIMARY KEY (' id ')) ENGINE = MyISAM DEFAULT CHARSET = utf8; INSERT INTO-Artikel ('id', 'timestamp', 'title', 'summary', 'content', 'author')) WERTE (1, '2011-07-28 02:03:14', 'Hello World.) ! ',' Lorem ipsum dolor sitzen amet, consectetur adipisicing elit, sed tun eiimod tempor incididunt ut labore und dolore magna aliqua. Ut ',' Lorem ipsum dolor sitzen amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt utlore und dolore magna Sie werden in den USA und in der Nähe von Sportarten trainiert, die nicht zu diesem Thema gehören, und Sie werden in der Regel in den Ruhestand gehen, wenn Sie sich in einem solchen Zustand befinden Deserunt mollit anim id est laborum. ',' Mr White '), (2,' 2011-07-28 02:03:14 ',' More Hello World! ',' Lorem ipsum dolor sitzt amet, consectetur verwöhnender elit, sed tun Sie es nicht, wenn Sie sich in einem Laboratorium befinden, und lassen Sie sich von einem magischen Aliqua befassen ut labore et dolore magna aliqua. Ut enim ad minim veniy, quis nostrud ausüben ullamco laboris nisi ut aliquip ex a commodo follat. Duis auture irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Ausnahme: sint occaecat cupidatat, kein Proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ',' Mr. Green ');
 
Da wir das Artikelmodell auf jeder Seite verwenden, fügen wir es in unseren Bootstrap ein, unmittelbar nachdem wir unsere Bibliotheken geladen haben: 
 
 // Modelle erfordern 'models / Article.php';
 
 
 Schritt 5: Anwendungs-Frontend
 
Nun, da wir alle Anwendungsrouten erstellt und unsere Modelle konfiguriert haben, ist es an der Zeit, einige Seiten zu erstellen. Unser Blog-Frontend wird ziemlich einfach sein, mit einer Liste aller Blog-Artikel und einer Seite zum Anzeigen einzelner Artikel.
 
Mit der verkettbaren fließenden Schnittstelle, die Paris und Idiorm bereitstellen, können wir schnell Datenbankabfragen erstellen, ohne Roh-SQL zu schreiben. Lassen Sie uns alle Artikel für die Homepage mithilfe der Routenschließung herausziehen: 
 
 $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many ();
 
Wir beginnen mit dem Aufruf der Modellfabrikmethode, die ein Modellobjekt des Typs ausgeben wird Artikel. Von hier aus haben wir eine fließende Schnittstelle, was bedeutet, dass wir unsere Befehle miteinander verketten können. Hier erhalten wir alle Artikel in der Datenbank, sortiert nach Zeitstempel, in absteigender Reihenfolge und sagen dann Paris, dass viele Artikel zurückgegeben werden sollen. Das Ergebnis dieser Abfrage ist ein Array von Artikelmodellobjekten.
 
Damit unsere Ergebnisse im Browser angezeigt werden, müssen wir eine Vorlage rendern. Slim bietet hierfür eine einfache Render-Methode. Der erste Parameter ist die Vorlage, die gerendert werden soll, und der zweite Parameter ist ein assoziatives Datenfeld, das der Vorlage zur Verfügung gestellt werden soll. Dies sind in unserem Fall unsere Artikelobjekte.
 
 return $ app-> render ('blog_home.html', array ('articles' => $ articles));
 
Wir schreiben unsere Vorlagen mit Twig, das eine saubere und einfache Tag-Struktur mit Vererbungsfunktionen bietet, mit deren Hilfe wir Webseiten ohne PHP ganz einfach gestalten können. Dies ist ideal für das Prototyping, da es bedeutet, sich auf die Gestaltung der Seitenausgabe zu konzentrieren, anstatt sich durch den vermischten PHP- und HTML-Spaghetti-Code zu bewegen.
 
Wir benötigen eine Basislayoutdatei - eine einfache HTML-Datei in Ihrem Vorlagenordner layout.html Wird besorgt.
 
    % block page_title% % endblock%    % block content% % endblock%  
 
Beachten Sie die Twig-Block-Tags? Blöcke sind benannte Bereiche, die Sie mit Inhalt füllen können. Wir füllen diese Blöcke in unseren individuellen Seitenvorlagen auf.
 
Hier ist ein kurzer Crash-Kurs zu Twig, der Sie zum Laufen bringt. 
 
Jede Variable oder jeder Ausdruck innerhalb  wird automatisch entkommen und wiederholt, während die %% Mit Tags können Sie Ausführungsanweisungen wie if else conditionals oder for-Schleifen verwenden.
 
Gehen wir Schritt für Schritt durch das Erstellen der Blog-Homepage. Vergessen Sie nicht, eine neue Vorlage zu erstellen blog_home.html in Ihrem Vorlagenordner.
 
Als Erstes möchten wir, dass unsere Vorlage das Layout erweitert. Das erweitert Mit diesem Tag kann Twig wissen, dass unsere Vorlage vom übernommen wird layout.html Datei: 
 
 % erweitert 'layout.html'%
 
Jetzt können wir dieselbe Block-Syntax verwenden, mit der wir unser Layout gefüllt haben. Legen wir den Seitentitel fest: 
 
 % block page_title% Mein Blog % endblock%
 
Zweig wird das bevölkern Seitentitel Region im Layout, mit dem, was wir in unserer Vorlage definiert haben. Um die Leistungsfähigkeit von Twig weiter zu veranschaulichen, erstellen Sie den Inhaltsblock und verwenden Sie einige weitere Twig-Funktionen: 
 
 % block content% % für Artikel in Artikeln% % else% 
Zur Zeit sind keine Artikel vorhanden.
 % endif% % endblock%
 
Erinnern Sie sich, dass wir unser abgerufenes Artikel-Array zuvor an unsere Vorlage übergeben haben? Dies ist jetzt in der Vorlage mit dem Namen verfügbar Artikel. Mit Twigs-Logic-Tags durchlaufen wir die Artikel Variable, um zu prüfen, ob es existiert und wenn nicht, geben wir eine höfliche Warnmeldung aus. Wir konsolidieren a zum Schleife und sonst in einen Satz von Tags einbinden, um ein leeres Array leicht handhaben zu können.
 
Lassen Sie uns auf der Startseite eine Liste von Blogartikeln anzeigen, um sich mit Twigs Loop- und Variablenausgabesyntax vertraut zu machen: 
 
 % block content% % für Artikel in Artikeln% 
article.title von article.author
 
 Artikelübersicht 
 % else% 
Zur Zeit sind keine Artikel vorhanden.
 % endfor% % endblock%
 
Die for-Schleife-Syntax ist die Umkehrung der foreach-Anweisung von PHP - wir verwenden lediglich das Schlüsselwort im, anstatt wie. Dies durchläuft unser Array von Artikel Objekte, die jeweils als Variable zur Verfügung gestellt werden Artikel innerhalb der Schleife.
 
In der Schleife verwenden wir die  Tags, die einen Escape-Wert ausgeben. Ja, Twig entgeht automatisch Ihrer Ausgabe, so dass Sie nicht mehr schreiben htmlentities ()! Wir greifen auch auf das Artikelattribut unserer Artikel über einen Punkt zu (.Notation anstelle des üblichen PHP-Pfeils (->). Wenn Sie Javascript oder Python geschrieben haben, sollten Sie mit dieser Syntax vertraut sein.
  
Nun, da wir unsere grundlegende Homepage angelegt haben, lassen Sie uns diese Detailansicht knacken.
 
 // Blogansicht. $ app-> get ('/ view / (: id)', Funktion ($ id) use ($ app) $ article = Modell :: factory ('Article') -> find_one ($ id); if (! $ article-Instanz des Artikels) $ app-> notFound (); return $ app-> render ('blog_detail.html', array ('article' => $ article));;
 
Mit Paris können wir einen Artikel anhand seiner ID schnell mit der einen finden() Methode. Wenn nein Artikel Wenn die Objektinstanz zurückgegeben wird, teilen wir der Slim-Anwendung mit, dass die Seite nicht gefunden wurde. Dadurch wird automatisch ein Fehler 404 ausgelöst.
 
Wenn der Artikel gefunden wurde, übergeben wir ihn an unsere Detailvorlage, die wie folgt aussieht:
 
 % erweitert 'layout.html'% % block page_title% article.title % endblock% % block content% 
 Artikelüberschrift 
 
Veröffentlicht: article.timestamp | date ('jS F Y') von article.author
 
article.content
 
Zurück zur Startseite
 % endblock%
 
Mit Hilfe von eingebauten Filtern können wir auf einige grundlegende PHP-Funktionen zugreifen, wie z Datum() in unseren Vorlagen. Das Klassenattribut Artikel.Zeitstempel wird automatisch als erster Parameter unserem Datumsfilter zugewiesen, und unsere Datumsformatzeichenfolge wird zum zweiten Parameter.
  
Wir haben jetzt ein Frontend, das zwar ein einfaches ist, aber es dauerte nicht lange, um es zum Laufen zu bringen. Mit Paris können Sie sich ganz einfach darauf konzentrieren, Ihre Daten aus der Datenbank zu ziehen. Wie wir beim Erstellen unseres Admin-Centers sehen werden, ist es auch einfach, Datensätze einzufügen und zu aktualisieren.
 
 
 Schritt 6: Back-End der Anwendung
 
Lassen Sie uns an einem Admin-Center für unser Blog arbeiten, das wir unter der URI strukturieren werden /Administrator. Da wir bereits alle Routen eingerichtet haben, schreiben wir die Logik für die Hauptseite des Verwaltungscenters. Es ist identisch mit unserer Blog-Hauptseite, daher sollte der folgende Code durchaus Sinn machen: 
 
 // Admin-Startseite. $ app-> get ('/ admin', function () use ($ app) $ articles = Modell :: factory ('Article') -> order_by_desc ('timestamp') -> find_many (); return $ app- > render ('admin_home.html', array ('articles' => $ articles)););
 
Wir verwenden ein einfaches Tabellenlayout mit Aktionslinks zum Hinzufügen, Bearbeiten und Löschen von Blogartikeln.
 
Sie sind bereits mit der Funktionsweise des Blockregionsystems in Twig vertraut. Konzentrieren wir uns also auf unseren Inhaltsblock: 
 
 % block content% 
Meine Blog-Administration
 
Artikel hinzufügen
 % if articles%  % für Artikel in Artikeln%  % endfor% 
  
 Titel Datum Autor Aktionen 
  
  Artikelüberschrift  article.author article.timestamp | date ('jS F Y') Bearbeiten Löschen 
 
 % else% 
Zur Zeit sind keine Artikel vorhanden.
 % endif% % endblock%
 
In dieser Vorlage verwenden wir die % if% % else% % endif% Logik. Wir möchten unser Tabellen-Markup nicht anzeigen, wenn keine Artikel vorhanden sind. Daher prüfen wir das Vorhandensein von Tabellen, bevor wir entscheiden, was angezeigt werden soll. Wir benutzen auch die Datumsfilter  wieder Methode, die, wie Sie meiner Meinung nach zustimmen, ziemlich sauber und lesbar ist.
  
Das Hauptverwaltungscenter
 
Lassen Sie uns auf das eigentliche Fleisch unseres Verwaltungszentrums eingehen: Inhalte manipulieren. Was wir brauchen, ist ein Formular, das alle Felder enthält, die wir zum Hinzufügen und Bearbeiten unseres Artikels benötigen. Glücklicherweise unterstützt Twig wiederverwendbare Partials, also erstellen wir ein Teilformular, das aufgerufen wird article_form.html:
 
 
 
action_name Artikel
 
 
  
 
 
  
 
 
  
 
 
  
 
  
 
 
Ein Partial ist einfach eine wiederverwendbare Vorlage, es kann immer noch eine Standard-Twig-Logik enthalten. In unserer Formularvorlage verwenden wir die Standard filter: Gibt einen Standardwert aus, wenn die zu filternde Variable leer ist oder nicht vorhanden ist. Bei unseren Formularfeldern geben wir eine leere Zeichenfolge aus, wenn keines der Artikelattribute vorhanden ist. Wir erwarten auch zwei Variablen, um unser Formular teilweise betriebsbereit zu machen. Der erste rief an Aktionsname beschreibt einfach die Formularaktion für unsere Benutzer (d. h. Hinzufügen oder Bearbeiten) und die zweite action_url wird als Formularaktion verwendet.
 
Sie haben sicher bemerkt, dass die Logik für diese Seite in zwei Routen aufgeteilt ist, eine für GET und eine für POST. Das bedeutet, dass wir eine Funktion schreiben müssen, um jede Methode zu verarbeiten. Unsere GET-Route muss nur die Seite rendern - nichts zu knifflig. Wir werden Twig nur anweisen, eine neue Vorlage zu rendern: 
 
 // Admin hinzufügen. $ app-> get ('/ admin / edit / (: id)', Funktion ($ id) return $ app-> render ('admin_input.html', array ('action_name' => 'Hinzufügen', 'action_url '=>' / admin / add ')););
 
Wir übergeben die beiden von unserem Formular erwarteten Variablen teilweise in die Vorlage. Apropos, lasst mich erklären, wie man das partielle in unserem verwendet admin_input.html Vorlage: 
 
 % include 'article_form.html'%
 
Ich bin sicher, Sie haben wahrscheinlich gedacht, dass es so einfach sein würde, und das ist es wirklich. Wir müssen nur das partielle Element in eine unserer Twig-Blockregionen aufnehmen, und dann wird es angezeigt. Es hat auch Zugriff auf alle Variablen im Rahmen seiner Hauptvorlage (d. H. Die beiden Variablen, die wir übergeben haben). Twig hat einige großartige Steuerelemente für den variablen Bereich und Sandbox-Sicherheitsfunktionen, die jedoch am besten für einen weiteren Tag gespeichert werden.
 
Unsere endgültige Eingabevorlage ist ziemlich einfach (siehe unten) und funktioniert auch gut, wenn wir unsere Bearbeitungssteuerelemente erstellen. Ich nehme an, Sie fragen sich, warum wir uns in der ersten Hälfte mit einem Partial beschäftigt haben, ob sowohl unser Add- als auch das Edit-Formular dieselbe Vorlage verwenden. Der Grund liegt darin, dass die Wiederverwendung des Formulars an anderen Stellen während des Prototyping zu einem echten Kinderspiel wird, falls dies erforderlich wird.
 
 % erweitert 'layout.html'% % block page_title% aktionsname Artikel % endblock% % block content% % include 'article_form.html'% % endblock%
  
Fügen Sie ein Artikelformular hinzu
 
Lass uns an dieser POST-Route arbeiten. Was wir tun müssen, ist die geposteten Daten zu packen und in einem Artikelobjekt zu speichern. In unserem Beispiel kümmern wir uns nicht um die Fehlerprüfung, da wir unsere Idee nur ungefähr prototypisieren. Wir werden Paris dazu bringen, ein neues abzugeben oder zu schaffen Artikel Objekt: 
 
 $ article = Model :: factory ('Article') -> create ();
 
Wir können jetzt mit dem Auffüllen des Artikels aus den veröffentlichten Daten fortfahren. Wir holen die POST-Daten von unserem Slim-Anwendungsobjekt ab, das über sein Anforderungsobjekt eine praktische Hilfsmethode bietet: 
 
 $ article-> title = $ app-> request () -> post ('title'); $ article-> author = $ app-> request () -> post ('author'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('content'); $ article-> timestamp = Datum ('Y-m-d H: i: s');
 
Paris achtet beim Speichern darauf, alle Eingaben zu umgehen, was praktisch ist, wenn Sie sich jemals dazu entschließen, Ihren Prototypen für andere zugänglich zu machen. Jetzt müssen wir nur noch Paris mitteilen, dass er die Aufzeichnung speichern soll.
 
 $ article-> save ();
 
Schließlich sagen wir unserer Slim-Anwendung, dass sie uns mit der. Zur Admin-Dashboard-Hauptseite zurückbringen soll umleiten Hilfsmethode: 
 
 $ app-> redirect ('/ admin');
 
Auf unserer Edit-Route-GET-Methode, die lediglich eine Zusammenfassung der Erkenntnisse darstellt, die wir aus der Erstellung unserer Blog-Detailseite und unserer Admin-Add-Seite gelernt haben. Zuerst müssen wir den Artikel, den wir bearbeiten, laden, indem wir die Platte mit Paris abrufen: 
 
 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article Instanz von Article) $ app-> notFound (); 
 
Paris sendet eine Artikelobjektinstanz aus, die der in unserer Schließung erhaltenen Artikeldatensatz-ID entspricht, oder false, wenn keine vorhanden ist. Wir prüfen dann, ob wir eine Instanz zurückbekommen haben. Wenn nicht, weisen wir Slim an, einen 404-Fehler auszulösen.
 
Wir weisen Slim nun an, die Eingabevorlage wie in unserer Add-Route zu rendern, aber das geladene Artikelobjekt und die korrekte Aktions-URL zu übergeben: 
 
 $ app-> render zurückgeben ('admin_input.html', array ('action_name' => 'Bearbeiten', 'action_url' => '/ admin / edit /'. $ id, 'article' => $ article));
 
Unsere POST-Editierroute funktioniert fast identisch mit der hinzufügen routen, mit der Ausnahme, dass wir prüfen müssen, ob der Artikel geladen werden konnte, bevor wir seine Attribute aktualisieren: 
 
 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article Instanz von Article) $ app-> notFound ();  $ article-> title = $ app-> request () -> post ('title'); $ article-> author = $ app-> request () -> post ('author'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('content'); $ article-> timestamp = Datum ('Y-m-d H: i: s'); $ article-> save (); $ app-> redirect ('/ admin');
 
Wir schließen unser Admin Center ab, indem wir die Löschroute erstellen. Wir werden dies tun, indem wir zuerst den Datensatz abrufen, ähnlich wie zuvor auf unserer Blog-Detailseite: 
 
 $ article = Model :: factory ('Article') -> find_one ($ id);
 
Wenn Paris einen Artikel geladen hat, müssen wir ihn löschen und den Benutzer zur Hauptverwaltungsseite zurückschicken. Paris macht das Löschen eines Datensatzes so einfach wie möglich: 
 
 if ($ article instanceof Article) $ article-> delete ();  $ app-> redirect ('/ admin');
 
Und damit ist unser grundlegendes Prototyp-Admin-Center fertig.
 
 
 Schritt 7: Middleware verwenden
 
Unser Admin-Center ist nun fertig. Es ist ziemlich einfach, da es nur ein Prototyp ist, aber wir möchten immer noch eine Art Autorisierung, um es vor neugierigen Blicken zu schützen. Mit Slim können wir Middleware in unsere Routen einfügen. Dies bedeutet, dass wir Funktionen erstellen können, die vor dem Schließen der Routenantwort aufgerufen werden.
 
Wir können HTTP Basic Auth verwenden, um unser Admin Center zu schützen. Natürlich würden wir etwas Live-sichereres verwenden, aber für unseren Prototyp ist das in Ordnung. Ganz oben auf unserer index.php Lassen Sie uns zwei Konstanten erstellen, die unseren Benutzernamen und das Kennwort enthalten: 
 
 // Auth Details. define ('USERNAME', 'admin'); define ('PASSWORD', 'Passwort');
 
Nachdem wir unsere Slim-Anwendungsinstanz erstellt haben, erstellen wir eine Schließung, die wir an eine Variable binden, um die Überprüfung der Berechtigungs-Middleware durchzuführen: 
 
 // Auth Check. $ authCheck = function () use ($ app) ;
 
Wenn Sie HTTP Basic Auth noch nie in PHP verwendet haben, ist das ganz einfach. Wir können die verwenden $ _SERVER Array, um zu überprüfen, welche Anmeldeinformationen vom Webbrowser des Benutzers gesendet wurden, und vergleichen Sie diese mit unseren Konstanten. Wir machen das in unserem neu erstellten Verschluss. Das erste, was wir in unserer Auth-Check-Funktion tun müssen, ist herauszufinden, ob Authentifizierungsdaten gesendet wurden. Wenn dies der Fall ist, prüfen Sie, ob sie mit unseren Konstanten übereinstimmen: 
 
 $ authRequest = isset ($ _ SERVER ['PHP_AUTH_USER'], $ _SERVER ['PHP_AUTH_PW']); $ authUser = $ authRequest && $ _SERVER ['PHP_AUTH_USER'] === USERNAME; $ authPass = $ authRequest && $ _SERVER ['PHP_AUTH_PW'] === PASSWORD;
 
Alles, was wir hier tun, ist zu prüfen, ob die Auth-Werte vorhanden sind und übereinstimmen, und dann die Ergebnisse in einigen Variablen speichern. Wenn eine dieser Variablen falsch ist, wissen wir, dass wir den Benutzer auffordern müssen, sich selbst zu autorisieren:
 
 if (! $ authUser ||! $ authPass) $ app-> response () -> header ('WWW-Authenticate: Basic realm = "Meine Blog-Verwaltung"', ''); $ app-> response () -> header ('HTTP / 1.1 401 Unauthorized', ''); $ app-> response () -> body ('
Bitte geben Sie gültige Anmeldeinformationen ein
'); $ app-> response () -> send (); Ausfahrt; 
 
Wir prüfen, ob unsere Berechtigungsnachweise in Ordnung sind. Ist dies nicht der Fall, senden wir eine Antwort mit den entsprechenden Kopfzeilen und der Warnmeldung zurück. Wie Sie bereits gesehen haben, können wir auf das Anfrageobjekt des Slim-Frameworks zugreifen, um auf unsere POST-Daten zuzugreifen. Wir können auch auf das interne Antwortobjekt zugreifen, wodurch es uns leicht fällt, unsere Header zu drücken und den Hauptteil des Slim-Antwortobjekts mit einer einfachen HTML-Warnmeldung zu überschreiben, bevor das Skript schließlich beendet wird.
 
In Slim können Sie einer Route mehrere Callables hinzufügen, die in der angegebenen Reihenfolge ausgeführt werden. Dies bedeutet, dass wir den Zugriff auf alle unsere Routen auf einfache Weise verhindern können, indem vor dem Schließen der Antwort die Authentifizierungsprüfung hinzugefügt wird: 
 
 // Admin-Startseite. $ app-> get ('/ admin', $ authCheck, function () use ($ app) //?); // Admin hinzufügen. $ app-> get ('/ admin / add', $ authCheck, function () use ($ app) //?); // Admin hinzufügen - POST. $ app-> post ('/ admin / add', $ authCheck, function () use ($ app) //?); // Admin Edit. $ app-> get ('/ admin / edit / (: id)', $ authCheck, Funktion ($ id) use ($ app) //?); // Admin Edit - POST. $ app-> post ('/ admin / edit / (: id)', $ authCheck, Funktion ($ id) use ($ app) //?); // Admin löschen. $ app-> get ('/ admin / delete / (: id)', $ authCheck, Funktion ($ id) use ($ app) //?);
 
Und da haben Sie es, unser Admin-Center ist jetzt geschützt. Jeder, der versucht, darauf zuzugreifen, wird eine Warnmeldung sehen und zur Eingabe der Anmeldeinformationen aufgefordert.
  
 
 Schritt 8: Zusammenfassung
 
Ich hoffe, dieses Tutorial hat Ihnen gezeigt, wie schnell und einfach es ist, einen Prototyp mit einem Mikro-Framework, einer ORM- und einer Vorlagensprache in Betrieb zu nehmen und dabei die Trennung von Anliegen und lesbarem Code aufrechtzuerhalten.
 
Eine leistungsfähige Templatiersprache kann verhindern, dass Ihre Ansichten als Mischung aus unlesbarem PHP- und HTML-Spaghetti-Code enden und wie ein fließender ORM langweilige CRUD-Aktionen schnell und schmerzlos machen kann.
 
Dies sind nur einige der vielen coolen Dinge, die Sie mit Slim, Twig und Paris machen können. Wenn Sie weiter recherchieren, können Sie Ihren Modellen mit Paris Beziehungen hinzufügen, in Twig Makro-Schnipsel hinzufügen, um die Entwicklung von Vorlagen zu beschleunigen, und mithilfe von namenbasiertem Routing mit Slim das Verknüpfen Ihres Website-Inhalts und das Ändern von URLs einfach machen.
 
Viel Spaß beim Prototyping und vielen Dank für das Lesen!





	
	
			
	   
	







Code
×