classes organiseren
Ik ben benieuwd hoe "ver" jullie gaan met het organiseren van jullie eigen classes. Ik probeer het duidelijk te maken met een voorbeeld. Stel, ik heb een kernel class, een session class en en product class. Als ik deze classes zou organiseren, dan zou ik zoiets doen:
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
library/
core/
kernel.php
storage/
session.php
shop/
product
/product.php
core/
kernel.php
storage/
session.php
shop/
product
/product.php
En als je dit (een heel klein beetje) zou uitbreiden, krijg je bijvoorbeeld zoiets:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
library/
core/
kernel.php
storage/
cookie.php
session.php
shop/
product/
categories.php
overview.php
product.php
core/
kernel.php
storage/
cookie.php
session.php
shop/
product/
categories.php
overview.php
product.php
Zoals je ziet zijn er in dit voorbeeld 2 hoofdgroepen, namelijk "core" en "shop". In de praktijk zijn het er natuurlijk veel meer, maar het gaat even om de gedachte. Ik vraag me af of jullie dit ook doen. En met "dit" bedoel ik dat je overkoepelende secties maakt, waarin classes staan die bij elkaar horen. In dit geval dus de "core" section en de "shop" section. Is dit wel of niet een goede gewoonte? Je zou ook de overkoepelende secties kunnen weglaten, en dan krijg je dit:
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
library/
kernel.php
storage/
cookie.php
session.php
product/
categories.php
overview.php
product.php
kernel.php
storage/
cookie.php
session.php
product/
categories.php
overview.php
product.php
Ik ben benieuwd wat jullie voorkeur heeft. Wel of geen overkoepelende secties gebruiken?
Gewijzigd op 06/10/2013 18:04:44 door Ozzie PHP
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
library/
login_succes/ (Members gedeelte)
boek_toevoegen.php
account_wijzigen.php
admin/
leden_beheer.php
boeken_overzicht.php
login_succes/ (Members gedeelte)
boek_toevoegen.php
account_wijzigen.php
admin/
leden_beheer.php
boeken_overzicht.php
Verder zou ik product enzo in een Entity namespace plaatsen. En het is altijd verstandig als je een vendor naam toevoegt als eerste namespace, bijv. Ozzie.
Offtopic:
Frank, dat heeft volgens mij niks met klassen te maken
"Verder zou ik product enzo in een Entity namespace plaatsen."
Wat bedoel je daarmee? Wat is een Entity namespace?
"En het is altijd verstandig als je een vendor naam toevoegt als eerste namespace, bijv. Ozzie."
Die voeg ik in de classes wel toe, maar jij bedoelt dat ik die in de library ook zou moeten opnemen? Zo bedoel je "/library/Ozzie/Core/Storage/Session.php"?
Quote:
Wat bedoel je daarmee? Wat is een Entity namespace?
Gewoon een namespace die entity heet. In de DB wereld (voornamelijk ORM) zijn entities klassen die data vasthouden en die naar een database gemapt worden.
Quote:
jij bedoelt dat ik die in de library ook zou moeten opnemen? Zo bedoel je "/library/Ozzie/Core/Storage/Session.php"?
Exact!
Alleen krijg je met al die directories wel hele lange namespaces dan. Want voor "/library/Ozzie/Core/Storage/Session.php" zou de namespace "Ozzie/library/core/storage" worden. Da's best lang. Is dat altijd zo?
Symfony\Component\Console\Input\InputInterface
Symfony\Bundle\FrameworkBundle\Controller\Controller
Symfony\Cmf\Component\Routing\DynamicRouter
Doctrine\Commons\Persistence\ManagerRegistry
Monolog\Logger (jeeh, kleine namespace!)
Symfony\Bridge\Twig\Extension\StopwatchExtension
Wj\Shift\EventDispatcher\EventQueue
Zend\EventManager\EventManagerAwareInterface
Illuminate\Console\Application
JMS\Serializer\SerializerBuilder
Al klopt die library niet. Je hebt namespaces als Ozzie\Core\Storage\Session, die wordt dan gezocht in /library/Ozzie/Core/Storage/Session.php (aangezien je de classloader hebt geconfigureerd voor Ozzie\Core -> /library). Of, wanneer je de PSR-4 autoloader gebruikt (aan te raden) in /libraries/ozzie-core/Storage/Session.php
Gewijzigd op 06/10/2013 20:46:28 door Wouter J
Ik zit dus te denken om te beginnen met de map library, en daarin de map Ozzie. Dus:
/library/ozzie/core/storage/session.php
Jij zegt dat dan de namespace "Ozzie\Core\Storage\Session" wordt. Tot zover kan ik je nog volgen. Alleen dan moet ik voor iedere "hoofd-sectie" aangeven dat het bij de library hoort.
Is het niet logischer om dat in de namespace zelf te doen? Dus "Ozzie\Library\Core\Storage\Session". De reden waarom zal ik uitleggen. Stel dat ik een model of controller wil inladen, dan had ik bedacht om dat zo te doen:
"Ozzie\Model\Product" en "Ozzie\Controller\Product"
Het 1e stukje geeft dus aan dat het om een "Ozzie" class gaat, en het 2e stukje of het om een library bestand, of model of controller gaat. Ik weet niet hoe ik dat anders zou moeten doen namelijk.
Het 2e probleem, library zegt niet heel veel over een klasse. Het is niet een echte namespace, het is meer een map waarin je verschillende hoofd namespaces zet. Daarom zou ik die hele map niet opnemen in de autoloader.
Vervolgens, hoe gaan we ontdekken dat Ozzie\Model en Ozzie\Controller beide uit de library/Ozzie/Store map komen? Dit gaan we doen door Store op te nemen in onze namespace: Ozzie\Store\Model\Product en Ozzie\Store\Controller\Product.
Hoe gaan we dan bepalen dat Ozzie\Store en Ozzie\Core allebei in library leven (de één in library/ozzie-core/ en de andere in library/ozzie-store)? Dat doen we door de autoloader goed te configureren, zodat hij de namespaces goed kan omzetten:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
$classLoader = new ClassLoader();
$classLoader->addDefaultDirectories(array('library', 'vendor'));
$classLoader->addPackage('ozzie-core', 'Ozzie\Core');
$classLoader->addPackage('ozzie-store', 'Ozzie\Store');
$classLoader->addPackage('doctrine-orm, 'Doctrine\ORM');
$classLoader->register();
new Ozzie\Core\Storage\Session(); // library/ozzie-core/Storage/Session.php
new Ozzie\Store\Model\Product(); // library/ozzie-store/Model/Product.php
new Doctrine\ORM\ManagerRegistry(); // vendor/doctrine-orm/ManagerRegistry.php
?>
$classLoader = new ClassLoader();
$classLoader->addDefaultDirectories(array('library', 'vendor'));
$classLoader->addPackage('ozzie-core', 'Ozzie\Core');
$classLoader->addPackage('ozzie-store', 'Ozzie\Store');
$classLoader->addPackage('doctrine-orm, 'Doctrine\ORM');
$classLoader->register();
new Ozzie\Core\Storage\Session(); // library/ozzie-core/Storage/Session.php
new Ozzie\Store\Model\Product(); // library/ozzie-store/Model/Product.php
new Doctrine\ORM\ManagerRegistry(); // vendor/doctrine-orm/ManagerRegistry.php
?>
Ik snap wel steeds beter wat je bedoelt, maar ik blijf het nog even lastig vinden om het op een voor mij logische manier te implementeren.
Ik was van plan om met een soort modules te gaan werken. Idee was dan om alle algemene classes in de library te zetten, en de modules in een module directory. En dan zou je bijvoorbeeld een module productoverview krijgen. /modules/shop/productoverview/ en hierin zou je dan een controller en een model hebben, die gebruik maken van de product class uit de library.
Pfff... ik moet het ff laten bezinken :(
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
// modules/ozzie-product-overview/Controller/DefaultController.php
namespace Ozzie\ProductOverview\Controller;
use Ozzie\Store\Model\Product as ProductModel;
class DefaultController
{
public function indexAction()
{
$productModel = new ProductModel();
$products = $productModel->getMostRecent(10);
// ... parse template/view
}
}
?>
// modules/ozzie-product-overview/Controller/DefaultController.php
namespace Ozzie\ProductOverview\Controller;
use Ozzie\Store\Model\Product as ProductModel;
class DefaultController
{
public function indexAction()
{
$productModel = new ProductModel();
$products = $productModel->getMostRecent(10);
// ... parse template/view
}
}
?>
Autoloader:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
// ...
$classLoader->addDefaultDirectory('modules');
$classLoader->addPackage('ozzie-product-overview', 'Ozzie\ProductOverview');
?>
// ...
$classLoader->addDefaultDirectory('modules');
$classLoader->addPackage('ozzie-product-overview', 'Ozzie\ProductOverview');
?>
Gewijzigd op 06/10/2013 22:11:59 door Wouter J
Even terugkomend op wat ik zou willen... ik wil dus een algemene library en modules. In zo'n module (dus niet in de library) wil ik dan de controller en het model zetten.
Het adden van een package... dat doe je toch helemaal in het begin? (niet pas op het moment dat je 'm nodig hebt?)
Maar als je het op deze manier doet, dan moet je dus telkens iedere module gaan toevoegen aan de autoloader. Dan moet je straks 100 modules toevoegen. Da's toch ook niet helemaal handig :-/
Quote:
(word je niet moe van al mijn vragen?).
enof ik moe wordt, waarom denk je dat ik om de 5 reacties weer een irritante reactie plaats? :)
Quote:
Het adden van een package... dat doe je toch helemaal in het begin? (niet pas op het moment dat je 'm nodig hebt?)
Klopt, je hebt een bootstrap file (of noem hem wat mij part autoload.php) waarin je de autoloader configured. Het ging mij er alleen even om zodat je zag how to configurate these.
Quote:
Dan moet je straks 100 modules toevoegen. Da's toch ook niet helemaal handig :-/
Die package downloaden als zip en plakken in je project is toch ook helemaal niet handig? Welkom bij Composer, de tool die ervoor zorgt dat je met 1 command (namelijk composer update) alle nieuwe versies van je modules binnen krijgt en de tool die er voor zorgt dat alle modules automatisch geautoload kunnen worden.
Leer meer door te zoeken op php composer en mijn blogpost te lezen: http://wouterj.nl/2012/07/php/werken-met-composer/
Ik hoef geen pakketten te kunnen toevoegen. Allemaal veel te ingewikkeld.
Laat ik een ander voorbeeld geven. Ik wil op een pagina 4 artikelen (nieuwsberichten) tonen. Wat mijn idee nu is... in mijn Ozzie library staat een algemene article class (overal waar ik een article nodig heb, wil ik dan deze class gebruiken). Oké, dus die algemene classes staan in de Ozzie library. Nu wil ik dus ook een Ozzie's modules directory maken. Hierin staan modules. En het idee is dat ik dan op een pagina een module kan aanroepen, in dit geval de ShowArticles module. Nu had ik dus het idee dat in de ShowArticles module een controller moet komen te staan en een Model. De ShowArticles module maakt dan gebruik van de algemen Article class uit de Ozzie library. Kun je het tot zover nog volgen? :-s Ik hoop het :)
Nu kan ik me voorstellen dat ik ook een keer een PDF wil kunnen genereren. De library die hier voor nodig is wil ik dan in de library directory zetten "naast" de Ozzie library.
Ik hoef verder geen packages te kunnen importeren en dat soort trucs :)
Hoe kan ik dan het beste mijn directorystructuur en namespaces maken? (die autoloader die fix ik dan wel, maar het gaat er me vooral wat een juiste directorystructuur is en hoe ik dan het beste de namespacing kan doen).
Wouter J op 06/10/2013 22:25:06:
enof ik moe wordt, waarom denk je dat ik om de 5 reacties weer een irritante reactie plaats? :)
Hehe... ik kan het me voorstellen hoor :) Af en toe ben ik gruwelijk irritant :)))
Ozzie PHP op 06/10/2013 22:35:44:
Hoe kan ik dan het beste mijn directorystructuur en namespaces maken? (die autoloader die fix ik dan wel, maar het gaat er me vooral wat een juiste directorystructuur is en hoe ik dan het beste de namespacing kan doen).
In een ideale wereld — die niet bestaat — zou je alleen één directory (inclusief subdirectory's en bestanden) moeten kunnen vervangen zonder dat dit gevolgen heeft voor de rest. Stel dat we dit hebben:
- /core/groente/
- /core/fruit/appels/
- /core/fruit/peren/
Als we de subdirectory /peren/ updaten, mag dat geen gevolgen hebben voor de appels en ook niet voor de groenteafdeling. Wijzigen we echter de fruitafdeling in /fruit/, dan mág dat gevolgen hebben voor de appels en peren, maar nog steeds niet voor de groenteafdeling.
Willen we bananen toevoegen? Dan moet dat met /core/fruit/bananen/ kunnen, zonder dat appels en peren daarvan ook maar iets merken.
Waar het mij meer om ging/gaat is hoe ik duidelijk maak (aan de hand van de namespace) of een class in de "library" directory staat of in de "modules" directory.
Stel we hebben 2 classes:
/libraries/foo/foo.php
/modules/foo/foo.php
Ik denk dat dat alleen maar lukt door in de namespace op de een of andere manier de directory aan te geven. In dit geval zoiets:
namespace Ozzie\library\foo (of misschien OzzieLibrary\foo)
namespace Ozzie\modules\foo (of misschien OzzieModule\foo)
Wouter zegt hier echter dit over:
"Het 2e probleem, library zegt niet heel veel over een klasse. Het is niet een echte namespace, het is meer een map waarin je verschillende hoofd namespaces zet. Daarom zou ik die hele map niet opnemen in de autoloader."
Maar ik zou niet weten hoe ik het anders moet oplossen.
Toevoeging op 07/10/2013 10:30:10:
Overigens... ik wil dus modules maken zodat ik bijv. op een pagina makkelijk zoiets kan doen:
Code (php)
1
2
3
4
2
3
4
<?php
$module = $this->module->get('ShowArticles');
$module->setAmount(5); // toont 5 berichten
?>
$module = $this->module->get('ShowArticles');
$module->setAmount(5); // toont 5 berichten
?>
Nu ga ik er vanuit dat modules altijd "van jezelf" zijn (Ozzie modules zal ik maar zeggen). Er zijn toch geen 3rd party modules bijvoorbeeld? Er zijn wel 3rd part libraries, maar toch geen modules?
Quote:
Er zijn toch geen 3rd party modules bijvoorbeeld? Er zijn wel 3rd part libraries, maar toch geen modules?
Waarom niet? OO is gemaakt om rekening te houden met uitbereiding, dus ook met andere namespaces voor modules. Maak er bijv. van Ozzie\ProductOverview\Controller\DefaultController::showArticles of gebruik een speciale formaat naam, die je dan omzet. Gebruik bijv. OzzieProductOverview:Default:showArticles
Quote:
Ik hoef geen pakketten te kunnen toevoegen. Allemaal veel te ingewikkeld.
Waarom begin je meteen negatief over een onderwerp? Je vindt het eigenlijk helemaal niet ingewikkeld, maar iets in jouw zegt dat je geen goede developer bent en alles wat nieuw is ingewikkeld is. Namespaces vond je toch ook moeilijk? Kijk nou, je hebt het in 2 dagen geleerd! Dat is misschien zelfs wel sneller dan dat ik het heb geleerd.
Begin een keer positief aan een nieuwe feature en denk niet altijd te negatief over jezelf, dat komt alles echt ten goede.
Composer is de makkelijkste tool van de wereld en jij hoeft daar praktisch niks aan te begrijpen, composer doet het voor jouw. Jij vroeg om een oplossing, Composer is dé oplossing!
Quote:
Kun je het tot zover nog volgen?
Ja ik kan het volgen en nee, dit is niet goed als je het aan mij vraagt. Een bepaalde package, dus ozzie-core en ozzie-shop, implementen bepaalde features. De core zorgt voor alles wat je als basis nodig hebt om een framework te laten draaien, de shop zorgt voor de webwinkel modules en klassen. Iets als een Product hoort dus niet in een core package, maar in de shop package. Wat precies een module doet is voor mij heel erg vaag...
Vergelijk het met het inrichten van een Windows-pc. Ik zou nooit alle Word-documenten in één directory zetten en alle Excel-bestanden in een andere directory. Nee, het is veel logischer om Word- en Excel-bestanden die bij elkaar horen op te slaan onder /klant-x/project-y/. Horen daar nog video's en foto's bij? Dan gaan die niet in algemene /Video/ of /Afbeeldingen/ map. Nee, die gaan in dezelfde projectmap.
Een MVC-module Foo zou ik daarom eerder zo opslaan:
- /library/Ozzie/Foo/
- /library/Ozzie/Foo/Controller.php
- /library/Ozzie/Foo/Mapper.php
- /library/Ozzie/Foo/View.php
De autoloader kun je dan richten op een new Ozzie_Foo_Controller(), zelfs als je geen namespaces gebruikt. En gebruik je wel namespaces, dan blijven die lekker overzichtelijk en goed gestructureerd.
Ik snap dat het enigszins vaag is... ik probeer voor mezelf namelijk ook even duidelijkheid te scheppen... Als ik die duidelijkheid eenmaal heb, dan kan ik weer vooruit.
Ik wil tzt op mijn server meerdere websites kunnen draaien. Dat kan een simpele website zijn met wat informatie, maar ook een complete webshop.
Mijn idee was dus om zoiets te doen: ik maak een (ozzie) library met daarin allerlei classes gerangschikt op onderwerp. Dus aan de ene kant heb ik een directory met classes. Aan de andere kant wil ik dan een module directory maken met modules. Deze modules maken dan gebruik van de classes uit de ozzie library. Een module is iets wat je gemakkelijk op een pagina moet kunnen aanroepen, bijvoorbeeld: ProductCategories, Agenda, (Show)Article, Login enz.
Schematisch zou je dan (heel erg grof) zoiets krijgen:
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
libraries/
ozzie/
content/
article.php
newsarticle.php
core/
alle "technische" classes, denk aan kernel, session,
formulierafhandeling, exceptions enz.
marketing/
banner.php
stats.php
shop/
product.php
productoverview.php
modules/
ozzie/
marketing/
getBanner
showStats
shop/
showProduct
showProductOverview
ozzie/
content/
article.php
newsarticle.php
core/
alle "technische" classes, denk aan kernel, session,
formulierafhandeling, exceptions enz.
marketing/
banner.php
stats.php
shop/
product.php
productoverview.php
modules/
ozzie/
marketing/
getBanner
showStats
shop/
showProduct
showProductOverview
Ik heb dus aan de ene kant een aparte library met classes, en aan de andere kant een aparte directory met modules die gebruik maken van de classes uit de library. En deze modules die wil ik dan weer in de views kunnen gebruiken.
Maar misschien is deze opzet onhandig, en moet ik alles in de library zetten?? De uiteindelijke situatie die ik in ieder geval zou willen is dat ik makkelijk een pagina kan maken. Stel je hebt bijvoorbeeld een contactpagina, dan zou ik zoiets als dit willen kunnen doen:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$module = $this->getModule('contact');
$module->showAddress();
$module->showMap();
$module->showKvK();
?>
$module = $this->getModule('contact');
$module->showAddress();
$module->showMap();
$module->showKvK();
?>
Waar het mij nu vooral om gaat is of de opzet met de "library" aan de ene kant en de "modules" aan de andere kant juist is. OF... is het bijvoorbeeld de bedoeling dat ik helemaal géén aparte "modules" directory gebruik, maar dat ik alles in de library plaats? (en zo ja, hoe... hoe zou dan mijn opzetje hierboven er ongeveer uitzien)
@Ward:
Dit is ook bijna hoe ik het zelf van plan was, met als enige uitzondering dat ik de class (bijv. Product) in de library wilde zetten, en dan wilde werken met modules (in zo'n module staat dan een controller, model en view). Dus eigenlijk zo:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
/libraries/
ozzie/
foo/
fooClass.php
/modules/
ozzie/
foo/
controller.php
model.php
view.phtml
ozzie/
foo/
fooClass.php
/modules/
ozzie/
foo/
controller.php
model.php
view.phtml
De Foo module maakt dan gebruik van de fooClass uit de library. Dat was mijn idee, maar als dit niet juist/logisch is dan hoor ik het graag!
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
/modules/
Ozzie/
Foo/
index.php
Controller.php
Model.php
View.phtml
Ozzie/
Foo/
index.php
Controller.php
Model.php
View.phtml
Met een simpele autoloader kun je hiermee een new Ozzie_Foo() aanroepen voor Ozzie/Foo/index.php en een new Ozzie_Foo_Controller() voor Ozzie/Foo/Controller.php.
Bovendien staat alles dan bij elkaar. Updaten van een Foo is updaten van één directory.