registry
Ik heb een registry class gemaakt waaruit ik settings en objecten wil kunnen halen. Nu kan ik 2 dingen doen... als ik een property aanroep dat ie dan een setting teruggeeft en als ik een method aanroep dat ie dan een object teruggeeft. Dus dan krijg je dit:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$registry = Registry::get();
$settings = $registry->my_setting; //als property aangeroepen
$object = $registry->my_object(); // als method aangeroepen
?>
$registry = Registry::get();
$settings = $registry->my_setting; //als property aangeroepen
$object = $registry->my_object(); // als method aangeroepen
?>
Ik kan het ook zo doen dat je zowel een setting als een object als property aanroept, maar dan specifiek. Bijvoorbeeld zo:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$registry = Registry::get();
$settings = $registry->setting->my_setting;
$object = $registry->object->my_object;
?>
$registry = Registry::get();
$settings = $registry->setting->my_setting;
$object = $registry->object->my_object;
?>
Ik vraag me af wat jullie mooier / handiger vinden.
Gewoon alles bij 1 methode houden? Je zet iets in het register, en je haalt iets uit het register. Wat hij retourneert? Tja, boeie daar heeft het register niets mee te maken.
Heb je al gekeken naar iets anders genaamd: 'Dependency Injection Container' ? Dan heb je in principe geen Registery meer nodig.
Niels
Gewijzigd op 16/02/2012 12:27:37 door Niels K
En dependency injection is de vervanger van het registry pattern dus je kunt je beter daarin verdiepen ;) Pim heeft daar een mooie tutorial voor.
Gewijzigd op 16/02/2012 12:33:35 door kees Schepers
Ah oke... gewoon alles op 1 manier aanroepen. Dus zo?
Code (php)
1
2
3
4
5
2
3
4
5
<?php
$registry = Registry::get();
$settings = $registry->my_setting;
$object = $registry->my_object;
?>
$registry = Registry::get();
$settings = $registry->my_setting;
$object = $registry->my_object;
?>
Code (php)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
<?php
Registry::getInstance()->get('key');
// Of de korte manier (moet je wel even zorgen dat je in de get methode de getInstance gebruikt)
Registry::get('key');
?>
Registry::getInstance()->get('key');
// Of de korte manier (moet je wel even zorgen dat je in de get methode de getInstance gebruikt)
Registry::get('key');
?>
Setten gaat dan zo:
Code (php)
1
2
3
4
5
2
3
4
5
<?php
Registry::set('key', 'value');
?>
Registry::set('key', 'value');
?>
Wat die value is maakt voor het Register niet uit.
Gewijzigd op 16/02/2012 12:48:19 door Niels K
$registry = Registry::get();
$settings = $registry->my_setting;
Die registry geeft een instance van zichzelf terug waarin de keys geset zijn.
Als ik dit doe: $registry->my_setting; dan wordt de __get() functie aangesproken en die geeft de juiste waarde terug. Waarom is dat niet goed?
Toevoeging op 16/02/2012 12:56:27:
Kees Schepers op 16/02/2012 12:53:53:
Maar Ozzie, je beseft je toch wel dat je Zend Framework opnieuw aan het bouwen bent he? :P
Hehe... nee, die kennis heb ik niet :)
Pik alleen her en der wat handigheidjes mee.
Ozzie,
Dan moet je de methode anders laten heten. Namelijk 'getInstance()'. Als jij get zegt en dan Registry. Dan denk ik dat je iets uit het register haalt.
Quote:
Hehe... nee, die kennis heb ik niet :)
Kwestie van knop omzetten, lezen en gaan?
;-)
Waarom niet gewoon Registry::get($key). Die functie zelf doet de instance uit zijn static halen en op die instance ->get.. simpel toch?
Niels Kieviet op 16/02/2012 14:34:31:
Dan moet je de methode anders laten heten. Namelijk 'getInstance()'. Als jij get zegt en dan Registry. Dan denk ik dat je iets uit het register haalt.
Ah oke... voor mij was dat wel duidelijk. $registry = Registry::get(); daar bedoel ik mee dat ik het Registry object ophaal. Voor mij heel duidelijk, maar voor een derde inderdaad misschien niet direct. Dus dat pas ik wel aan.
Ik zit nu te denken of ik het anders moet... meer op de dependency injection manier, maar ik ben daar (nog) niet heel erg in thuis. Nu had ik het als volgt bedacht. HEt is even heel globaal beschreven dus let niet op de details!
Wat vind jij van dit idee:
Ik maak een Registry class en een Service class.
In de Registry class kan ik dan allerlei settings opslaan. Een groot deel van deze settings komt uit een configuratiebestand. Die worden automatisch ingeladen. En ik kan dan ook zelf via een set en get settings opslaan. De Registry class gebruik ik dan dus alleen voor het opslaan van settings.
In de Service class kan ik dan een object injecteren (oei, hoe leg ik dit fatsoenlijk uit), bijvoorbeeld met behulp van de settings uit de registry.
Dan krijg je dus zoiets:
$database_settings = Registry::get('database');
en dan zeg ik vervolgens:
Service::set('database', $database_settings);
en als ik dan de database wil opvragen:
$database = Service::get('database');
Is dit een goed idee? Graag jullie reactie. Let vooral niet op de details. Het gaat mij vooral om dit principe: enerzijds een Registry class waar je settings in opslaat, anderzijds een Service class waar je objecten in opslaat waarbij je eventueel de settings uit de Registry class gebruikt.
Graag advies!
Toevoeging:
Je bedoeld zoiets als Zend_Resource ? ;-)
Daarnaast settings uit een bestand hoort dat niet thuis in een Config object.
Gewijzigd op 16/02/2012 14:56:51 door Niels K
Kees Schepers op 16/02/2012 14:47:08:
Waarom niet gewoon Registry::get($key). Die functie zelf doet de instance uit zijn static halen en op die instance ->get.. simpel toch?
Kees... is er eigenlijk iets op tegen om ipv Registry::get($key)het als volgt te doen:
$registry = Registry::getInstance();
$value = $registry->key;
Toevoeging op 16/02/2012 14:59:15:
Niels Kieviet op 16/02/2012 14:55:12:
Daarnaast settings uit een bestand hoort dat niet thuis in een Config object.
Kun jij me dan even in simpele bewoordingen uitleggen wat (het doel van)een Registry is?
Quote:
Kun jij me dan even in simpele bewoordingen uitleggen wat (het doel van)een Registry is?
Jazeker, een Register klasse is niet meer dan een generieke 'opslag' class voor het opslaan van globale data.
Niels Kieviet op 16/02/2012 15:11:57:
Jazeker, een Register klasse is niet meer dan een generieke 'opslag' class voor het opslaan van globale data.
Kijk, dat is nog eens heel duidelijk :)
Laat ik eerst even mijn bedoeling uitleggen. Ik heb een configuration.php bestand. Hier zet ik een aantal default instellingen in, bijvoorbeeld:
$config['database']['username'] = 'ozzie';
$config['database']['pass'] = 'php';
Alle instellingen uit het configuratiebestand wil ik inladen in een class zodat ik ze makkelijk kan oproepen. Dit zou dan een Config class kunnen zijn.
Nu wil ik ergens een database object in plaatsen dat ik overal in mijn applicatie kan benaderen. Ik had dus het idee om dit database object dan in een Registry te stoppen waarbij ik de gegevens uit de Config class gebruik.
Registry::set('database', Config::get['database']);
vervolgens kan ik dan de database ophalen met $database = Registry::get('database');
Kan iemand me even in de juiste richting sturen hoe ik dit het beste kan aanpakken. Dat zou fijn zijn. Of is de bovengenoemde manier oke? Ik hoef geen uitgewerkte code, maar ik wil even het principe weten. Dus gewoon een voorbeeldje, zoiets simpels als dit:
Registry::set('database', Config::get['database']);
$database = Registry::get('database');
Alleen dan op de juiste manier... :)
Geen probleem. Om gelijk met de deur in huis te komen. Waarom doe je de configuratie in PHP? Kan je niet kijken naar wat mooiere manieren zoals INI, XML, YML?
Wil de configuratie automatisch inladen? Dat is niet wat een configuratie object moet doen naar mijn weten. Als je iets standaard in moet laden zijn dat dan geen resources?
In je config.php kan je het Config object aanmaken en een configuratie bestand in het object setten.
Bijvoorbeeld zo:
Code (php)
1
2
3
4
5
6
7
8
9
10
2
3
4
5
6
7
8
9
10
<?php
$config = new Config_Ini('path/to/config.ini');
// Of
$config = new Config_Xml('path/to/config.xml');
// Of
$config = new Config_Yml('path/to/config.yml');
?>
$config = new Config_Ini('path/to/config.ini');
// Of
$config = new Config_Xml('path/to/config.xml');
// Of
$config = new Config_Yml('path/to/config.yml');
?>
Daarnaa kan je hem in het register zetten:
Code (php)
1
2
3
2
3
<?php
Registry::set('config', $config);
?>
Registry::set('config', $config);
?>
Wat mooi is dat je alle configuratie als een object laat benaderen. Dus stel je hebt de volgende config.ini
Code (php)
1
2
3
4
2
3
4
database.host = 'test';
database.dbname = '';
database.username = '';
database.password = '';
database.dbname = '';
database.username = '';
database.password = '';
Dat je die dan als volgt kan benaderen:
Code (php)
1
2
3
4
2
3
4
<?php
$config = Registry::get('config');
echo $config->database->host; // geeft 'test'
?>
$config = Registry::get('config');
echo $config->database->host; // geeft 'test'
?>
Snap je ?
Maar nogmaals de vraag, waarom geen Zend?
Het gebruik van ini files is super, maar ik vind het niet prettig dat zo'n bestand te lezen is. Vandaar dat ik daar dan niet voor kies.
Ik zie jou trouwens telkens dit doen:
$config = Registry::get('config');
"Mag" ik het ook zo programmeren dat je dit kan doen?
$registry = Registry::getInstance();
$config = $registry->config;
Vraag me niet waarom maar ik vind dit "mooier", maar misschien zie jij hier bepaalde nadelen in die ik niet zie? Graag je reactie.
Quote:
Ik geef er graag zelf vorm aan omdat ik dan precies weet hoe het in elkaar zit en ik het dan makkelijker kan begrijpen.
Kost te veel tijd, en daarmee ook te veel geld ;-)
Quote:
Het gebruik van ini files is super, maar ik vind het niet prettig dat zo'n bestand te lezen is. Vandaar dat ik daar dan niet voor kies.
Dan maak je gebruik van een XML file? Ik geef maar advies over wat naar mijn mening de beste manier is.
Hoe jij programmeert maakt mij niet zo heel veel uit ;-) Het grootste nadeel is dat het twee regels zijn i.p.v 1.
Gewijzigd op 16/02/2012 16:34:12 door Niels K
Nog een laatste vraag he...
Nu heb ik die Config class waar ik settings uit kan halen. Nu vraag ik me af... ik zou als ik een config setting nodig heb de Config class zelf kunnen aanspreken:
$config = Config::getInstance();
$my_setting = $config->my_key;
Maar ik kan ook die hele config instance in de Registry gooien. Dan krijgen we dus zoiets:
$registry = Registry::getInstance();
$config = $registry->config;
$my_setting = $config->my_key;
Wat is eigenlijk beter? Allebei de manieren werken immers. Wat is het voordeel van het een ten opzichte van het ander?
Gewijzigd op 16/02/2012 16:43:53 door Ozzie PHP