Symfony componenten los van elkaar gebruiken
De bedoeling daarvan is dat je die components los van elkaar zou kunnen gebruiken. Toch lijkt me dit moeilijk, want bijvoorbeeld in de Authentication component wordt heel veel gebruik gemaakt van de Http component. En bijvoorbeeld in de Form component, wordt voor een groot deel de PropertyAccess component gebruikt.
Hoe wordt dit eigenlijk opgelost?
Ik begreep wel dat er een paar basiscomponents zijn, die je altijd nodig hebt.
Maar hoe wordt er dus voor gezorgd dat de code vrijwel los van elkaar kan draaien? Dit is namelijk een van de dingen waar ik altijd moeite mee heb als ik een class design bedenk.
En bijvoorbeeld bij Authentication, daar wordt weer de routing door beïnvloed, dan moet er dus weer een verband zijn met de Routing component.
Schrijven jullie ook graag code in componenten (of module achtig) zodat je die stukken apart kunt gebruiken? En hebben jullie tips hoe je op die manier je class design kunt opstellen? Vanaf het moment dat ik OO programmeer, is het indelen van klassen en design patterns voor mij juist de kunst.
Gewijzigd op 15/02/2016 16:53:48 door Jan terhuijzen
Zo heeft de Form component bijvoorbeeld altijd de PropertyAccess component nodig (zoals jij al aangeeft). Maar de Form component heeft niet per definitie de HttpFoundation component nodig (je kan ook gewoon $_POST en $_GET gebruiken). Ook is het zo dat je de PropertyAccess component wel weer volledig los kan gebruiken.
Voor heel veel components is de dependency tussen de twee voorkomen door [adapters](https://www.phphulp.nl/php/forum/topic/dicht-timmeren/83005/2/#591034) te gebruiken. Zo gebruikt de Form component bijvoorbeeld een NativeRequestHandler, welke gebruik maakt van $_POST en $_GET. Maar het biedt ook de mogelijkheid om een HttpFoundationRequestHandler te gebruiken (welke de classes uit de HttpFoundation component gebruikt).
Voor Security is hier mee om gegaan door deze op te splitsen in Core en Http. Core is het land waar alles gebeurd, waar alle logica plaats vind. Http is een klein laagje tussen HTTP wereld (je browser) en Core.
Deze manier van werken wordt vaak getypeerd door "Domain Driven Development". Hierin staat het domein (het onderwerp) centraal. Je maakt hierdoor een grote kern met alle logica, welke volledig los staat van zijn implementatie. De implementatie is dan slechts een klein laagje tussen de buitenwereld en je domain layer.
Als voorbeeld, stel dat je een website maakt voor een luchtvaartmaatschappij. Hierin is de "vlucht" het centrale onderwerp, je domein. Deze staat centraal en je maakt classes die vluchten kunnen boeken, volgen, etc.
Vervolgens wil je dat het boeken via een formulier op een website gebeurd. Dat is een implementatie. Deze zit dus in het implementatie layer en zou er bijv. zo uit zien:
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
class BookingFormHandler
{
public function handle(Request $request)
{
$user = $this->getCurrentUser();
// haal waardes op uit het formulier
$flightId = $request->request->get('flight_id');
$numberOfSeats = $request->request->get('seats');
// onze FlightBooker class staat nu volledig los van het formulier
// of iets van HTTP land. We kunnen deze net zo goed vanuit een test
// aanroepen, vanaf de command line, etc.
$this->flightBooker->book($flightId, $numberOfSeats);
}
}
?>
class BookingFormHandler
{
public function handle(Request $request)
{
$user = $this->getCurrentUser();
// haal waardes op uit het formulier
$flightId = $request->request->get('flight_id');
$numberOfSeats = $request->request->get('seats');
// onze FlightBooker class staat nu volledig los van het formulier
// of iets van HTTP land. We kunnen deze net zo goed vanuit een test
// aanroepen, vanaf de command line, etc.
$this->flightBooker->book($flightId, $numberOfSeats);
}
}
?>
Over dit onderwerp is enorm veel geschreven en gesproken op het internet.
Wouter J op 15/02/2016 20:32:14:
Over dit onderwerp is enorm veel geschreven en gesproken op het internet.
Goed om je hier weer te zien Wouter. Dit onderwerp houdt mij ook wel bezig. Het blijkt best lastig te zijn om herbruikbare code te schrijven. Mocht je een lijstje met "handvaten" weten zou je dan hier een linkje willen achterlaten?
Blogs van hun: http://verraes.net/ en http://php-and-symfony.matthiasnoback.nl/
Verder ook interessant op dit gebied, maar wel wat meer naar Symfony gefocused: http://williamdurand.fr/2013/08/07/ddd-with-symfony2-folder-structure-and-code-first/
De grondlegger van DDD is Eric Evans en zijn "blue book" genaamd "Domain Driven Design, tackling complexity in the heart of software". Deze heb ik nooit gelezen, maar schijnt goed te zijn.