Share
Als programmeur is het belangrijk dat je de stroom begrijpt van het systeem waarmee je werkt - niet alleen om iets te kunnen veranderen wanneer dat nodig is, maar ook omdat het je een zelfvertrouwen boost geeft terwijl je dit doet.
Vandaag zullen we OpenCart kiezen en het ontleden om de basisprincipes van het dispatchingproces te begrijpen. We beginnen met datgene waar het dispatchingproces over gaat, en naarmate we verder gaan verkennen we codeplakken uit de verschillende secties van het framework.
Ik haal de nieuwste versie van OpenCart voor dit artikel op, maar min of meer de stroom is vergelijkbaar in de eerdere versies.
In elke webgebaseerde toepassing wordt het verzendproces gebruikt om de toewijzing tussen de binnenkomende aanvraag-URL en de overeenkomstige module in het raamwerk te vinden. Natuurlijk varieert de implementatie van kader tot raamwerk, maar het onderliggende concept blijft hetzelfde. Dus hier zijn enkele verantwoordelijkheden van de dispatcher:
Laten we proberen dit te begrijpen met een eenvoudig voorbeeld in OpenCart. Om een nieuwe gebruiker vanaf de front-end te maken, moet men zich registreren bij de site met behulp van http://www.youropencartstore.com/index.php?route=account/register. Laten we de stappen samenvat die OpenCart heeft genomen om de gevraagde pagina weer te geven.
Dus dat is een weergave op het hoogste niveau van hoe OpenCart de gevraagde URL doorloopt en het antwoord retourneert. In het volgende gedeelte gaan we dieper in en zien we hoe dat precies gebeurt.
Ga je gang en open de index.php bestand in de document root van OpenCart. Er gebeurt veel in dat bestand, maar raak niet overweldigd, want het meeste is slechts de opstelling van objecten die in het hele kader worden gebruikt.
Laten we meteen het fragment van onze interesse uit dat bestand halen.
Accentsconagua
// Front Controller $ controller = new Front ($ register); // Onderhoudsmodus $ controller-> addPreAction (nieuwe actie ('gemeenschappelijk / onderhoud')); // SEO URL's $ controller-> addPreAction (nieuwe actie ('common / seo_url'));Zoals met de meeste andere frameworks, vertrouwt OpenCart ook op het patroon van de front-controller, zodat er een gemeenschappelijk toegangspunt is voor alle aanvragen in de applicatie.
Eerst maken we een instantie van de frontcontroller en wijzen deze toe aan de $ controller variabel. Direct hierna noemen we de addPreAction methode om een aantal acties toe te voegen.
Nu brengt dat een ander onderwerp op tafel: wat is een "preAction"? Eenvoudig gezegd is een preAction een actie die vóór de gevraagde actie op elke pagina wordt uitgevoerd. Wanneer de gebruiker bijvoorbeeld op een pagina klikt, wilt u controleren of de site zich in de onderhoudsmodus bevindt of niet voordat het daadwerkelijke antwoord wordt geretourneerd. In dat geval zou u een preAction kunnen gebruiken, zodat de gebruiker wordt omgeleid naar de onderhoudspagina als deze is ingeschakeld.
We voegen ook toe common / seo_url als een preActie ook, want in het geval van een SEO-enabled site willen we de corresponderende routevariabelen ophalen voordat de daadwerkelijke dispatching begint.
Laten we verdergaan naar het volgende belangrijke fragment.
// Router if (isset ($ request-> get ['route'])) $ action = new Action ($ request-> get ['route']); else $ action = new Action ('common / home'); Het controleert de aanwezigheid van de stringvariabele "route" -vraag en als die er is, maken we een exemplaar van de Actie klasse door de huidige "route" -waarde door te geven als een constructorargument. Als dit niet aanwezig is, doen we hetzelfde met de route URI op de startpagina-common / huis.
Met onze $ actie variabele ingesteld met de juiste waarde, laten we verdergaan naar het volgende fragment.
// Dispatch $ controller-> dispatch ($ action, new Action ('error / not_found'));Ten slotte noemen we het verzending methode van de klasse van de voorste controller. Ga je gang en open system / motor / front.php en zoek het volgende fragment.
openbare functie verzending ($ actie, $ fout) $ dit-> fout = $ fout; foreach ($ this-> pre_action als $ pre_action) $ result = $ this-> execute ($ pre_action); if ($ resultaat) $ action = $ resultaat; breken; while ($ actie) $ action = $ this-> execute ($ action);
Dit is de methode waarbij alle magie gebeurt! Eerst voert het alle "preActions" uit zoals eerder besproken. Verder zal het in de while-lus proberen onze huidige uit te voeren $ actie, geslaagd als een argument van de uitvoeren methode.
Laten we de definitie van de volgen uitvoeren methode in hetzelfde bestand.
private function execute ($ action) $ result = $ action-> execute ($ this-> registry); if (is_object (resultaat $)) $ action = $ result; elseif ($ result === false) $ action = $ this-> error; $ this-> error = "; else $ action = false; return $ action;
Op de allereerste regel, de uitvoeren methode van de Actie klasse wordt genoemd. Verwar het niet met de uitvoeren methode van de klasse Frontcontroller. Open het bestand system / motor / action.php en hier is het.
public function execute ($ register) // Stop met magische methoden die worden aangeroepen if (substr ($ this-> method, 0, 2) == '__') return false; if (is_file ($ dit-> bestand)) include_once ($ this-> bestand); $ class = $ this-> class; $ controller = nieuwe $ klasse ($ register); if (is_callable (array ($ controller, $ this-> method))) return call_user_func (array ($ controller, $ this-> method), $ this-> args); else return false; else return false;
Het belangrijkste om op te merken is dat het Actie klasse stelt al de vereiste variabelen in de constructor zelf in wanneer het actieobject wordt geïnstantieerd index.php. Het maakt de het dossier, klasse en methode eigenschappen, die zullen worden gebruikt in de uitvoeren methode. Om de zaken minder ingewikkeld te houden, bespreken we alleen de uitvoeren methode, hoewel ik zou aanraden dat je de constructor van de Actie klasse.
Terug naar onze uitvoeren methode van de Actie klasse, controleert het de aanwezigheid van het bestand ($ This-> file) die is gekoppeld aan de huidige route. Als alles in orde is, bevat het dat bestand en roept het de bijbehorende methode op ($ This-> methode) van die controllerklasse met behulp van de call_user_func functie en geeft het antwoord terug.
Als het bijbehorende bestand niet beschikbaar is, zal het terugkeren vals. Laten we nu teruggaan naar het fragment van de uitvoeren methode van de klasse Frontcontroller. Heb geduld, we zijn er bijna!
... $ result = $ action-> execute ($ this-> registry); if (is_object (resultaat $)) $ action = $ result; elseif ($ result === false) $ action = $ this-> error; $ this-> error = "; else $ action = false; return $ action; ...
Zodra de methode execute van de Actie klasse voltooit het proces, retourneert het resultaat en het is toegewezen aan de $ result variabel. Nu zijn er drie verschillende mogelijkheden met de opgeslagen waarde $ result. Laten we ze allemaal onderzoeken.
Als alles goed is gegaan, hebben we HTML-uitvoer in de $ result variabel, dus de $ actie variabele is ingesteld op vals en het proces eindigt. Het is de laatste andere zaak.
Bedenk dat we terugkwamen vals als het overeenkomstige controllerdossier niet werd gevonden in de uitvoeren methode van de Actie klasse. In dat geval, de $ actie variabele wordt ingesteld op $ This-> error (fout niet gevonden Actie) en "pagina niet gevonden" wordt getoond aan de gebruiker.
En tot slot, als we vinden dat de $ result is een object zelf, we zullen het instellen op de $ actie variabel. Ja, dat is raar: waarom zou de controller-methode op aarde een andere versie retourneren? Actie object, wanneer het de HTML-uitvoer voor de gevraagde pagina moet retourneren? Maar dat is slechts een van de manieren waarop de controller gebruikers doorstuurt naar een andere URL.
Laten we snel de catalogus / controller / common / maintenance.php bestand en zie het in actie. In de inhoudsopgave methode, het geeft het Actie object als bepaalde voorwaarden waar zijn.
... if (($ route! = 'Payment' && $ route! = 'Api') &&! $ This-> user-> isLogged ()) return new Action ('common / maintenance / info'); ... Dus, zoals je kunt zien, retourneert het de Actie object om de gebruiker om te leiden naar de common / onderhoud / info URL. Natuurlijk is er een code in de verzending methode van de klasse frontcontroller om dit gedrag aan te pakken. Roep het fragment van die methode op - ik beloof dat het het laatste fragment van deze zelfstudie is.
... while ($ action) $ action = $ this-> execute ($ action); ...
Dus het is een while-lus, en het loopt totdat het de $ actie variabele ingesteld op vals! Meer specifiek, het beëindigt de lus wanneer we nuttige uitvoer voor onze gebruiker hebben.
Dus dat is het einde van de reis. Ik hoop dat het niet zo ingewikkeld was als op het eerste gezicht leek.
Vandaag hebben we een belangrijk aspect van het OpenCart-raamwerk doorlopen - het dispatchingproces. We begrepen de basis van dispatching en ondernamen de volledige stroom om te begrijpen hoe het werkt.
Als u op zoek bent naar aanvullende OpenCart-hulpmiddelen, hulpprogramma's, uitbreidingen en dergelijke die u kunt gebruiken in uw eigen projecten of voor uw eigen opleiding, vergeet dan niet te zien wat we beschikbaar hebben op de markt.
Voor eventuele vragen, aarzel niet om uw opmerkingen achter te laten. Twitter is ook een andere mogelijkheid om contact met me op te nemen en ik reageer snel.
