Portál AbcLinuxu, 27. dubna 2024 04:43
Táto časť patrí k najdôležitejším, pretože si v nej budeme podrobne vysvetľovať srdce celého frameworku, a to je Active Record.
V minulej časti sme si povedali o základnej inštalácii celého frameworku a pre začiatok sme si vysvetlili, ako funguje základné rozloženie stránky. V dnešnej časti si predstavíme srdce celého CakePHP a ukážeme si, ako správne dodržiavať konvencie Cake v súvislosti s návrhom databáze. Samotný návrh databázy príde na radu v nasledujúcej časti.
Active Record je srdce CakePHP a dokonale demonštruje princípy, na akých je Cake postavený.
Active Record je návrhový vzor, ktorý mapuje databázové tabuľky na triedy, riadky na objekty a stĺpce na ich atribúty (toto však v Cake nie je úplne tak - rozdiel je v tom, že aktuálne sa riadky a stĺpce mapujú na dvojrozmerné polia; mapovanie na objekty je naplánované na verziu 2.0). Z názvu triedy modelu teda jednoducho odvodíme názov tabuľky. Napr. máme model Article a k nemu patrí tabuľka articles (vždy množné číslo od názvu modelu). Zároveň Active Record umožňuje definovať vzťahy medzi tabuľkami (hasMany, belongsTo, hasManyAndBelongsTo, …) a okrem toho obsahuje výkonné nástroje pre prácu s dátami, ako je zápis, čítanie, validácia.
Čo teda Active Record prináša do našej práce? Najdôležitejšia a podstatná vec je, že nám značne uľahčuje prácu s databázou, kde v konečnom dôsledku nemusíme písať SQL. Koľko práce trávime písaním, ladením SQL dotazov a následným mapovanim výsledkov atď. Active Record nám umožňuje pracovať na oveľa vyššej úrovni. Poďme sa pozrieť na nasledujúci príklad:
Máme tabuľku Articles, v ktorej máme uložené jednotlivé články. Bežným spôsobom chceme vybrať konkrétny článok SELECT * FROM articles WHERE id = 1.
+----+-------------+-------+--------+---------------------+ | id | title | text | author | created | +----+-------------+-------+--------+---------------------+ | 1 | Titulok | Text | Linus | 0000-00-00 00:00:00 | +----+-------------+-------+--------+---------------------+
V Cake si vytvoríme triedu Article (uložíme ju do súboru /app/models/article.php), ktorá nám bude reprezentovať tabuľku articles (názov tabuľky je množné číslo názvu modelu):
class Article extends AppModel{
var $name = 'Article';
}
A pomocou príkazu $this->Article->find(1); dostaneme požadovaný výsledok:
Article => id: 1 title: Titulok text: Text author: Linus created: 0000-00-00 00:00:00
Pôsobivé však? Ako sme si uviedli v prvej časti, konvencia má prednosť pred konfiguráciou, preto Cake automaticky predpokladá, že keď máme model nazvaný Article, v našej databáze existuje tabuľka nazvaná articles. Ak by sme však chceli zmeniť názov tabuľky a nepoužívať tak automatické konvencie, môžeme tak urobiť následovne
class Article extends AppModel{
var $name = 'Article';
var $useTable = 'clanky';
}
Vyššie sme si povedali, že Active Record obsahuje efektívne metódy nielen pre čítanie dát, ale aj pre ich manipuláciu. Poďme teda zmeniť titulok nášho článku:
$article = $this->Article->find(1); $article['Article']['title'] = 'nový titulok'; $this->Article->save($article);
po uložení môžeme vidieť obsah tabuľky:
+----+-------------+-------+--------+---------------------+ | id | title | text | author | created | +----+-------------+-------+--------+---------------------+ | 1 | nový titulok| Text | Linus | 0000-00-00 00:00:00 | +----+-------------+-------+--------+---------------------+
A máme hotovo. Jednoduchšie to už ani nemôže byť. Absolútny rozdiel od spôsobu, kde by sme museli písať SQL ako select… a potom update…, je značný. Možností využitia Active Record je mnoho:
Bolo by asi zbytočné vypisovať tu ďalšie ukážky a demonštrovať tak silu Active Record. Pre jednotlivé metódy a ich parametre odporúčam pozrieť oficiálnu dokumentáciu. Okrem iného sme si povedali, že Active Record nám nedáva len nástroje pre manipuláciu s dátami, ale poskytuje nám taktiež možnosť validácie vstupných dát a určenie vzťahov medzi tabuľkami.
Validácia vstupných dát je jednou zo základných podmienok bezpečnosti a správnej funkcie webovej aplikácie. Active Record preto obsahuje vstavanú a veľmi prepracovanú validáciu, ktorá nám uľahčí množstvo práce. Chceme určiť, aby titulok článku nebol pri uložení prázdny
class Article extends AppModel{
var $name = 'Article';
var $validate = array(
'title' => VALID_NOT_EMPTY,
);
}
Týmto sme určili, že pri uložení článku, musí byť vždy atribút title neprázdny. Preto, keď sa pokúsime uložiť článok následovne, dostaneme chybovú hlášku, ktorá nás upozorní, že titulok článku nemôže byť prázdny.
$article = $this->Article->find(1); $article['Article']['title'] = ''; $this->Article->save($save); This field cannot be left blank
Používať môžeme aj niekoľko validačných kritérie pre jeden atribút. Chceme-li napríklad určiť, aby náš titulok nebol prázdny a zároveň aby mal minimálne 5 znakov a maximálne 100 znakov, nie je nič jednoduchšie:
class Article extends AppModel{
var $name = 'Article';
var $validate = array(
'title' => array(
'required' => VALID_NOT_EMPTY,
'length' => array( 'rule' => 'validateLength', 'min' => 5, 'max' => 100 )
),
);
}
Sami vidíte, že jednoduchšie to už ani nemôže byť. A k tomu ešte platí, že Cake automaticky vypĺňa hodnotu prvku formulára, pri neúspešnom uložení generuje chybovú hlášku pre každý prvok formulára (podľa určenia validácie v modely) a umožňuje nám určiť taktiež aj iné validačné pravidlá ako VALID_NUMBER, VALID_YEAR, resp. ľubovoľný vlastný regulárny výraz. Z tohto nám musí byť jasné, koľko práce, kódu a starostí máme ušetrených.
Posledná vec, ktorú spomeniem pri Active Record, sú vzťahy medzi tabuľkami. Active Record umožňuje mapovať vzťahy medzi tabuľkami ako napríklad 1:N, M:N atď. Vezmime si náš prechádzajúci príklad. Určite budeme chcieť mať autorov v osobitnej tabuľke. Vytvoríme si preto novú tabuľku s názvom authors. Každý článok bude mať práve jedného autora a autor môže mať niekoľko článkov, čiže tu máme väzbu 1:N. Kód bude nasledovný:
class Article extends AppModel{
var $name = 'Article';
var $belongsTo = 'Author';
}
class Author extends AppModel{
var $name = 'Author';
var $hasMany = 'Article';
}
Poďme si vytvoriť nového autora a následne nový článok s daným autorom:
$author['Author']['name'] = 'Linus'; $author['Author']['email'] = 'linus@aaa.com'; $this->Author->save($author); +----+-------------+--------------------+ | id | name | email | +----+-------------+--------------------+ | 1 | Linus | linus@aaa.com | +----+-------------+--------------------+ $article['Article']['title'] = 'titulok'; $article['Article']['text'] = 'text'; $article['Article']['author_id] = 1; $this->Article->save($article); +----+-------------+-------+-----------+---------------------+ | id | title | text | author_id | created | +----+-------------+-------+-----------+---------------------+ | 1 | titulok | text | 1 | 0000-00-00 00:00:00 | +----+-------------+-------+-----------+---------------------+
To bolo jednoduché. Keď sa teraz pozrieme na článok $this->Article->find(1), vidíme detaily, že nám všetko funguje správne:
Article => id: 1 title: Titulok text: Text author: Linus created: 0000-00-00 00:00:00 Author => id: 1 name: Linus email: linus@aaa.com
Aké jednoduché však? Nemuseli sme písať žiadne dodatočné SQL dotazy, stále nám stačí príkaz $this->Article->find(1). Jediné, čo je potrebné, je dodržiavať konvencie Cake a správne určiť vzťahy medzi tabuľkami (určiť správny vzťah medzi danými tabuľkami nám značne pomáha tzv. console, venovať sa jej budeme v niektorých z nasledujúcich častí) a v daných tabuľkách správne dodržiavať cudzie kľúče. Poďme sa preto pozrieť, ako vyzerajú dané tabuľky.
Z obrázku je jasné, že cudzí kľúč v tabuľke articles musí byť pomenovaný author_id, čo sú dané konvencie Cake, aby framework mohol určiť, že sa jedná o cudzí kľúč z tabuľky authors. Čiže vždy platí, že cudzí kľúč v tabuľke je zložený z jednotného číslo názvu tabuľky cudzieho kľúča a príslušného id, teda pre cudzí kľúč autora v tabuľke articles bude author_id.
Ako to bude s väzbou N:M? Opäť to bude veľmi jednoduché. Predstavme si situáciu, že článok môže mať niekoľko autorov a autor može mať niekoľko článkov. Tabuľky sú na sebe nezávislé a ich prepojenie bude zaisťovať špeciálna tabuľka, ktorú môžeme vidieť na obrázku.
Opäť musíme dodržiavať konvencie Cake, aby všetko fungovalo správne. Názov tabuľky articles_authors sa skladá z názvov tabuliek, ktoré sú vo vzťahu N:M, čiže articles a authors a navyše tieto tabuľky musie byť zapísané v abecednom poradí a oddelené podtržítkom. Kód bude potom nasledovný
class Article extends AppModel{
var $name = 'Article';
var $hasAndBelongsToMany = array(
'Author' => array('className' => 'Author',
'joinTable' => 'articles_authors',
'foreignKey' => 'article_id',
'associationForeignKey' => 'author_id',
)
);
}
class Author extends AppModel{
var $name = 'Author';
var $hasAndBelongsToMany = array(
'Article' => array('className' => 'Article',
'joinTable' => 'articles_authors',
'foreignKey' => 'author_id',
'associationForeignKey' => 'article_id',
)
);
}
Ešte treba poznamenať, že model sa pre spojovaciu tabuľku articles_authors nevytvára; vďaka dodržiavaniu konvencií Cake to nie je potrebné.
Týmto sme u konca. Dúfam, že sa mi podarilo zachytiť základné rysy a možnosti Active Record v CakePHP. Samotný návrh databáze a jej testovanie príde na radu v nasledujúcom článku.
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.