3. Tvoríme CMS s CakePHP - Active Record

Autor: Tibor Piňo, Vytvorený: 11. 02. 2008 22:50

Treťou časťou pokračuje seriál o CakePHP. 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 čas­ti.

Active Record

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, hasManyAndBelon­gsTo…), 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, následné mapovanie výsledkov atď. Active Record nám umožňuje pracovať na oveľa vyššej intelektuálnej ú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               | user   | 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/ar­ticle.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
user: 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é konvecie, 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               | user   | 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…, potom update… je značný. Možností využitia Active Record je mnoho

• $this->Article->findById(1) ⇒ vráti článok s id 1
• $this->Article->findAll(null,a­rray(‚title,‘tex­t'),‚Article.cre­ated desc‘) ⇒ vráti články zotriedené podľa dátumu vytvorenia, a vyberú sa len stĺpce title a text
• $this->User->findByName(‚Li­nus‘) ⇒ vráti autora s menom Linus

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 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 users. 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 = 'User';
}

class User extends AppModel{
  var $name = 'User';
  var $hasMany = 'Article';
}

Poďme si vytvoriť nového autora a následne nový článok s daným autorom

$user['user']['name'] = 'Linus';
$user['user']['email'] = 'linus@aaa.com';
$this->user->save($user);

+----+-------------+--------------------+
| id | name        | email              |
+----+-------------+--------------------+
|  1 | Linus       | linus@aaa.com      |
+----+-------------+--------------------+

$article['Article']['title'] = 'titulok';
$article['Article']['text'] = 'text';
$article['Article']['user_id] = 1;
$this->Article->save($article);

+----+-------------+--------------------+-----------+---------------------+
| id | title       | text               | user_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
user: Linus
created: 0000-00-00 00:00:00
user =>
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ý user_id čo sú dané konvencie Cake, aby framework mohol určiť, že sa jedná o cudzí kľúč z tabuľky users. Č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 user_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_users sa skladá z názvov tabuliek, ktoré sú vo vzťahu N:M, čiže articles a users 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(
          'user' => array('className' => 'user',
                        'joinTable' => 'articles_users',
                        'foreignKey' => 'article_id',
                        'associationForeignKey' => 'user_id',
                           )
       );
}

class user extends AppModel{
  var $name = 'user';
  var $hasAndBelongsToMany = array(
          'Article' => array('className' => 'Article',
                        'joinTable' => 'articles_users',
                        'foreignKey' => 'user_id',
                        'associationForeignKey' => 'article_id',
                           )
       );
}

Ešte treba poznamenať, že model sa pre spojovaciu tabuľku articles_users 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.

Rád uvítam vaše námety a pripomienky v diskusii k článku.