Rapid Application Prototyping in PHP met behulp van een Micro Framework

Laten we eerlijk zijn: we hebben allemaal geweldige ideeën voor een webapplicatie. Of je ze nu op papier schrijft of ze onthoudt met je eidetic geheugen, er komt een moment waarop je wilt testen of je idee echt haalbaar is.

In deze tutorial gebruiken we een micro-framework, een templating-taal en een ORM om snel een applicatie-prototype te ontwikkelen.

Stap 1: Inleiding en instellingen

We hebben allemaal dat gevoel gehad. Weet je, degene waar je weet dat je een geweldig idee hebt voor de webtoepassing, alleen heb je niet de tijd om een snel prototype op te zetten en te testen of het idee echt werkt. Met behulp van een micro-framework, een templating-taal en een ORM, kon je het binnen enkele minuten operationeel hebben.

Voor deze tutorial gebruiken we het uitstekende micro framework Slim, de vormgevende taal Twig en de lichtgewicht vloeiende ORM Paris en Idiorm. Onze voorbeeldtoepassing zal een blog zijn. Je hebt waarschijnlijk al eerder een blog gebouwd, maar we zijn hier om meer te weten te komen over microkaders en een blog past goed in de lijst!

Het eerste dat u wilt doen is deze pakketten van hun respectieve websites halen:

Slim 1.5.02 (stabiele release)
Slanke extra's
Takje 1.1
Parijs en Idiorm

Nu alle pakketten naar uw computer zijn gedownload, is het tijd om uw directorystructuur in te stellen. We plaatsen de bestanden in de hoofdmap van onze site, dus uw projectmap moet er als volgt uitzien:

"Vergeet niet het .htaccess-bestand op te nemen dat met Slim wordt meegeleverd."

Nu we ons project gestructureerd hebben, ga je gang en verwijder je de inhoud van de Slim index.php bestand - we zullen er later iets over schrijven. Je kunt ook alles behalve het TwigView.php klassenbestand in het Slim extras pakket.

Stap 2: Bootstrappen

Onze index.php bestand zal fungeren als een bootstrap, waardoor Slim, Twig en Parijs en Idiorm allemaal netjes samenwerken. Slim zal alle verzoeken hier naar onze toepassing omleiden, controleren op eventuele overeenkomende routepatronen en vervolgens de juiste reactie verzenden. Dit bestand bevat uiteindelijk onze volledige applicatie-instellingen en logica.

Het eerste dat we moeten doen is alle bibliotheken die de magie zullen laten plaatsvinden. Voeg het volgende toe aan de index.php bootstrap bestand:

Als alles goed gaat, zou een verzoek aan je applicatie absoluut niets moeten doen, wat geweldig is!

Laten we nu Twig in gebruik nemen. Met behulp van het Slim extras pakket kunnen we Slim setup een Twig-omgeving voor ons laten. Het enige dat nodig is om te weten is de map Twig, dus laten we dat toevoegen aan onze bootstrap. Ga ook door en maak een map met sjablonen met de naam templates in de hoofdmap van de site terwijl je bezig bent.

 // Configuratie TwigView :: $ twigDirectory = __DIR__. '/ Twig / lib / Twig /';

Het volgende onderdeel van onze stapel is Parijs en Idiorm, onze ORM. Het maakt gebruik van het ingebouwde PHP PDO-object, dus u kunt Postgres of SQLite gebruiken voor uw prototype, maar voor deze zelfstudie gebruiken we MySQL. Zorg ervoor dat u de juiste databasereferenties geeft:

 ORM :: configure ( 'MySQL: host = localhost; dbname = blog'); ORM :: configure ('gebruikersnaam', 'root'); ORM :: configure ( 'password', ");

Laten we tot slot Slim operationeel maken. Het is vrij ingewikkeld, ik denk dat je het ermee eens zult zijn:

 // Start Slim. $ app = new Slim (array ('view' => nieuwe TwigView));

Een waarschuwing. Als u uw toepassing nu probeert uit te voeren, krijgt u mogelijk een cryptische foutmelding. Geen paniek! We lossen dat in een ogenblik op door enkele routes toe te voegen.

Stap 3: Routing

Het toevoegen van routes in Slim is eenvoudig. Alles wat Slim moet weten is de methode voor routeaanvragen (bijvoorbeeld GET, POST, PUT enz.) En URI om op te reageren en hoe te reageren. We zullen de basisroutes van onze applicatie eerst uitwerken en de lef van het prototype creëren verderop in deze tutorial.

Laten we eerst een homepage-route maken:

 // Blog Home. $ app-> get ('/', functie () gebruik ($ app) );

Hier vertellen we Slim om te reageren op elk GET-verzoek dat naar de hoofdmap van onze app verwijst. De uiteindelijke afsluitparameter bevat uiteindelijk de logica om de pagina-uitvoer te genereren.

Laten we een andere route toevoegen om een individueel blogartikel te bekijken:

 // Blogweergave. $ app-> get ('/ view / (: id)', functie ($ id) gebruik ($ app) );

Let op het verschil hier? In onze parameter URI hebben we een slug toegevoegd (:ID kaart), waarmee Slim aan het einde van de URI een waarde verwacht.

Als je ooit een ander PHP-framework hebt gebruikt, ben je waarschijnlijk bekend met dit concept. Als u dat niet bent, komt ons voorbeeld overeen / View / 1, / View / 2 enz.

We hebben deze parameter ook doorgegeven aan onze sluitingsfunctie, zodat we deze ook kunnen gebruiken in onze toepassingslogica. Merk op hoe we onze toepassingsvariabele ook hebben doorgegeven in de scope van de sluitingen, met de gebruik uitspraak? Dit geeft ons toegang tot de internals van Slim, die we zullen gebruiken om request-data te verzamelen en antwoorden te geven.

Onze administratieroutes zullen verschillende aanvraagmethoden moeten gebruiken, dus laten we ze toevoegen:

 // Admin Home. $ app-> get ('/ admin', function () gebruik ($ app) ); // Admin toevoegen. $ app-> get ('/ admin / add', function () gebruik ($ app) ); // Admin Add - POST. $ app-> post ('/ admin / add', function () gebruik ($ app) ); // Beheerder bewerken. $ app-> get ('/ admin / edit / (: id)', functie ($ id) gebruik ($ app) ); // Beheerder bewerken - POST. $ app-> post ('/ admin / edit / (: id)', functie ($ id) gebruik ($ app) ); // Beheerder verwijderen. $ app-> get ('/ admin / delete / (: id)', functie ($ id) gebruik ($ app) );

Je zult merken dat we hier wat POST-routes hebben. Later zullen we deze gebruiken om formulieren in ons beheercentrum te verwerken.

Eindelijk kunnen we Slim beter gebruiken om onze applicatie uit te voeren.

 $ App-> run ();

Stap 4: Modellen

Parijs en Idiorm maken bouwmodellen om uw gegevens gemakkelijk weer te geven, net als het meeste gruntwerk, wat geweldig is voor snelle prototyping. We slaan onze modellen op in een map met de naam modellen, dus ga je gang en maak die map aan. Maak er de basis van Artikel model in een bestand genaamd Article.php:

Vrij eenvoudig, huh? Paris en Idiorm halen alle benodigde informatie uit de modelklasse en de databasetabel. Terwijl we bezig zijn, moeten we waarschijnlijk de database maken en enkele voorbeeldgegevens toevoegen:

CREATE DATABASE 'blog' DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; GEBRUIK 'blog'; CREËER TAFEL INDIEN NIET BESTAAT 'article' ('id' int (10) unsigned NOT NULL AUTO_INCREMENT, 'timestamp' datetime NOT NULL, 'title' varchar (128) NOT NULL, 'summary' varchar (128) NOT NULL, 'content 'text NOT NULL,' author 'varchar (128) NOT NULL, PRIMARY KEY (' id ')) ENGINE = MyISAM DEFAULT CHARSET = utf8; INSERT IN 'article' ('id', 'timestamp', 'title', 'summary', 'content', 'author') VALUES (1, '2011-07-28 02:03:14', 'Hello World ! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad ville veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irre dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. ',' Mr White '), (2,' 2011-07-28 02:03:14 ',' More Hello World! ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut ',' Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minimus veniam, quis nostrud exercise ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. "," Mr Green ");

Ten slotte zullen we, omdat we het artikelmodel op elke pagina gebruiken, het opnemen in onze bootstrap, net nadat we onze bibliotheken hebben geladen:

 // Modellen vereisen 'modellen / Article.php';

Stap 5: Application Front End

Nu we onze toepassingsroutes hebben uitgestippeld en onze modellen geconfigureerd, is het tijd om enkele pagina's te maken. De voorkant van onze blog zal vrij eenvoudig zijn, met een lijst van alle blogartikelen en een pagina om afzonderlijke artikelen te bekijken.

Met behulp van de te koppelen vloeiende interface die Parijs en Idiorm bieden, kunnen we snel databasequery's maken zonder ruwe SQL te schrijven. Laten we alle artikelen voor de startpagina ophalen met behulp van de routeafsluiting:

 $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many ();

We beginnen met het aanroepen van de modelfabriekmethode, die een modelobject van het type zal afgeven Artikel. Vanaf hier hebben we een vloeiende interface, wat betekent dat we onze opdrachten samen kunnen houden. Hier krijgen we alle artikelen in de database, gerangschikt volgens hun tijdstempel, in aflopende volgorde, en dan vertellen we Parijs dat we veel artikelen willen retourneren. Het resultaat van deze query is een array van artikelmodelobjecten.

Om onze resultaten zichtbaar te maken in de browser, moeten we een sjabloon weergeven. Slim biedt een eenvoudige weergavemethode om dit te doen. De eerste parameter is de sjabloon die moet worden weergegeven en de tweede parameter is een associatieve array van gegevens die beschikbaar moet worden gemaakt voor de sjabloon, in ons geval onze artikelobjecten..

 return $ app-> render ('blog_home.html', array ('artikelen' => $ artikelen));

We zullen onze sjablonen schrijven met Twig, die een schone en eenvoudige tagstructuur biedt met overervingsfuncties die we kunnen gebruiken om eenvoudig een webpagina te maken zonder gebruik te maken van PHP. Dit is geweldig voor prototyping, omdat het betekent dat je moet focussen op het vormgeven van de pagina-uitvoer, in plaats van het waden door de vermengde PHP en HTML-spaghetti-code.

We hebben een basislay-outbestand nodig: een eenvoudig HTML-bestand in de map genaamd sjablonen layout.html zal ik doen.

    % block page_title% % endblock%    % block content% % endblock%

Let op de Twig block-tags? Blokken worden regio's genoemd die u kunt vullen met inhoud. We vullen deze blokken in onze individuele paginasjablonen in.

Hier is een snelle spoedcursus over Twig om je op weg te helpen.

Elke variabele of uitdrukking binnen wordt automatisch ontsnapt en weerklinkt, terwijl de %% Met tags kunt u execute-instructies gebruiken, zoals if else conditionals of voor loops.

Laten we doorlopen door stap voor stap de startpagina van de blog te maken. Vergeet niet om een nieuwe sjabloon te maken met de naam blog_home.html in je sjablonenmap.

Het eerste wat we willen dat onze sjabloon doet, is onze lay-out uitbreiden. De strekt tag laat Twig weten dat onze template een erfenis zal zijn van de layout.html het dossier:

 % breidt 'layout.html'% uit

Nu kunnen we dezelfde blok-syntaxis gebruiken die we eerder hebben gebruikt om onze lay-out te vullen. Laten we de paginatitel instellen:

 % block page_title% Mijn blog % endblock%

Twig vult de pagina titel regio in de lay-out, met wat we hebben gedefinieerd in onze sjabloon. Om de kracht van Twig verder te illustreren, maken we het inhoudsblok en gebruiken we nog enkele Twig-functies:

% block content% % for article in articles% % else%

Er zijn momenteel geen artikelen.

% endif% % endblock%

Weet je nog dat we onze array met opgehaalde artikelen eerder aan onze sjabloon hebben doorgegeven? Dit is nu beschikbaar in de sjabloon met de naam artikelen. Met Twigs logic-tags doorlopen we de artikelen variabele om te controleren of het bestaat en zo niet, we hebben een beleefde waarschuwing gegeven. We consolideren een voor loop en anders afhankelijk van één set tags om eenvoudig een lege array af te handelen.

Laten we een lijst met blogartikelen op de startpagina weergeven om ons bekend te maken met de lusvorm van Twig en de syntaxis van de variabele uitvoer:

% block content% % voor artikel in artikelen%

article.title door article.author

article.summary

% else%

Er zijn momenteel geen artikelen.

% endfor% % endblock%

De syntaxis van de for-lus is het tegenovergestelde van PHP's foreach-verklaring - we gebruiken alleen het sleutelwoord in, in plaats van zoals. Dit loopt door onze reeks van artikel objecten, waardoor elk beschikbaar als variabele wordt genoemd artikel binnen de lus.

Binnen de lus gebruiken we de tags, die een ontsnapte waarde laten klinken. Ja, Twig ontsnapt automatisch aan je uitvoer, dus schrijf niet meer htmlentities ()! We hebben ook toegang tot het titelattribuut van onze artikelen met behulp van een punt (.) notatie, in plaats van de gebruikelijke PHP-pijl (->). Als je Javascript of Python hebt geschreven, zou je wat van deze syntaxis moeten kennen.

Dus nu we onze startpagina hebben ingedeeld, laten we die gedetailleerde weergave bekijken.

 // Blogweergave. $ app-> get ('/ view / (: id)', functie ($ id) gebruik ($ app) $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound (); return $ app-> render ('blog_detail.html', array ('article' => $ article)););

Als we Parijs gebruiken, kunnen we snel een artikel pakken op basis van zijn ID met behulp van de vind een() methode. Als Nee Artikel object instantie wordt geretourneerd, we vertellen de Slim-toepassing dat de pagina niet is gevonden, wat automatisch een 404-fout zal veroorzaken.

Als het artikel wordt gevonden, geven we het door aan ons detailsjabloon, dat er als volgt uitziet:

% breidt 'layout.html'% % block page_title% article.title % endblock% % block content% uit

artikel titel

Gepubliceerd: article.timestamp | date ('jS F Y') door article.author

article.content

Terug naar de startpagina

% endblock%

Door Twigs ingebouwde filters te gebruiken, hebben we toegang tot enkele eenvoudige PHP-functies, zoals datum() in onze sjablonen. Het class-kenmerk article.timestamp wordt automatisch aan onze datafilter gegeven als de eerste parameter, en onze datumnotatiereeks wordt de tweede parameter.

We hebben nu een front-end werkende, zij het een eenvoudige, maar het duurde niet lang voordat hij operationeel was. Parijs maakt het heel gemakkelijk om u te concentreren op het verwijderen van uw gegevens uit de database, en zoals we zullen zien bij het maken van ons beheercentrum, maakt het het eenvoudig om ook records in te voegen en bij te werken.

Stap 6: Back-end van toepassing

Laten we werken aan een beheercentrum voor onze blog, dat we structureren onder de URI /beheerder. Aangezien we al de routes hebben ingesteld, kunnen we de logica voor de hoofdpagina van het beheerderscentrum schrijven. Het zal identiek zijn aan onze hoofdpagina van de bloglijst, dus de onderstaande code is logisch:

 // Admin Home. $ app-> get ('/ admin', functie () gebruik ($ app) $ articles = Model :: factory ('Article') -> order_by_desc ('timestamp') -> find_many (); retourneer $ app > render ('admin_home.html', array ('articles' => $ articles)););

We gebruiken een eenvoudige tabelindeling met actielinks voor het toevoegen, bewerken en verwijderen van blogartikelen.

Je bent al bekend met hoe het blokregiosysteem in Twig werkt, dus laten we ons concentreren op ons inhoudsblok:

% block content%

Mijn blogbeheer

Voeg artikel toe

% if articles% % voor artikel in artikelen% % endfor%

Titel	Datum	Schrijver	acties
artikel titel	article.author	article.timestamp \| date ('jS F Y')	Bewerk	Verwijder

% else%

Er zijn momenteel geen artikelen.

% endif% % endblock%

In deze sjabloon gebruiken we de % if% % else% % endif% logica. We willen onze tabelmarkering niet weergeven als er geen artikelen zijn. Daarom controleren we het bestaan ervan voordat we besluiten wat we willen weergeven. We gebruiken ook de datumfilter methode opnieuw, waarvan ik denk dat u ermee instemt, is vrij schoon en leesbaar.

Het hoofdbeheerderscentrum

Laten we doorgaan met het echte vlees van ons beheerderscentrum: inhoud manipuleren. Wat we nodig hebben, is een formulier dat alle velden bevat die we nodig hebben om ons artikel toe te voegen en te bewerken. Gelukkig ondersteunt Twig herbruikbare partials, dus laten we een partiële part creëren article_form.html:

  action_name artikel
  Titel: 
  
  Schrijver: 
  
  Samenvatting: 
 article.summary | default ('') 
  Inhoud: 
 article.content | default ('')

Een partial is gewoon een herbruikbare sjabloon, deze kan nog steeds standaard Twig-logica bevatten. In onze formuliersjabloon gebruiken we de standaard filter, die een standaardwaarde uitvoert als de variabele die wordt gefilterd leeg of niet bestaat. In het geval van onze formuliervelden voeren we een lege string uit als geen van de artikelattributen aanwezig is. We verwachten ook twee variabelen om onze vorm gedeeltelijk operationeel te krijgen. De eerste riep ACTION_NAME beschrijft eenvoudig de formulieractie voor onze gebruikers (dat wil zeggen toevoegen of bewerken) en de tweede action_url wordt gebruikt als de formulieractie.

U zult ongetwijfeld gemerkt hebben hoe de logica voor deze pagina is opgesplitst in twee routes, één voor GET en één voor POST, wat betekent dat we een functie moeten schrijven om elke methode te verwerken. Onze GET-route hoeft alleen maar de pagina weer te geven - niets te lastig. We zullen Twig gewoon vertellen om een nieuwe sjabloon te maken:

 // Admin toevoegen. $ app-> get ('/ admin / edit / (: id)', functie ($ id) return $ app-> render ('admin_input.html', array ('action_name' => 'Toevoegen', 'action_url '=>' / admin / add ')););

We geven de twee variabelen die door ons formulier worden verwacht gedeeltelijk door in de sjabloon. Nu we het erover hebben, laat me uitleggen hoe je de gedeeltelijke in onze kunt gebruiken admin_input.html sjabloon:

 % include 'article_form.html'%

Ik weet zeker dat je waarschijnlijk al geraden had dat het zo simpel was, en dat is het echt. We hoeven alleen het gedeeltelijke deel in een van onze Twig-blokgebieden op te nemen en dan verschijnt het. Het zal ook toegang hebben tot alle variabelen binnen het bereik van zijn hoofdsjabloon (dat wil zeggen de twee variabelen die we hebben doorgegeven). Twig heeft een aantal fantastische functies voor variabele scans en sandboxing-beveiligingsfuncties, maar ze kunnen het beste voor een andere dag worden bewaard.

Onze uiteindelijke invoersjabloon is vrij eenvoudig (zie hieronder) en zal goed werken wanneer we onze bewerkingsbesturingselementen ook bouwen. Ik veronderstel dat je je afvraagt waarom we ons zorgen maken over een deel in de eerste plaats, als onze beide toevoeg- en bewerkingsformulieren dezelfde sjabloon gebruiken. De reden is omdat het de vorm elders tijdens het maken van prototypen herbruikt om een echt briesje te doen, mocht dit nodig zijn.

 % extends 'layout.html'% % block page_title% action_name Artikel % endblock% % block content% % include 'article_form.html'% % endblock%

Voeg een artikelformulier toe

Laten we aan die POST-route werken. Wat we moeten doen is de geposte gegevens ophalen en opslaan in een artikelobject. We houden ons niet bezig met foutcontrole in ons voorbeeld, omdat we ons idee maar ruwweg prototypen. We zullen Parijs vragen om een nieuwe te verstrekken of te creëren artikel voorwerp:

 $ article = Model :: factory ('Article') -> create ();

We kunnen nu doorgaan met het invullen van het artikel uit de geposte gegevens. We pakken de POST-gegevens van ons Slim-toepassingsobject, dat via het request-object een handige hulpmethode biedt:

 $ article-> title = $ app-> request () -> post ('title'); $ article-> author = $ app-> request () -> post ('auteur'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('content'); $ article-> timestamp = date ('Y-m-d H: i: s');

Parijs zorgt ervoor dat u bij het opslaan kunt ontsnappen aan al onze input, wat handig is als u ooit besluit uw prototype voor anderen toegankelijk te maken. Het enige wat we nu hoeven te doen, is Parijs vertellen om het record te bewaren.

 $ Artikel-> save ();

Tot slot vertellen we onze Slim-toepassing om ons terug te brengen naar de dashboardpagina van de hoofdbeheerder met behulp van de redirect helper methode:

 $ App-> redirect ( '/ admin');

Op onze GET-methode voor het bewerken van de route, die simpelweg een samensmelting is van de dingen die we hebben geleerd door het bouwen van onze blogdetailpagina en onze admin-pagina toevoegen. Eerst moeten we het artikel dat we aan het bewerken zijn, laden door het record met Parijs op te halen:

 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound ();

Parijs verzendt een artikelobject van een artikel dat overeenkomt met het artikelrecord-ID dat is ontvangen in onze sluiting, of onwaar als er geen bestaat. We controleren dan of we een exemplaar terug hebben gekregen, anders geven we Slim de opdracht om een 404-fout te gooien.

We geven Slim nu opdracht de invoersjabloon weer te geven, zoals in onze add-route, maar het geladen artikelobject en de juiste actie-URL door te geven:

 return $ app-> render ('admin_input.html', array ('action_name' => 'Bewerken', 'action_url' => '/ admin / edit /'. $ id, 'article' => $ article));

Onze POST-bewerkingsroute werkt vrijwel identiek aan de toevoegen route, met de uitzondering dat we moeten controleren of het artikel kan worden geladen voordat we verder gaan en de kenmerken bijwerken:

 $ article = Model :: factory ('Article') -> find_one ($ id); if (! $ article instanceof Article) $ app-> notFound ();  $ article-> title = $ app-> request () -> post ('title'); $ article-> author = $ app-> request () -> post ('auteur'); $ article-> summary = $ app-> request () -> post ('summary'); $ article-> content = $ app-> request () -> post ('content'); $ article-> timestamp = date ('Y-m-d H: i: s'); $ Artikel-> save (); $ App-> redirect ( '/ admin');

We sluiten ons beheerderscentrum af door de verwijderingsroute te maken. We doen dit door eerst het record op te halen, vergelijkbaar met wat we deden op onze blogdetailpagina eerder:

 $ article = Model :: factory ('Article') -> find_one ($ id);

Als Parijs een artikel heeft geladen, moeten we het verwijderen en vervolgens de gebruiker terugsturen naar de hoofdbeheerderspagina. Parijs maakt het verwijderen van een record zo eenvoudig als maar kan zijn:

 if ($ article instanceof Article) $ article-> delete ();  $ app-> redirect ('/ admin');

En daarmee is ons basis prototype van het beheercentrum klaar.

Stap 7: Middleware gebruiken

Ons beheerderscentrum is nu voltooid. Het is vrij eenvoudig, omdat het slechts een prototype is, maar we willen nog steeds een vorm van autorisatie om het tegen nieuwsgierige blikken te beschermen. Slim stelt ons in staat om middleware in onze routes in te voegen. Wat dit betekent is dat we functies kunnen creëren die worden opgeroepen voordat onze routes de responsafsluiting doen.

We kunnen HTTP Basic Auth gebruiken om ons beheerderscentrum te beschermen. Het is duidelijk dat we iets veiliger zouden gebruiken in een live-site, maar voor ons prototype is dit prima. Helemaal bovenaan onze index.php laten we twee constanten maken die onze gebruikersnaam en wachtwoord bevatten:

 // Verifieer details. define ('USERNAME', 'admin'); define ('PASSWORD', 'password');

Nadat we onze Slim-toepassingsinstantie hebben gemaakt, maken we een afsluiting die we binden aan een variabele om onze autorisatie-middleware-controle te houden:

 // Auth-controle. $ authCheck = function () gebruik ($ app) ;

Als je nog nooit HTTP Basic Auth in PHP hebt gebruikt, is dat heel eenvoudig. We kunnen de gebruiken $ _SERVER array om te controleren welke referenties werden verzonden vanuit de webbrowser van de gebruiker en deze te vergelijken met onze constanten. We doen dit binnen onze nieuw gemaakte sluiting. Het eerste dat we moeten doen in onze auth-controlefunctie is te achterhalen of er authenticatiegegevens zijn verzonden en zo ja, controleer dan of ze overeenkomen met onze constanten:

 $ authRequest = isset ($ _ SERVER ['PHP_AUTH_USER'], $ _SERVER ['PHP_AUTH_PW']); $ authUser = $ authRequest && $ _SERVER ['PHP_AUTH_USER'] === USERNAME; $ authPass = $ authRequest && $ _SERVER ['PHP_AUTH_PW'] === PASSWORD;

Het enige wat we hier doen is controleren of de auth-waarden bestaan en overeenkomen en vervolgens de resultaten opslaan in sommige variabelen. Ervan uitgaande dat een van deze variabelen false is, weten we dat we de gebruiker moeten vragen zichzelf te autoriseren:

 if (! $ authUser ||! $ authPass) $ app-> response () -> header ('WWW-Authenticate: Basic realm = "My Blog Administration"', ''); $ app-> response () -> header ('HTTP / 1.1 401 Unauthorized', ''); $ App-> respons () -> lichaam ('Voer geldige beheerdersreferenties in
'); $ App-> respons () -> send (); Uitgang;

We controleren of onze inloggegevens in orde zijn. Als dat niet het geval is, sturen we een antwoord terug met de juiste koppen en een waarschuwingsbericht. Zoals u eerder zag, konden we toegang krijgen tot het Slim-frameverzoekobject om toegang te krijgen tot onze POST-gegevens. We kunnen ook toegang krijgen tot het interne antwoordobject, waardoor we gemakkelijk onze headers kunnen pushen en de instantie van het Slim response-object kunnen overschrijven met een eenvoudig HTML-waarschuwingsbericht, voordat we uiteindelijk het script dwingen af te sluiten.

In Slim kunt u meerdere callabels toevoegen aan een route en deze worden uitgevoerd in de volgorde waarin ze zijn opgegeven. Dit betekent dat we eenvoudig toegang tot al onze routes kunnen voorkomen door de sluiting van de auth-controle toe te voegen voordat de reactie wordt gesloten:

 // Admin Home. $ app-> get ('/ admin', $ authCheck, function () gebruik ($ app) //?); // Admin toevoegen. $ app-> get ('/ admin / add', $ authCheck, function () gebruik ($ app) //?); // Admin Add - POST. $ app-> post ('/ admin / add', $ authCheck, function () gebruik ($ app) //?); // Beheerder bewerken. $ app-> get ('/ admin / edit / (: id)', $ authCheck, function ($ id) gebruik ($ app) //?); // Beheerder bewerken - POST. $ app-> post ('/ admin / edit / (: id)', $ authCheck, function ($ id) gebruik ($ app) //?); // Beheerder verwijderen. $ app-> get ('/ admin / delete / (: id)', $ authCheck, function ($ id) gebruik ($ app) //?);

En daar heb je het, ons beheerderscentrum is nu beschermd. Iedereen die probeert toegang te krijgen, ziet een waarschuwingsbericht en wordt gevraagd naar hun inloggegevens.

Stap 8: Samenvatting

Hopelijk heeft deze tutorial je laten zien hoe snel en eenvoudig het is om een prototype in gebruik te nemen met een micro framework, een ORM en een sjabloontaal, terwijl je toch een goede scheiding van zorgen en leesbare code behoudt.

Een krachtige sjablonerende taal kan voorkomen dat je weergaven eindigen als een mix van onleesbare PHP en HTML-spaghetti-code, en hoe een vloeiende ORM saaie CRUD-acties snel en pijnloos kan maken.

Dit zijn slechts enkele van de vele leuke dingen die je kunt doen met Slim, Twig en Parijs. Als je verder graaft, kun je relaties toevoegen aan je modellen met Parijs, macrofragmenten toevoegen in Twig om je sjabloonontwikkeling te versnellen en naamgebaseerde routering met Slim te gebruiken om het koppelen van je website-inhoud en het veranderen van URL's triviaal te maken.

Happy prototyping en heel erg bedankt voor het lezen!

Code