autoloader
Ik ga een autoloader maken die automatisch classes inlaadt. Nu wil ik gaan werken met een library met classes, maar naast die library wil ik ook gaan werken met "modules" die een eigen controller en model hebben. Behalve de classes uit de library hebben we dus ook controllers en models.
Nu vraag ik me af of het wijs/handig is om de models en controllers ook via de autoloader te laden. Stel we hebben een class "Product", en een bijbehorende module Product met daarin een ProductController en een ProductModel. Stel dat ik dan een nieuwe ProductController nodig heb, dan zou ik kunnen zeggen:
$product_controller = new ProductController();
De autoloader ziet nu dat de class-naam eindigt op "Controller" en weet dus dat het de bedoeling is om een controller in te laden.
Het feit is echter wel dat in 1 page request misschien wel tientallen classes moeten worden ingeladen, maar slechts enkele controllers/models.
Door nu telkens te controleren of de clas-naam eindigt op "Controller" of "Model" (wat in 90% van de gevallen niet zo zal zijn) vertraag ik de boel dus behoorlijk.
Nu is mijn vraag, is er een hele slimme/snelle manier om te controleren of de class-naam eindigt op "Controller" of "Model", of wordt dat sowieso een kwestie van substrings vergelijken? En mijn 2e vraag, zou het beter zijn om de controllers en models via een method in te laden in plaats van via de autoloader, zoiets als:
$product_model = $this->loadModel('Product');
Reacties zijn welkom!
Gewijzigd op 05/10/2013 00:34:03 door Ozzie PHP
Daarnaast kijk eens naar PSR-0 en PSR-4, die bevatten wel mooie richtlijnen voor het schrijven van een autoloader. En ja, ALTIJD autoloader gebruiken.
thanks!
Ozzie PHP op 05/10/2013 00:31:10:
Nu vraag ik me af of het wijs/handig is om de models en controllers ook via de autoloader te laden. Stel we hebben een class "Product", en een bijbehorende module Product met daarin een ProductController en een ProductModel. Stel dat ik dan een nieuwe ProductController nodig heb, dan zou ik kunnen zeggen:
$product_controller = new ProductController();
De autoloader ziet nu dat de class-naam eindigt op "Controller" en weet dus dat het de bedoeling is om een controller in te laden.
$product_controller = new ProductController();
De autoloader ziet nu dat de class-naam eindigt op "Controller" en weet dus dat het de bedoeling is om een controller in te laden.
De autoloader hoeft niets te "zien" of te "weten", maar laadt gewoon automatisch Product.php of ProductController.php of ProductModel.php zodra je één van de klassen gebruikt. Het hele eiereneten bij een autoloader is juist dat je niet eerst van alles gaat zitten laden, maar pas iets laadt wanneer het nodig is.
Ik gebruik zelf inderdaad de autoloader uit PSR-0 met een kleine aanpassing. Dan moet je echter ook wel kiezen voor namespaces.
Hoeft niet, ook de PEAR methoden worden nog ondersteund.
Maar je hebt verder wel gelijk: ik vind dat je anno 2013 namespaces moet gebruiken, dus dat is zeker een waardeoordeel.
Ward van der Put op 05/10/2013 11:10:09:
De autoloader hoeft niets te "zien" of te "weten", maar laadt gewoon automatisch Product.php of ProductController.php of ProductModel.php zodra je één van de klassen gebruikt. Het hele eiereneten bij een autoloader is juist dat je niet eerst van alles gaat zitten laden, maar pas iets laadt wanneer het nodig is.
Ward, ik snap niet precies wat je hiermee wilt zeggen. Een autoloader treedt pas in werking op het moment dat er een class wordt aangeroepen die nog niet is ingeladen. Ik ga toch niet "van alles zitten laden"? Ik denk dat je me niet helemaal correct begrepen hebt.
Ik heb vroeger wel eens gewerkt met Zend Framework 1 en ik vind de manier van class benamingen (met underscores) wel fijn. Die namespacing dat bevalt me op de een of andere manier niet en dus hou ik het graag bij de "oude" manier. De autoloader weet aan de hand van een class-naam welk bestand hij moet inladen. En daar ging mijn vraag dus over. 95% van de classes die ik zal inladen zal een normale library class zijn. 5% zal een controller of model zijn (deze staan in een andere directory dan de library classes). Als ik controllers en models ook via de autoloader inlaadt, dan betekent dit dat er in 95% van de gevallen onnodig zal worden gecontroleerd of het om een controller of model gaat. Is dat wel slim is mijn vraag. Of moet ik de controllers en models via een aparte functie aanroepen (en dus niet via de autoloader). Dat is mijn vraag.
Gewijzigd op 05/10/2013 15:52:40 door Ozzie PHP
Symfony doet het ook: https://github.com/symfony/symfony/blob/master/src/Symfony/Component/ClassLoader/UniversalClassLoader.php#L295
Op die manier geldt dat "onnodig controleren" ook niet echt, aangezien hij al meteen na de if statement afkapt
Edit: en als antwoord, one autoloader to rule them all...
Gewijzigd op 05/10/2013 16:24:19 door NOLot -
Stel ik heb een fictieve class, een xml loader. Bij mij zou die dan in de library komen te staan in de directory "xml". zoiets als dit:
/library/xml/loader.php
De class-naam zou dan zijn xml_loader. Als ik de xml loader zou nodig hebben, dan doe ik dit:
$xml_loader = new xml_loader();
Aangezien de class nog niet is geladen, wordt de autoload functie geactiveerd. Aan de hand van de class-naam "xml_loader" gaat deze automatisch het juiste bestand "/library/xml/loader.php" inladen.
Zo is hoe ik het nu ongeveer doe.
Waarom moet de autoloader dan controleren om welke type klasse het gaat? Dat is niet de taak van de autoloader: andere klassen bepalen welke klassen zij nodig hebben, de autoloader laadt ze vervolgens alleen maar.
Ozzie PHP op 05/10/2013 16:29:18:
NOLot, thanks... maar ik ben niet gewend met namespaces te werken, en ik snap het principe ook niet zo goed.
Stel ik heb een fictieve class, een xml loader. Bij mij zou die dan in de library komen te staan in de directory "xml". zoiets als dit:
/library/xml/loader.php
De class-naam zou dan zijn xml_loader. Als ik de xml loader zou nodig hebben, dan doe ik dit:
$xml_loader = new xml_loader();
Aangezien de class nog niet is geladen, wordt de autoload functie geactiveerd. Aan de hand van de class-naam "xml_loader" gaat deze automatisch het juiste bestand "/library/xml/loader.php" inladen.
Zo is hoe ik het nu ongeveer doe.
Stel ik heb een fictieve class, een xml loader. Bij mij zou die dan in de library komen te staan in de directory "xml". zoiets als dit:
/library/xml/loader.php
De class-naam zou dan zijn xml_loader. Als ik de xml loader zou nodig hebben, dan doe ik dit:
$xml_loader = new xml_loader();
Aangezien de class nog niet is geladen, wordt de autoload functie geactiveerd. Aan de hand van de class-naam "xml_loader" gaat deze automatisch het juiste bestand "/library/xml/loader.php" inladen.
Zo is hoe ik het nu ongeveer doe.
Dat voorbeeld ging niet over namespaces, maar classes met underscore.
Als jij je classes xml_loader noemt dan wordt het wel even zoeken ja voor de autoloader. Vooral als je dan ook je controllers home_indexcontroller noemt. Maar uiteindelijk is een autoloader altijd beter dan geen autoloader
Dit is geheel duidelijk.
"Waarom moet de autoloader dan controleren om welke type klasse het gaat?"
Hij moet dat weten, omdat een model of controller in een andere map dan de library staat. Hij moet dus een ander pad aanroepen.
"Standaard" classes staan in de map library, maar een model staat in map foo, en een controller in map bar. De autoloader moet dus (aan de hand van de class-naam) weten waar hij het bestand moet zoeken. Is het zo duidelijker wat ik bedoel?
Toevoeging op 05/10/2013 16:46:07:
"Als jij je classes xml_loader noemt dan wordt het wel even zoeken ja voor de autoloader."
Nee, juist niet. Het geeft precies aan waar hij moet zoeken.
OzzieCore_Product_Controller == /OzzieCore/Product/Controller.php
OzzieCore_Product_Model == /OzzieCore/Product/Model.php
Het is twee handen op één buik. Het werkt als je geen namespaces gebruikt. En het blijft werken als je alsnog namespaces gaat gebruiken. Het werkt zelfs in een gemengde omgeving, als je iets van een ander inhaakt op je eigen project.
OzzieCore_Product_Controller == /OzzieCore/Product/Controller.php
Is "OzzieCore_Product_Controller" de class-naam? En wat is het verschil met namespacing en hoe ik het nu doe?
Ozzie PHP op 05/10/2013 16:42:39:
"Als jij je classes xml_loader noemt dan wordt het wel even zoeken ja voor de autoloader."
Nee, juist niet. Het geeft precies aan waar hij moet zoeken.
Nee, juist niet. Het geeft precies aan waar hij moet zoeken.
Nee juist niet :) Omdat jij geen namespaces gebruikt zul je dus je classes moeten prefixen met library_xml_loader en controller_home_indexcontroller als je niet wilt dat je autoloader nutteloos directories door gaat zoeken
NOLot - op 05/10/2013 17:12:42:
Omdat jij geen namespaces gebruikt zul je dus je classes moeten prefixen met library_xml_loader en controller_home_indexcontroller als je niet wilt dat je autoloader nutteloos directories door gaat zoeken
Je hoeft geen include_path te gebruiken. Je kunt de autoloader ook direct op een specifiek bestand afsturen. Alleen... dat werkt veel makkelijker als je een namespace-achtige directorystructuur gebruikt. Dan kun je de underscore _ vervangen door de constante DIRECTORY_SEPARATOR.
Mijn autoloader ziet er als volgt uit. PSR-0 met twee kleine extra's.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?php
/**
* AutoLoader
*
* Load by vendor\class or by namespace\class:
*
* autoload('StoreCore_Database');
*
* Load by namespace\package\class, by vendor\package\class,
* or by package\subpackage\class:
*
* autoload('StoreCore_Payments_iDEAL');
*
* @author Ward van der Put <[email protected]>
* @link https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md
* @param string $classname
* @return void
* @version 1.0
*/
function autoload($classname)
{
$classname = ltrim($classname, '\\');
$filename = '';
$namespace = '';
if ($last_namespace_position = strrpos($classname, '\\')) {
$namespace = substr($classname, 0, $last_namespace_position);
$classname = substr($classname, $last_namespace_position + 1);
$filename = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
}
$filename .= str_replace('_', DIRECTORY_SEPARATOR, $classname) . '.php';
/**
* De volgende aanvulling op het voorbeeld van de functie autoload() uit
* PSR-0 maakt het pad naar het bestand met een klasse absoluut in plaats
* van relatief. Dit verkort de laadtijd.
*/
$filename = __DIR__ . DIRECTORY_SEPARATOR . $filename;
require $filename;
}
/** Register the autoloader */
spl_autoload_register('autoload');
?>
/**
* AutoLoader
*
* Load by vendor\class or by namespace\class:
*
* autoload('StoreCore_Database');
*
* Load by namespace\package\class, by vendor\package\class,
* or by package\subpackage\class:
*
* autoload('StoreCore_Payments_iDEAL');
*
* @author Ward van der Put <[email protected]>
* @link https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md
* @param string $classname
* @return void
* @version 1.0
*/
function autoload($classname)
{
$classname = ltrim($classname, '\\');
$filename = '';
$namespace = '';
if ($last_namespace_position = strrpos($classname, '\\')) {
$namespace = substr($classname, 0, $last_namespace_position);
$classname = substr($classname, $last_namespace_position + 1);
$filename = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) . DIRECTORY_SEPARATOR;
}
$filename .= str_replace('_', DIRECTORY_SEPARATOR, $classname) . '.php';
/**
* De volgende aanvulling op het voorbeeld van de functie autoload() uit
* PSR-0 maakt het pad naar het bestand met een klasse absoluut in plaats
* van relatief. Dit verkort de laadtijd.
*/
$filename = __DIR__ . DIRECTORY_SEPARATOR . $filename;
require $filename;
}
/** Register the autoloader */
spl_autoload_register('autoload');
?>
Gewijzigd op 05/10/2013 17:20:06 door Ward van der Put
Ah, nu begrijp je me! :)
Ja, daar heb je gelijk in. Mijn idee was dus... alle classes staan in de library, dus hoef ik de class-naam niet te prefixen met library. Echter, als ik dus ook models en controllers ga gebruiken die in een andere directory staan wordt het een ander verhaal... Dan zou ik zoals jij zegt dit kunnen doen:
"controller_home_indexcontroller"
Of... ik laat de class-naam eindigen op "controller".
"home_indexcontroller"
Ik controleer dan of de class-naam eindigt op "controller" (of op "model") en zo ja, dan weet ik dat ik niet de library directory moet gebruiken, maar de model of controller directory. Maar dit kost dus wel telkens 2 extra controles, namelijk "eindigt de class-naam op model, zo nee... eindigt de class-naam op controller, zo nee... aha, dan ben ik dus een library class".
Ik ben in ieder geval blij dat jij nu precies begrijpt wat ik bedoel.
Is er dan een manier waarop namespaces me gaan helpen? En zo ja... kun je een klein voorbeeldje geven, zodat ik het principe snap?
@Ward:
Thanks, maar ik snap het principe van die namespaces nog niet. Wat is nou eigenlijk een namespace, en wat is het voordeel ten opzichte van hoe ik het nu doe (via de oude manier)?
Dan kun je dus 2 dingen doen: Een autoloader voor je library maken en een autoloader voor je project klassen. dit kan best.
Of je zorgt ervoor dat de autoloader deze al uit zichzelf uit elkaar houdt doordat je ze prefixed met een zogenaamde 'vendor' naam. Bijv. library_xml_reader en ozzie_xml_reader. De eerste zou worden gezocht in library/xml/reader.php en de andere in ozzie/xml/reader.php
Merk overigens op dat xml_reader ook al een namespace is.
Offtopic:
Ward, de PSR-0 namespaces waren eerst de PEAR autoloading, dus Ozzie_Xml_Reader -> Ozzie/Xml/Reader.php De PSR-0 namespaces zijn later aangepast, toen PHP5.3 namespaces ging ondersteunen: Ozzie\Xml\Reader -> Ozzie/Xml/Reader.php
PSR-4 is nu bijna officieel en daarin gaat het nog een stapje verder, door te doen wat de composer autoloader doet: Werken met package en vendor namen. Stel je hebt een pagina "config" met de vendor "ozzie" dan wordt een klasse Ozzie\Config\Xml\Reader.php gezocht in ozzie-config/Xml/Reader.php
"Of je zorgt ervoor dat de autoloader deze al uit zichzelf uit elkaar houdt doordat je ze prefixed met een zogenaamde 'vendor' naam. Bijv. library_xml_reader en ozzie_xml_reader."
Maar dit betekent simpelweg dat ik mijn class dus niet xml_reader noem, maar library_xml_reader?
Dus:
$xml_reader = new library_xml_reader();
Zo bedoel je? (en is dit dan wat je noemt namespacing?)
Ozzie PHP op 05/10/2013 17:24:33:
@NOLot:
Ah, nu begrijp je me! :)
Ja, daar heb je gelijk in. Mijn idee was dus... alle classes staan in de library, dus hoef ik de class-naam niet te prefixen met library. Echter, als ik dus ook models en controllers ga gebruiken die in een andere directory staan wordt het een ander verhaal... Dan zou ik zoals jij zegt dit kunnen doen:
"controller_home_indexcontroller"
Of... ik laat de class-naam eindigen op "controller".
"home_indexcontroller"
Ik controleer dan of de class-naam eindigt op "controller" (of op "model") en zo ja, dan weet ik dat ik niet de library directory moet gebruiken, maar de model of controller directory. Maar dit kost dus wel telkens 2 extra controles, namelijk "eindigt de class-naam op model, zo nee... eindigt de class-naam op controller, zo nee... aha, dan ben ik dus een library class".
Ik ben in ieder geval blij dat jij nu precies begrijpt wat ik bedoel.
Is er dan een manier waarop namespaces me gaan helpen? En zo ja... kun je een klein voorbeeldje geven, zodat ik het principe snap?
Ah, nu begrijp je me! :)
Ja, daar heb je gelijk in. Mijn idee was dus... alle classes staan in de library, dus hoef ik de class-naam niet te prefixen met library. Echter, als ik dus ook models en controllers ga gebruiken die in een andere directory staan wordt het een ander verhaal... Dan zou ik zoals jij zegt dit kunnen doen:
"controller_home_indexcontroller"
Of... ik laat de class-naam eindigen op "controller".
"home_indexcontroller"
Ik controleer dan of de class-naam eindigt op "controller" (of op "model") en zo ja, dan weet ik dat ik niet de library directory moet gebruiken, maar de model of controller directory. Maar dit kost dus wel telkens 2 extra controles, namelijk "eindigt de class-naam op model, zo nee... eindigt de class-naam op controller, zo nee... aha, dan ben ik dus een library class".
Ik ben in ieder geval blij dat jij nu precies begrijpt wat ik bedoel.
Is er dan een manier waarop namespaces me gaan helpen? En zo ja... kun je een klein voorbeeldje geven, zodat ik het principe snap?
Ik begreep de hele tijd al wat je bedoelde, echter vraag je iets te veel en probeer je iets te weinig naar mijn mening.
De fix die je doet is het toevoegen van de namespace Model, Controller en Library. OF je prefixt al je classes met model_core_user, controller_home_homecontroller, library_xml_loader. Namespaces is nieuwer, beter en duidelijker, dus ik zou voor die optie gaan. Dan heb je die 3 folders, Model, Controller en Library. Je autoloader stop je dan in dezelfde directory als die 3 folders, met dit erin
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
spl_autoload_register(function($clazz) {
$file = __DIR__ . DIRECTORY_SEPARATOR . str_replace('\\', DIRECTORY_SEPARATOR, $clazz) .'.php';
if (file_exists($file))
require $file;
});?>
spl_autoload_register(function($clazz) {
$file = __DIR__ . DIRECTORY_SEPARATOR . str_replace('\\', DIRECTORY_SEPARATOR, $clazz) .'.php';
if (file_exists($file))
require $file;
});?>
En klaar, al je files worden autoloaded zonder enige vorm van "opzoeken".
Natuurlijk wil je later je folders op een andere plek neerzetten, dat is het moment dat je namespace => directory array's wil toevoegen, en een autoloader class wil maken. Maar zorg eerst dat je de basis begrijpt
Gewijzigd op 05/10/2013 17:37:31 door NOLot -