Strzałek's devblog http://strzalek.net/blog Just another devblog Fri, 10 Apr 2009 15:46:28 +0000 http://wordpress.org/?v=2.5.1 en XML - morze możliwości - XPath, XPointer, XInclude http://feedproxy.google.com/~r/strzalek-devblog/~3/06zXVmsLoZU/xml-morze-mozliwosci-xpath-xpointer-xinclude http://strzalek.net/blog/7/xml-morze-mozliwosci-xpath-xpointer-xinclude#comments Thu, 27 Nov 2008 20:03:24 +0000 Strzałek http://strzalek.net/blog/?p=7 Często odbywają się dyskusje dotyczące formatu w jakim przechowywać konfiguracja aplikacji. Najczęściej wybierane sposoby to pliki INI, YAML oraz XML. Za najlepsze rozwiązanie uważam wykorzystanie XML’a.

Główną zaletą XML jest jego popularność oraz szereg standartów które znacznie usprawniają prace. Struktury XML są bardzo łatwo rozszerzalne poprzez XInclude. Walidację takiego pliku można bardzo szybko rozwiązać tworząc plik XSD, natomiast jeżeli potrzebujemy ładnej prezentacji zawartości, wystarczy stworzyć plik XSLT oraz napisać kilkadziesiąt linijek.

Przykładowy plik XML

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="UTF-8"?>
  2. <adress -book>
  3.         <presons>
  4.                 <person id="1">
  5.                         <firstname>Jan</firstname>
  6.                         <lastname>Kowlaski</lastname>
  7.                         <email>jan-kowalski@gmail.com</email>
  8.                         <phone>000 123 456</phone>
  9.                 </person>
  10.                 <person id="2">
  11.                         <firstname>Piotr</firstname>
  12.                         <lastname>Nowak</lastname>
  13.                         <email>piotr-nowak@gmail.com</email>
  14.                         <phone>000 123 456</phone>
  15.                 </person>
  16.                 <person id="1">
  17.                         <firstname>Paweł</firstname>
  18.                         <lastname>Kwiatkowski</lastname>
  19.                         <email>jan-kowalski@gmail.com</email>
  20.                         <phone>000 123 456</phone>
  21.                 </person>
  22.         </presons>
  23. </adress>

XPath jest językiem używanym do lokalizacji oraz pozyskiwania informacji z drzewa XML. Język ten jest również potrzebny podczas używania XPointer oraz XSLT

Do przetwarzania XML’a będziemy używać rozszerzenia DOM dla PHP.

Zacznijmy od podstawowego wyrażenia xpath. Pobierzemy wszystkie nazwiska z naszej książki adresowej:

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. $dom = new DOMDocument();
  4. $dom->load(‘address-book.xml’);
  5.  
  6. $xpath = new DOMXPath($dom);
  7. $persons = $xpath->query("/address-book/persons/person/lastname");
  8.  
  9. foreach ($persons as $person) {
  10.         echo $person->nodeValue."<br />";
  11. }
  12.  
  13. ?>
[Show Plain Code]:
  1. Kowlaski
  2. Nowak
  3. Kwiatkowski
  4. Jankowski

Do wykonywania operacji korzystając z XPath służy klasa DOMXPath. Tworząc egzemplarz tej klasy przekazujemy obiekt DOM na którym chcemy operować, następnie używając metody query która zwraca to o co prosiliśmy.

A o co prosiliśmy i jak prosić? W przykładzie powyżej napisaliśmy bardzo proste wyrażenie, które zwróciło nam tylko nazwiska (lastname) osób w książce. Poszczególne poziomy w dokumencie XML oddzielane są znakiem /. Jezeli zapytanie zaczyna się od slasha oznacza to że wyszukiwanie ma zacząć się od najwyższego elementu.

Używając XPath możemy pisać bardziej szczególowe zapytania. Wybrać nazwisko osoby o numerze id równym 1:

XML [Show Plain Code]:
  1. /address-book/persons/person[@id='1']/lastname

Dodający przy person nawias kwadratowy ograniczyliśmy wyszukiwanie tylko do elementów person które posiadają atrybut id o wartości równej 1. Znak @ przed id oznacza że uwzględniamy atrybuty nie elementy.

XML [Show Plain Code]:
  1. /address-book/persons/person[firstname='Paweł' and city='Warszawa']/lastname

Powyższe zapytanie zwróci nam nazwiska osób których imię to Paweł oraz miejsce zamieszkania to Warszawa. W tym zapytanie nie używaliśmy znaku @ ponieważ interesowały nas elementy a nie atyrbuy.

Przedstawiłem tutaj podstawowe sposoby które najczęściej są używane podczas korzystanie z XPath. Po więcej informacji zapraszam do dokumentacji XPath.

XInclude

XPointer

XPointer jest rozszerzeniem XPath i używa jego składni. Jest to język do adresowania fragmentów dokumentów XML. Został przewidziany do stosowania w adresach URI.

Przykładowe wyrażenia XPath używając XPointer wyglądają następująco:

XML [Show Plain Code]:
  1. xpointer(/address-book/persons/person[@id='1']/lastname)

Wspomniałem o używaniu w adresach URI. Tak przykładowo by wyglądało wyrażenie jako fragment URI:

[Show Plain Code]:
  1. http://www.example.com/address-book.xml#xpointer(/address-book/persons/person[@id='1']/lastname)

XInclude

XInclude jest standartem który pozwala nam dołączać zewnętrzne dokumenty lub ich fragmnety do pliku XML. XInclude zawiera się w przestrzeni nazw http://www.w3.org/2001/XInclude. W tym namespace mamy dwa elementy zakładając że zadeklarujemy prefix xi będzie to xi:include oraz xi:fallback. Pierwszy z nich określa lokalizacje jednostki którą chcemy dołączyć - może być to mały zakres XML’a wybrany XPath’em lub cały plik. Może się zdarzyć że XInclude zwróci błąd. Plik lub wybrany zakres który chcemy dołączyć może nie istnieć. Aby osłużyć błąd XInclude oferuje element xi:fallback.

Rozszerzmy naszą książkę adresową o grupy. Mając wiele konkatków w pewnym momencie dobrze by było je jakoś uporządkować.

XML [Show Plain Code]:
  1. <address -book>
  2.         <persons>
  3.                 <person id="1">
  4.                         <firstname>Jan</firstname>
  5.                         <lastname>Kowlaski</lastname>
  6.                         <email>jan-kowalski@gmail.com</email>
  7.                         <phone>000 123 456</phone>
  8.                         <city>Warszawa</city>
  9.                 </person>
  10.                 <person id="2">
  11.                         <firstname>Piotr</firstname>
  12.                         <lastname>Nowak</lastname>
  13.                         <email>piotr-nowak@gmail.com</email>
  14.                         <phone>000 123 456</phone>
  15.                         <city>Kraków</city>
  16.                 </person>
  17.                 <person id="3">
  18.                         <firstname>Paweł</firstname>
  19.                         <lastname>Kwiatkowski</lastname>
  20.                         <email>pawel-kwiatkowski@gmail.com</email>
  21.                         <phone>000 123 456</phone>
  22.                         <city>Warszawa</city>
  23.                 </person>
  24.                 <person id="4">
  25.                         <firstname>Paweł</firstname>
  26.                         <lastname>Jankowski</lastname>
  27.                         <email>robert-jankowski@gmail.com</email>
  28.                         <phone>000 123 456</phone>
  29.                         <city>Poznań</city>
  30.                 </person>
  31.         </persons>
  32.  
  33.         <groups>
  34.                 <group name="Znajomi">
  35.                         <persons>
  36.                                 <person id="2">
  37.                                         <firstname>Piotr</firstname>
  38.                                         <lastname>Nowak</lastname>
  39.                                         <email>piotr-nowak@gmail.com</email>
  40.                                         <phone>000 123 456</phone>
  41.                                         <city>Kraków</city>
  42.                                 </person>
  43.                                 <person id="3">
  44.                                         <firstname>Paweł</firstname>
  45.                                         <lastname>Kwiatkowski</lastname>
  46.                                         <email>pawel-kwiatkowski@gmail.com</email>
  47.                                         <phone>000 123 456</phone>
  48.                                         <city>Warszawa</city>
  49.                                 </person>
  50.                         </persons>     
  51.                 </group>
  52.  
  53.                 <group name="Praca">
  54.                         <persons>
  55.                                 <person id="1">
  56.                                         <firstname>Jan</firstname>
  57.                                         <lastname>Kowlaski</lastname>
  58.                                         <email>jan-kowalski@gmail.com</email>
  59.                                         <phone>000 123 456</phone>
  60.                                         <city>Warszawa</city>
  61.                                 </person>
  62.                                 <person id="4">
  63.                                         <firstname>Paweł</firstname>
  64.                                         <lastname>Jankowski</lastname>
  65.                                         <email>robert-jankowski@gmail.com</email>
  66.                                         <phone>000 123 456</phone>
  67.                                         <city>Poznań</city>
  68.                                 </person>
  69.                         </persons>     
  70.                 </group>               
  71.         </groups>
  72.  
  73. </address>

Nie trudno zauważyć że takie rozwiązanie jest kłopotliwe. Gdy ktoś zmieni numer będziemy musieli zmieniać ten numer w kilku miejscach.

Problem ten możemy rozwiązać właśnie dzięki XInclude. Zamiast posiadać te same wpisy kilka razy, będzie je dołączać na podstawie numeru ID.

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="UTF-8"?>
  2. <address -book xmlns:xi="http://www.w3.org/2001/XInclude">
  3.         <persons>
  4.                 <person id="1">
  5.                         <firstname>Jan</firstname>
  6.                         <lastname>Kowlaski</lastname>
  7.                         <email>jan-kowalski@gmail.com</email>
  8.                         <phone>000 123 456</phone>
  9.                         <city>Warszawa</city>
  10.                 </person>
  11.                 <person id="2">
  12.                         <firstname>Piotr</firstname>
  13.                         <lastname>Nowak</lastname>
  14.                         <email>piotr-nowak@gmail.com</email>
  15.                         <phone>000 123 456</phone>
  16.                         <city>Kraków</city>
  17.                 </person>
  18.                 <person id="3">
  19.                         <firstname>Paweł</firstname>
  20.                         <lastname>Kwiatkowski</lastname>
  21.                         <email>pawel-kwiatkowski@gmail.com</email>
  22.                         <phone>000 123 456</phone>
  23.                         <city>Warszawa</city>
  24.                 </person>
  25.                 <person id="4">
  26.                         <firstname>Paweł</firstname>
  27.                         <lastname>Jankowski</lastname>
  28.                         <email>robert-jankowski@gmail.com</email>
  29.                         <phone>000 123 456</phone>
  30.                         <city>Poznań</city>
  31.                 </person>
  32.         </persons>
  33.  
  34.         <groups>
  35.                 <group name="Znajomi">
  36.                         <persons>
  37.                                 <xi :include xpointer="xpointer(/address-book/persons/person[@id='1'])" />
  38.                                 <xi :include xpointer="xpointer(/address-book/persons/person[@id='4'])" />
  39.                         </persons>     
  40.                 </group>
  41.  
  42.                 <group name="Praca">
  43.                         <persons>
  44.                                 <xi :include xpointer="xpointer(/address-book/persons/person[@id='3'])" />
  45.                                 <xi :include xpointer="xpointer(/address-book/persons/person[@id='4'])" />
  46.                         </persons>     
  47.                 </group>               
  48.         </groups>
  49.  
  50. </address>

Przetwórzmy teraz ten plik używając PHP i DOM:

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. $dom = new DOMDocument();
  4. $dom->preserverWhiteSpace = true;
  5. $dom->formatOutput = true;
  6.  
  7. $dom->load(‘address-book.xml’);
  8. $dom->xinclude();
  9. $dom->save("adress-book-xinclude.xml");
  10.  
  11. ?>

Za XInclude w klasie odpowiedzialna jest metoda xinclude(). Na końcu zapisaliśmy zawartość w nowym pliku żeby móc sprawdzić czy to rzeczywiście działa. Otwierając plik powinniśmy zobaczyć zamiast wpisów xi:include, dołączone właściwe watrości.

Nasza książka może się rozrosnąć a trzymanie wszystkiego w jednym pliku może stać się nie wygodne. A co gdybyśmy chcieli trzymać grupy kontaktów w odzielnym pliku, np.: address-book-groups.xml?

Zawartość pliku wyglądała by wtedy następująco:

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="UTF-8"?>
  2. <address -book xmlns:xi="http://www.w3.org/2001/XInclude">
  3.         <groups>
  4.                 <group name="Znajomi">
  5.                         <persons>
  6.                                 <xi :include href="address-book.xml" xpointer="xpointer(/address-book/persons/person[@id='1'])"/>
  7.                                 <xi :include href="address-book.xml" xpointer="xpointer(/address-book/persons/person[@id='4'])"/>
  8.                         </persons>     
  9.                 </group>
  10.  
  11.                 <group name="Praca">
  12.                         <persons>
  13.                                 <xi :include href="address-book.xml" xpointer="xpointer(/address-book/persons/person[@id='3'])"/>
  14.                                 <xi :include href="address-book.xml" xpointer="xpointer(/address-book/persons/person[@id='4'])"/>
  15.                         </persons>     
  16.                 </group>               
  17.         </groups>
  18. </address>

Wycieliśmy element groups wraz z jego dziećmi z pliku address-book.xml, dodając przy wartościach dołączanych atrybut href, wskazujący na plik w którym znajduje się nasz XML z osobami.

XSLT

Format XML jest dość czytelnym formatem jednak nie nadaje się on do prezentacji. Zdecydowanie lepszym pomysłem jest wyświetlić dane osadzając je ładnie np.: w HTMLu. Mamy do wyboru dwie drogi: pierwsza użycie DOM w PHP, parsując dokument i wyświetlając go wg. naszych oczekiwań. Drugim, lepszym sposobem, jest stworzenie pliku XSL oraz wykonać transformację przy użyciu XSLT.

Pliki XSL są dokumentami opisującymi sposób prezentacji i przekształceń dokumentów XML. Spróbujemy teraz pisząc kilka prostych podstawowych instrukcji, przekształcić XML naszej książki aby była ona prezentowana w formie tabeli HTML.

Jako że nasz plik jest dość prosty to w również prosty sposób zaprezentujemy go w tabeli html, przy okazji sortując

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="utf-8"?>
  2. <xsl :stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  3. </xsl><xsl :template match="/">
  4. <html>
  5. <head>
  6.         <title>XML - morze możliwości</title>
  7.  
  8.          <meta http-equiv="content-type" content="text/html; charset=utf-8;" />
  9.          <meta http-equiv="content-language" content="pl" />
  10.  </head>
  11.  <body>
  12.    <h2>Książka adresowa</h2>
  13.    <table>
  14.      <tr>
  15.        <th>Imię</th>
  16.        <th>Nazwisko</th>
  17.        <th>E-Mail</th>
  18.      </tr>
  19.         <xsl :for-each select="address-book/persons/person">
  20.         <xsl :sort select="lastname" />
  21.       <tr>
  22.         <td><xsl :value-of select="firstname"/></td>
  23.         <td><xsl :value-of select="lastname"/></td>
  24.         <td><xsl :value-of select="email"/></td>
  25.       </tr>
  26.         </xsl>
  27.    </table>
  28.  </body>
  29.  </html>
  30. </xsl>

Plik zaczynami od przypisania prefixu dla przestrzeni nazw XSL. Następie posługujemy się elementem xsl:template który definiuje szablon. Nasz szablon zaczyna się od podstawowych elementów html. Aby przetworzyć każdą osobę posłużymy się elementem xsl:for-each, w atrybucie select zaznaczając zbiór węzów do przetworznia używając wyrażeń XPath. Następnie zaznaczamy że chceby aby osoby były posortowane alfabetycznie wg. nazwiska i umieszczamy szablon który ma być używany przy każdym elemencie który ma być przetworzony. Zawiera on html wiersza tabeli. W komórkach tabeli do wyświetlenia imienia i nazwiska osoby użwywamy elementu xsl:value-of który zwraca wartość węzła podanego w atrybucie select. Trzeba zwrócić uwagę na to że podajemy tam wyrażenie XPath węzła który jest dostarczany przez xsl:for-each. W naszym przypadku będzie to np.:

XML [Show Plain Code]:
  1. <firstname>Jan</firstname>
  2. <lastname>Kowlaski</lastname>
  3. <email>jan-kowalski@gmail.com</email>
  4. <phone>000 123 456</phone>
  5. <city>Warszawa</city>

Dlatego też atrybut select będzie zawierał wyrażenie firstname/ a nie jak niektóry mogli mylnie sądzić address-book/persons/person/firstname. Na końcu dodajmy w pliku naszej książki linijkę podpinającą plik XSL:

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="UTF-8"?>
  2. < ?xml-stylesheet type="text/xsl" href="address-book.xsl"?>
  3. <address -book xmlns:xi="http://www.w3.org/2001/XInclude">
  4.         <persons>
  5.                 [...]
  6.         </persons>
  7. </address>

Gdy otworzymy teraz plik XML naszej książki w przeglądarce naszym oczom ukaże się tabelka z osobami a nie drzewo z XML’em.

W tym przypadku processorem XSLT był silnik przeglądarki. Jednak możemy zrobić to samo używając PHP i DOM’a.

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. $dom = new DomDocument();
  4. $dom->load("address-book.xml");
  5.  
  6. $xsl = new DomDocument();
  7. $xsl->load("address-book.xsl");
  8.  
  9. $xslt = new XsltProcessor();
  10. $xslt->importStyleSheet($xsl);
  11.  
  12. echo $xslt->transformToXML($dom);
  13.  
  14. ?>

Zaczynamy od stworzenia dwóch obiektów DOM. Pierwszy ładuje plik adress-book.xml czyli naszą książkę, natomiast drugi address-book.xsl zawierający arkusz z przekształceniami. Następnie tworzymy obiekt XsltProcessor który najpierw importuje plik XSL następnie wykonuje transformacje do HTML na naszej książce.

Podsumowanie

XML jest potężnym narzędziem. W tym artykule poruszyłem tylko podstawowe zagadnienia oraz możliwości. Odpowiednio XPath, XInclude, XSLT mają dużo obszerne dokumenacje i potrafią zdziałąć dużo więcej. Większość z was może czuć nie dosyt i odnieśc wrażenie artykuł został napisany bardzo powieszchownie. Otóż takie było moje założenie. Chciałem pokazać jakie możwliości posiada XML i wszystkie jego standarty oraz zachęcić was do ich używania, teraz kiedy już widzać z czym się to je, oraz że może okazać się to bardzo przyadtne i pomoce. Każdy z poruszonych tutaj standartów “potrafi” zdecydowanie więcej. Wyrażenia XPath mogą bardzo szczegółowo selekcjonować wartości które potrzebujemy. Natomiast XSLT posiada szereg kilku innych elementów służących do transformacji. W notce pokazałem jak przetworzyć XML do HTML’a. Jednak XSLT bardzo często jest używany również do transformacji pliku XML w inny.

Dodatkowe materiały

Artykuł zajął drugie miejsce w konkursie Doceniamy Publicystów zorganizowanym przez wortal php.pl

]]> http://strzalek.net/blog/7/xml-morze-mozliwosci-xpath-xpointer-xinclude/feed http://strzalek.net/blog/7/xml-morze-mozliwosci-xpath-xpointer-xinclude Agavi - Wprowadzenie http://feedproxy.google.com/~r/strzalek-devblog/~3/3e4mfQTewyA/agavi-wprowadzenie http://strzalek.net/blog/5/agavi-wprowadzenie#comments Fri, 16 May 2008 19:48:33 +0000 Strzałek http://strzalek.net/blog/?p=5 Agavi jest frameworkiem MVC napisanym w PHP5. Jest on stosunkowo słabo znany w środowisku programistów PHP. Przyczyną tego jest to iż dopiero od niedawna dostępne jest Agavi oznaczone wersją 0.11, które ma zamrożone API. Jednak przede wszystkim framework ten nadal nie posiada dokumentacji, co właściwie go dyskwalifikuje. Developerzy Agavi obiecują że dokumentacja się wreszcie pojawi, ja tymczasem postaram się częściowo załatać dziurę serią artykułów o tym świetnym frameworku.

Model View Controller

Tak jak pisałem we wstępie - Agavi jest frameworkiem którego działanie opiera się na wzorcu projektowym - MVC - Model View Controller.

Wg. tego wzorca aplikacja dzieli się na 3 części. Nie zagłębiając się w szczegóły odpowiednie warstwy odpowiadają za

  • Model - pozyskiwanie danych (Baza danych, Web Services etc.)
  • View (Widok) - przedstawienie pozyskanych danych użytkownikowi (zwrócenie html, xml, pdf etc.)
  • Controller (Kontroler) - analiza żądania użytkownika i uruchomienie odpowiedniego modelu i widoku.

W Agavi znajdują się dodatkowo akcje które to są wywoływane przez kontroler. Akcja natomiast może posiadać kilka widoków.

Instalacja

Zacznijmy od utworzenia struktury folderów na naszym serwerze. Składać się na nią będą:

  • /agavi_application
    • /app - nasza aplikacja
    • /dev - narzędzia które będą pomoce w momencie tworzenia aplikacji
    • /libs - biblioteki (agavi, doctrine, smarty etc.)
    • /pub - publiczny folder

Możemy ściągnąć najnowszą wersję Agavi ze strony frameworka. W momencie pisania artykuły najnowszą wersją jest 0.11.1. Po ściągnięciu, należy rozpakować paczkę, zmienić nazwę folderu na “agavi” i przenieść go do folderu libs.

Następnie przygotujmy sobie generatora. Skrypt ten używa phing’a, aby go zainstalować należy wykonać następujące komendy w konsoli (musisz mieć skonfigurowany pear).

[Show Plain Code]:
  1. $ pear channel-discover pear.phing.info
  2. $ pear install phing/phing

Skopiujmy skrypt agavi.bat-dist, który znajduje się w /libs/agavi/etc, do /dev zmieniając jego nazwę na agavi.bat. Używając naszego ulubionego edytora tekstowego zmieńmy ścieżki znajdujące się w skrypcie:

[Show Plain Code]:
  1. set PHING_COMMAND=C:\Server\php\phing.bat
  2. set AGAVI_INSTALLATION=C:\Server\www\agavi_application\libs\agavi\src

Tak wyglądają ścieżki w moim przypadku. Pierwsza wskazuje plik skryptu phing, druga źródła agavi.

Mając już gotowe narzędzie możemy uruchomić konsole i wykonać skrypt agavi.bat:

[Show Plain Code]:
  1. C:\Server\www\agavi_application> dev\agavi.bat project

Skrypt będzie nas pytał o różne ciekawe rzeczy. My grzecznie za każdym razem wciskamy enter. Po ok 45 sek. generator powinien poinformować nas że zakończył swoją pracę sukcesem, natomiast my po uruchomieniu aplikacji - http://localhost/agavi_application/pub/ powinniśmy zobaczyć logo agavi. Oznaczać to będzie że wszystko generator stworzył za nas pierwszą aplikację opierającą się na Agavi.

Budowa aplikacji

Aplikacje pisane na Agavi mają budowę modularną. Każdy moduł składa się z akcji. Akcja może mieć kilka widoków, widok natomiast może używać różnych szablonów. Przykładowo: moduł News, posiada akcję Add, która posiada widoki Input (formularz dodawania newsa) oraz Success (wiadomość o dodaniu newsa).

Tak w dużym skrócie wyglądają moduły. Moduły dodatkowo mogą posiadać własną konfigurację, pliki validatora, lub inne biblioteki które są używane przez moduł.

Stwórzmy sobie przykładowy moduł Notes, który będzie modułem notek bloga. Wygenerujmy sobie ten moduł używając generatora agavi:

[Show Plain Code]:
  1. $ dev\agavi.bat module

Generator będzie pytał nas o:

  1. Nazwa modułu: Notes
  2. Akcje: Index,ShowOne,Add
  3. Widoki dla akcji Index,ShowOne: Success (obie akcje tylko po 1 widoku), dla akcji Add: Success,Input
  4. Modele: Notes

Generator powinien stworzyć za nas wszystkie foldery, pliki z szablonami klas, oraz puste pliki szablonów. Pozostaje nam teraz dopisać logikę aplikacji.

Konfiguracja

Agavi jest frameworkiem który w dużym stopniu opiera się na konfiguracji. Konfiguracja znajduje się w plikach XML, składa się na nią 13 podstawowych plików oraz dodatkowe pliki które może posiadać każdy z modułów. Ilość plików na początku może przerażać, jednak zapewniam że gdy dobrze poznamy ten framework, konfiguracja stanie się bardzo prosta i intuicyjna. Generator stworzył nam domyślną konfigurację i na niej będziemy się opierać. Zmienimy jedynie 4 pliki.

settings.xml

Ustawiamy akcję Index modułu Notes jako domyślną.

XML [Show Plain Code]:
  1. <system_action name="default">
  2.                                 <module>Notes</module>
  3.                                 <action>Index</action>
  4.                         </system_action>

oraz włączamy komponent bazy danych:

XML [Show Plain Code]:
  1. <setting name="use_database">true</setting>

databases.xml

Deklarujemy driver którego będziemy używać (w naszym przypadku PDO ale nic nie stoi na przeszkodzie abyś użył Propela, Doctrine lub cokolwiek innego) oraz dane potrzebne do nawiązania połączenia z bazą danych.

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="UTF-8"?>
  2. <configurations xmlns="http://agavi.org/agavi/1.0/config">     
  3.         <configuration>
  4.                 <databases default="pdo_mysql">   
  5.                         <database name="pdo_mysql" class="AgaviPdoDatabase">
  6.                                 <parameter name="dsn">mysql:host=localhost;dbname=agavi_application</parameter>
  7.                                 <parameter name="username">root</parameter>
  8.                                 <parameter name="password">pass</parameter>
  9.                         </database>               
  10.                 </databases>
  11.         </configuration>
  12. </configurations>

routing.xml

Plik z drogami. Zadeklarowaliśmy 3 scieżki. Pierwsza zostanie wybrana, gdy adres będzie wyglądał np. tak:
http://strona.pl/notes/123/html. Wykonana zostanie wtedy akcję ShowOne modułu Notes, przekazując parametr id o wartości 123. Druga pokaże nam formularz dodawania notki, a trzecia domyślną akcję.

XML [Show Plain Code]:
  1. < ?xml version="1.0" encoding="UTF-8"?>
  2. <configurations xmlns="http://agavi.org/agavi/1.0/config">
  3.         <configuration>
  4.                 <routes>                       
  5.                         <route name="note_one" pattern="^/note/(id:\d+).html$" module="Notes" action="ShowOne" />
  6.                         <route name="note_add" pattern="^/add.html$" module="Notes" action="Add" />
  7.                         <route pattern="^/$" module="%actions.default_module%" action="%actions.default_action%" />
  8.                 </routes>
  9.         </configuration>
  10. </configurations>

output_types.xml

W sekcji layouts, dodajemy jedną warstwę. Dekorator, czyli nasz “główny” szablon.

XML [Show Plain Code]:
  1. <layer name="decorator">
  2.       <parameter name="template">%core.app_dir%/templates/Master</parameter>
  3. </layer>

Model

Pisanie aplikacji zaczniemy od modelu. Zaimplementujemy w nim metody które będą potrzebne dla akcji/widoków. Będą to metody: getRecent (zwrócenie ostatnich kilku notek), getById (zwrócenie notki o danym id) oraz save (zapis):

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Notes_NotesModel extends ProjectBaseModel
  4. {
  5.   public $dbLayer = null;
  6.  
  7.         public function initialize(AgaviContext $context, array $parameters = array())
  8.         {
  9.                 parent::initialize($context, $parameters);           
  10.                 $this -> dbLayer = $this -> getContext() -> getDatabaseConnection();
  11.                 $this -> dbLayer -> exec("SET NAMES utf8");
  12.         }
  13.        
  14.         public function getById($id)
  15.         {
  16.                 $stmt = $this -> dbLayer -> prepare("SELECT * FROM notes WHERE id = :id");
  17.                 $stmt -> bindParam("id", $id, PDO::PARAM_INT);
  18.                 $stmt -> setFetchMode(PDO::FETCH_OBJ);
  19.                 $stmt -> execute();
  20.        
  21.                 return $stmt -> fetch();
  22.         }
  23.        
  24.         public function getRecent()
  25.         {
  26.                 $stmt = $this -> dbLayer -> prepare("SELECT * FROM notes ORDER BY date DESC LIMIT 10");
  27.                 $stmt -> setFetchMode(PDO::FETCH_OBJ);
  28.                 $stmt -> execute();
  29.        
  30.                 return $stmt -> fetchAll();
  31.         }
  32.        
  33.         public function save(array $data)
  34.         {
  35.                 $stmt = $this -> dbLayer -> prepare("INSERT INTO notes VALUES(NULL, :title, :intro, :text, NOW(), :author)");
  36.                 $stmt -> execute($data);
  37.         }
  38. }
  39.  
  40. ?>

Tak wygląda nasz model. Myślę że zbytnio nie ma co się rozpisywać, są to podstawowe operacje na baze danych używając PDO.

Akcje

Wygenerowane akcje mają obszerny komentarza. Warto go przeczytać i zapamiętać wskazówki w nim zawarte. Oprócz komentarza (po przeczytaniu możemy go wywalić ;) mamy jedną metodę: getDefaultViewName, zwraca ona domyślny widok który ma być wykonany jeżeli nie wskazano innego.

Najważniejszymi metodami akcji są metody executeRead oraz executeWrite. Są one wykonywane odpowiednio gdy wysłane są dane metodą GET i POST. Można zaimplementować jedną metodę - execute - w której ręcznie sprawdzali byśmy sobie skąd otrzymujemy dane. Nie jest to zalecane rozwiązanie jednak może zaistnieć sytuacja kiedy będziemy musieli z tej możliwości skorzystać. Wszystkie z tych 3 metod muszą zwrócić nazwę widoku który ma być wykonany. W przeciwnym wypadku nie zostanie wykonany żaden widok.

Jeżeli chodzi o naszą małą aplikację, a właściwie nasz jeden mały moduł to interesuje nas jedynie akcja Add. Inne akcje nie będą posiadały żadnej logiki. Będą jedynie zwracać widok, ten natomiast będzie prezentował dane pobrane od modelu.

Akcja Add domyślnie będzie uruchamiać widok Input, który będzie zawierał formularz. Jeżeli jednak zostaną przesłane jakieś dane metodą POST to zostanie wywołana metoda executeWrite.

Oto jak będzie wyglądać nasza akcja:

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Notes_AddAction extends ProjectBaseAction
  4. {
  5.         public function executeWrite(AgaviRequestDataHolder $rd)
  6.         {
  7.                 $model = $this -> getContext() -> getModel("Notes", "Notes");
  8.                 $model -> save($rd -> getParameter("note"));
  9.                
  10.                 return ‘Success’;
  11.         }
  12.         public function getDefaultViewName()
  13.         {
  14.                 return ‘Input’;
  15.         }
  16. }
  17.  
  18. ?>

Kod bardzo prosty. Pobranie modelu, następnie wywołanie metody save, podając jako argument tablicę z danymi z formularza ($rd jest obiektem typu AgaviRequestDataHolder, są tam przechowywane dane z requestu)

Widoki

Została nam ostania warstwa aplikacji, warstwa prezentacyjna czyli widok. W tym przypadku pomijamy widoku akcji Add, ponieważ nie potrzebujemy wciągać żadnych danych. Pokażemy jedynie formularz (Input) lub wiadomość o tym że dodano wiadomość (Success). Tak będą natomiast będą wyglądać widoki:

IndexSuccessView

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Notes_IndexSuccessView extends ProjectBaseView
  4. {
  5.         public function executeHtml(AgaviRequestDataHolder $rd)
  6.         {
  7.                 parent::setupHtml($rd);
  8.                
  9.                 $model = $this -> getContext() -> getModel("Notes", "Notes");
  10.                 $this->setAttribute("notes", $model -> getRecent());
  11.         }
  12. }
  13.  
  14. ?>

ShowOneSuccessView

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Notes_ShowOneSuccessView extends ProjectBaseView
  4. {
  5.         public function executeHtml(AgaviRequestDataHolder $rd)
  6.         {
  7.                 parent::setupHtml($rd);
  8.  
  9.                 $model = $this -> getContext() -> getModel("Notes", "Notes");      
  10.                 $this->setAttribute("note", $model -> getById($rd -> getParameter("id")));
  11.         }
  12. }
  13.  
  14. ?>

Są one prawie takie same. Różnią się one jedynie metodą modelu którą wykonujemy. W widoku ShowOne pobieramy z modelu jedną notkę o id którego wartość bierzemy z requestu, tam natomiast trafiło z routera, czyli z adresu url :)

Pozostało nam już tylko napisanie szablonów. Zacznijmy od głównego szablonu, czyli Master.php który musimy utworzyć w app/templates:

app/templates/Master.php

HTML [Show Plain Code]:
  1. < !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  2. <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="pl">
  4.  
  5.  <title>Notki</title>
  6.  
  7.  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
  8.  <meta http-equiv="content-language" content="pl" />
  9.  
  10.  <base href="<?php echo $ro->getBaseHref(); ?>" />
  11.  
  12. </base></head>
  13. <body>
  14.         < ?php echo $inner; ?>
  15. </body>
  16. </html>

Ustawiając Master.php jako dekorator, wszystko co zwróci widok dane akcji (html), będzie później dostępne poprzez zmienną $inner. Szkielet strony wtedy trzymamy w Master.php a w miejscu, gdzie treść będzie sie zmieniać wyświetlamy zawartość $inner.

IndexSuccess.php

HTML [Show Plain Code]:
  2.         <h1>Notki</h1>
  3.         <p><a href="<?php echo $ro -> gen("note_add"); ?>">Dodaj</a></p>
  4.                 <ul>
  5.                 < ?php foreach($template['notes'] as $note){ ?>
  6.                         <li>
  7.                                 <div><a href="<?php $ro -> gen("note_one", array("id" => $note -> id)); ?>">< ?php echo $note -> title; ?></a></div>
  8.                                 <p>< ?php echo $note -> intro; ?></p></li></ul></div>
  9.                        
  10.                 < ?php } ?>

ShowOneSuccess.php

HTML [Show Plain Code]:
  1. < ?php $note = $template[‘note’]; ?>
  2.         <h2>< ?php echo $note -> title; ?></h2>
  3.         <div>   
  4.                 <p>< ?php echo $note -> intro; ?></p>
  5.                 <p>< ?php echo $note -> text; ?></p>
  6.                 <p>< ?php echo $note -> author; ?> / < ?php echo $note -> date; ?></p>   
  7.         </div>

AddInput.php

HTML [Show Plain Code]:
  1. <h2>Dodaj notkę</h2>
  2.         <form action="<?php echo $ro -> gen("note_add"); ?>" method="post">
  3.           <div>
  4.                 <label for="title">Tytuł</label>
  5.                 <input type="text" name="note[title]" id="title" />
  6.           </div>
  7.           
  8.           <div>
  9.                 <label for="intro">Wstęp</label>
  10.                 <textarea name="note[intro]" id="intro"></textarea>
  11.           </div>
  12.           
  13.           <div>
  14.                 <label for="text">Treść</label>
  15.                 <textarea name="note[text]" id="text"></textarea>
  16.           </div>
  17.           
  18.           <div>
  19.                 <label for="author">Autor</label>
  20.                 <input type="text" name="note[author]" id="author" />
  21.           </div>
  22.           
  23.           <div>
  24.                 <input type="submit" value="Dodaj" />
  25.           </div>
  26.         </form>

AddSuccess.php

HTML [Show Plain Code]:
  1. <p>Dodano notkę!</p>

Nad szablonami myślę że nie ma za bardzo co się rozwodzić. Zwykły HTML, wyświetlający dane otrzymane z widoku.

Zakończenie

W kilku szybkich krokach, nie zagłębiając się w szczegóły, stworzyliśmy bardzo prostą aplikację. Coś w stylu “Jak napisać bloga w 15 minut” używając mojego kochanego frameworka ;) Notka ta miała na celu bardziej zachęcić do zainteresowania się Agavi, niż szczegółowo opisać cały framework. Wszystko w swoim czasie ;)

Polecam przejrzeć jeszcze raz kod aplikacji (teoretycznie powinna ona działać, po uruchomieniu ;) w aby lepiej zrozumieć zasadę działania. Warto również zajrzeć do przykładowej aplikacji znajdującej się w paczce Agavi w folderze samples.

]]> http://strzalek.net/blog/5/agavi-wprowadzenie/feed http://strzalek.net/blog/5/agavi-wprowadzenie Doctrine - ORM dla PHP http://feedproxy.google.com/~r/strzalek-devblog/~3/TzSeyXV1Olk/doctrine-orm-dla-php http://strzalek.net/blog/4/doctrine-orm-dla-php#comments Fri, 02 May 2008 19:29:06 +0000 Strzałek http://strzalek.net/blog/?p=4 Po pewnym czasie obcowania z bazą danych, ciągłe pisanie zapytań oraz ich przetwarzanie może stać się strasznie męczące. Dodatkowo pojawia się problemu z kompatybilnością baz danych

Na przeciw temu wszystkiemu wychodzą ORMy. ORM czyli Object-Relational Mapping jest to rozwiązanie w którym dane są mapowane i zwracane w postaci obiektów. Powstało kilkanaście rozwiązań ORM dla PHP. Najpopularniejsze to Propel oraz Doctrine, osobiście w projektach używam tego drugiego i tą notką postaram się przybliżyć wam użycie tego ORM.

Rekordy

Przed napisaniem pierwszego zapytania musimy stworzyć wcześniej rekordów. Stwórzmy sobie bazę danych posiadającą 3 tabele: categories (id, name), companies (id, name) oraz products (id, name, description, price, company, category) na której będziemy operować bawiąc się Doctrine. Baza ta będzie przechowywać produkty, każdy z produktów może znajdować się w jednej kategorii oraz może być stworzony przez jedną firmę.

models/Category.php

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Category extends Doctrine_Record
  4. {
  5.     public function setTableDefinition()
  6.     {
  7.         $this->setTableName("categories");       
  8.         $this->hasColumn("name", "string", 45);
  9.     }
  10.  
  11.     public function setUp()
  12.     {
  13.         $this->hasMany("Product as Products", array("local" => "id", "foreign" => "category"));
  14.     }
  15. }
  16.  
  17. ?>

models/Company.php

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Company extends Doctrine_Record
  4. {
  5.     public function setTableDefinition()
  6.     {
  7.         $this->setTableName("companies");       
  8.         $this->hasColumn("name", "string", 45);
  9.     }
  10.  
  11.     public function setUp()
  12.     {
  13.         $this->hasMany("Product as Products", array("local" => "id", "foreign" => "company"));
  14.     }
  15. }
  16.  
  17. ?>

models/Product.php

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3. class Product extends Doctrine_Record
  4. {
  5.     public function setTableDefinition()
  6.     {
  7.         $this->setTableName("products");
  8.         $this->hasColumn("name", "string", 45);
  9.         $this->hasColumn("description", "string");
  10.         $this->hasColumn("price", "decimal", 10);
  11.         $this->hasColumn("category", "integer");
  12.         $this->hasColumn("company", "integer");
  13.     }
  14.  
  15.     public function setUp()
  16.     {
  17.         $this->hasOne("Category", array("local" => "category", "foreign" => "id"));
  18.         $this->hasOne("Company", array("local" => "company", "foreign" => "id"));
  19.     }
  20. }
  21.  
  22. ?>

Tak wyglądają zadeklarowane rekordy. Każdy rekord musi dziedziczyć po Doctrine_Record. Pierwszą rzeczą jaką trzeba zrobić zrobić jest implementacja metody setTableDefinition, w której ustawiamy nazwę tabeli oraz deklarujemy kolumny jakie posiada (pole id jest deklarowane domyślnie). Następną rzeczą którą możemy uczynić jest ustawienie relacji zachodzących z rekordem. Do dyspozycji mamy 3 typu relacji: one-to-one (hasOne), one-to-many (hasMany) oraz many-to-many (o tej relacji kiedy indziej).

Wszystko pięknie, jednak gdy mamy do czynienia z dużą bazą danych gdzie operujemy na 20-30 tabelach, stworzenie rekordów dla bazy może być czasochłonne. Zresztą “przepisanie” struktury nawet dla 10 już jest męczące ;) Tutaj przychodzi z pomocą generator który udostępnia nam Doctrine. Może on stworzyć za nas wszystkie rekordy, a jego użycie sprowadza się do połączenia się z bazą danych oraz wywołania metody generateModelsFromDb, podając folder do którego mają być wygenerowane rekordy:

PHP [Show Plain Code]:
  1. < ?php
  2.  
  4. //Dołączenie główengo pliku Doctrine.
  5. require_once(‘./lib/Doctrine.php’);
  6. //Zarejestrowanie autoloadera Doctrine.
  7. spl_autoload_register(array(‘Doctrine’, ‘autoload’));
  8.  
  9. //Ustawienie połączenia
  10. Doctrine_Manager::connection(‘mysql://root:pass@localhost/doctrine’);
  11. //Wywołanie generatora
  12. Doctrine::generateModelsFromDb(‘models’);
  13.  
  14. //W folderze models mamy już gotowe do użycia rekordy
  15. ?>

Podstawowe operacje

Posiadając rekordy na których będziemy operować możemy przystąpić do działania. Zacznijmy od wypełnienia naszej bazy jakimiś danymi, by później móc wykonywać jakieś zapytania.

Użycie rekordów jest bardzo proste. Sprowadza się do stworzenia obiektu rekordu, następnie wypełnienia go danymi i wywołania metody save. Dodajmy pierwszy produkt:

Dodawanie

PHP [Show Plain Code]:
  1. < ?php
  2.  
  4.  
  5. //Dołączenie główengo pliku Doctrine.
  6. require_once(‘./lib/Doctrine.php’);
  7. //Zarejestrowanie autoloadera Doctrine.
  8. spl_autoload_register(array(‘Doctrine’, ‘autoload’));
  9. //Załadowanie wygenerowanych rekordów które znajdują się w folderze models
  10. Doctrine::loadModels(‘models’);
  11.  
  12.  //Ustawienie połączenia
  13.  $conn = Doctrine_Manager::connection(‘mysql://root:pass@localhost/doctrine’);
  14.  
  15.  $product = new Product();
  16.  $product -> name = "Zend Studio Professional Edition";
  17.  $product -> description = "IDE dla PHP";
  18.  $product -> price = 1500.00;
  19.  $product -> Company -> name = "Zend Technologies";
  20.  $product -> Category -> name = "Programowanie";
  21.  $product -> save();
  22.  
  23. ?>

Tworzymy nowy obiekt rekordu Product. Następnie ustawiamy po kolei wartości. W deklaracji rekordu zaznaczyliśmy że zachodzą relacje one-to-one z rekordami Category i Company. Dostęp do obiektów tych rekordów mamy poprzez właściwości o nazwie relacji. Mogli byśmy podać $product -> Company -> id = 1; ale na razie nie mamy żadnej kategorii ani firmy więc dodając produkt dodajemy nową kategorię oraz firmę.

Pobieranie

Jest kilka sposobów aby wyciągać rekordy z bazy danych. Najszybszym jest użycie magicznych metod find, udostępnianych przez Doctrine_Table:

PHP [Show Plain Code]:
  1. < ?php
  2.  $table = Doctrine::getTable("Product");
  3.  
  4.  $product = $table -> find(1);
  5.  $product = $table -> findOneByPrice(1500);
  6.  
  7.  echo "Produkt: ".$product -> name."<br />";
  8.  echo "Kategoria: ".$product -> Category -> name."<br />";
  9.  echo "Producent: ".$product -> Company -> name;
  10.  
  11.  $products = $table -> findByCompany(1);
  12.  $products = $table -> findAll();
  13.  
  14.  echo "<ul>";
  15.  foreach($products as $product)
  16.  {
  17.     echo "<li>".$product -> name."</li>";
  18.  }
  19.  echo "</ul>";
  20. ?>

Pierwsze dwie metody zwracają nam obiekt Product. Następnie wyświetlamy nazwę: produktu, kategorii oraz firmy. I tutaj trzeba zwrócić uwagę na bardzo ważną rzecz. Otóż stosując lazy-loading wywoływane są 3 zapytania, a nie jedno z JOINEM. A o tym jak pobrać w jednym zapytaniu to wszystko za chwilę (DQL).

Następnie znajdujemy wszystkie produktu, lub te gdzie company = 1. Zmienna products jest obiektem Doctrine_Collection, posiadającym pobrane rekordu. Jako że Doctrine_Collection implementuje interface ArrayAccess, oraz Iterator, możemy używać $products jako tablica.

Zmiana

Aby zmienić rekord używając obiektu rekordu, najpierw musimy pobrać rekord z bazy danych. Najprostszym sposobem jest użycie metody find która szuka po kluczu głównym (id)

PHP [Show Plain Code]:
  1. < ?php
  2.  $product = Doctrine::getTable("Product") -> find(1);
  3.  print_r($product -> toArray());
  4.  
  5.  $product -> name = "Zend Studio v.5 Professional Edition";
  6.  
  7.  //Update zmienionych wartości czyli tylko "name"
  8.  $product -> save();
  9.  print_r($product -> toArray());
  10. ?>

Usunięcie

Aby usunąć jakiś obiekt z bazy danych wystarczy użyć metody delete().

PHP [Show Plain Code]:
  1. < ?php
  2.  
  3.  $product = Doctrine::getTable("Product") -> find(1);
  4.  //Produkt został usunięty z bazy danych.
  5.  $product -> delete();
  6.  
  7. ?>

DQL - Doctrine Query Language

Magiczne DQL nie jest żadnym nowym językiem służącym do komunikacji z bazą danych - właściwie jest to trochę uproszczony SQL. Zapytania DQL pisze się za pomocą fluent interface, używając obiektu Doctrine_Query. Oto jak wygląda zapytanie które zwróci nam produkt wraz z jego kategorią oraz firmą:

PHP [Show Plain Code]:
  1. < ?php
  2.  $product = Doctrine_Query::create() -> from("Product p")
  3.                                      -> leftJoin("p.Category cat")
  4.                                      -> leftJoin("p.Company c")
  5.                                      -> where("p.id = ?", 6)
  6.                                      -> fetchOne();
  7.  
  8.  echo "Produkt: ".$product -> name."<br />";
  9.  echo "Kategoria: ".$product -> Category -> name."<br />";
  10.  echo "Producent: ".$product -> Company -> name;
  11.  
  12.  print_r($product -> toArray());
  13. ?>

Zasadniczą różnicą między DQL a SQL jest to że nie podajemy nazw tabel lecz nazwy rekordów. Dodatkowo przy JOINach nie musimy pisać ON col1 = col2 ponieważ Doctrine zna zarówno nazwę tabeli jak i nazwy kolumn między którymi zachodzi relacja. Na końcu wywołujemy fetchOne, chcąc dostać obiekt Product a nie obiekt Doctrine_Collection z jednym produktem :) Tak natomiast będzie wyglądać wyciągnięcie firmy oraz jej produktów:

PHP [Show Plain Code]:
  1. < ?php
  2.  $company = Doctrine_Query::create() -> from("Company c")
  3.                                      -> leftJoin("c.Products p")
  4.                                      -> where("c.id = ?", 1)
  5.                                      -> fetchOne();
  6.  
  7.  echo "Firma: ".$company -> name;
  8.  echo "<ul>";
  9.  foreach($company -> Products as $product)
  10.  {
  11.     echo "<li>".$product -> name."</li>";   
  12.  }
  13.  echo "</ul>";
  14. ?>

oraz wyciągnięcie wszystkich produktów z kategorii programowanie:

PHP [Show Plain Code]:
  1. < ?php
  2.  $products = Doctrine_Query::create() -> from("Product p")
  3.                                       -> leftJoin("p.Category cat")
  4.                                       -> where("cat.name = ?", "Programowanie")
  5.                                       -> execute();
  6.  echo "Produkty należace do kategori Programowanie";
  7.  echo "<ul>";                                     
  8.  foreach($products as $product)
  9.  {
  10.     echo "<li>".$product -> name."</li>";
  11.  }
  12.  echo "</ul>";
  13. ?>

Zaawansowane możliwości

Zaprezentowane wyżej możliwości to podstawowe funkcjonalności które oferuje nam ten ORM. Doctrine jest zaawansowanym narzędziem z którego można “wycisnąć” dużo więcej niż proste operacje CRUD oraz zapytania do bazy. O zaawansowanych możliwościach takich jak Event Listeners, Templates, Plugins, Cache oraz Migrations w następnej notce.

Jeżeli zachęciłem was do Doctrine to zapraszam do dokumentacji. Polecam ją przeczytaj od początku do końca aby dowiedzieć się jak ogromne możliwości oferuje nam to narzędzie. Jeżeli pojawią się jakieś problemy a dokumentacja nie wystarczy, pomoc zawsze znajdziecie na kanale #doctrine na serwerze freenode.net

Wszystkie listningi można ściągnąć i uruchomić na swoim komputerze.

]]> http://strzalek.net/blog/4/doctrine-orm-dla-php/feed http://strzalek.net/blog/4/doctrine-orm-dla-php Przyjazne URLe - piszemy router http://feedproxy.google.com/~r/strzalek-devblog/~3/2Jso5d-gwTQ/przyjazne-urle-piszemy-router http://strzalek.net/blog/3/przyjazne-urle-piszemy-router#comments Fri, 26 Oct 2007 17:34:54 +0000 Strzałek http://strzalek.net/blog/3/przyjazne-urle-piszemy-router Czym są przyjazne urle? Są to adresy w formacie http://strona.pl/nowosci/php/nowa-wersja-php-wydana, a nie tak standardowe i niewygodne adresy ze zmienny GET: http://strona.pl/index.php?module=news&category=php&title=nowa-wersja-php-wydana. Pierwszą rzeczą która skłania programistów do korzystania z przyjaznych urli jest to że są one rzeczywiście przyjazne. Można bardzo prosto zapamiętać taki link, znacznie łatwiej niż standardowy link ze zmiennymi GET. Wygodnie możemy na przykład umieszczać reklamy w gazetach - http://sklep.pl/konkurs. Drugą sprawą jest to iż przyjazne urle są łatwe do indeksowania dla wyszukiwarek. Roboty indeksujące strony wyżej zindeksują nasz pierwszy przykładowy link niż ten drugi, przestarzały rupieć ;)

Podstawy

Ok, po wstępnie zapewne czytelniku jesteś żądny wiedzy. Jak uzyskać takie urle? Bardzo prosto. Cała magia zawiera się w PATH INFO.
2 krótkie linijki:

PHP [Show Plain Code]:
  1. < ?php
  2. $pathInfoParams = explode(’/‘, substr($_SERVER[’PATH_INFO’], 1));
  3. var_dump($pathInfoParams);
  4. ?>

Prosty skrypt który po odpaleniu, pokaże nam dump’a tablicy, którą utworzyliśmy rozbijając dane z patch info ;) Wiedząc skąd brać nasze wejście trzeba by to teraz jakoś obsłużyć.
Router – wygodny interfejs

Skoro wszystko trzymane jest w PATH INFO, wiemy również jak to przetworzyć i użyć. Jednak takie rozwiązanie nas w ogóle nie zadowala. Strukturalny kod, który nie wygodnie wdrożyć w systemie. Przydało by się napisać ładną klasę odpowiedzialną za wszystko związane z adresem. I tutaj pojawia się nazwa Router. Cóż to za cudo? Router w aplikacjach internetowych służy do analizowania URLi, oraz ich generowania.

Przedstawię teraz przykładową implementację Routera:

PHP [Show Plain Code]:
  1. < ?php
  2.  class NiceUrlsRouter {
  3.  
  4.    protected $input = null;
  5.    
  6.    public $controller = null;
  7.    public $action = null;
  8.    public $params = null;   
  9.    
  10.    const URL_DELIMITER = ‘/’;

Zadeklarowaliśmy 4 właściwości przechowywujące odpowiednio, wejście, kontroler, akcję oraz tablicę z parametrami. Na końcu jedna stała która przechowuje separator. Dalej piszemy niezbędne metody:

PHP [Show Plain Code]:
  1. /**
  2.     * Ustawienie inputu który później
  3.     * zostaje parsowany
  4.     *
  5.     * @param string $input
  6.     */
  7.    public function setInput($input){
  8.           $this -> input = $this -> prepare($input);
  9.          }
  10.         
  11.          /**
  12.          * Ustawienie parametrow
  13.          *
  14.          * @param array $params
  15.          */
  16.          private function setParams($params){          
  17.           $this -> controller = array_shift($params);
  18.           $this -> action = array_shift($params);
  19.           $this -> params = $params;     
  20.          }
  21.         
  22.         
  23.          /**
  24.          * Przygotowanie urla do parsowania.
  25.          * Czyszczenie ze zbednych rzeczy.
  26.          *
  27.          * @param string $input
  28.          * @return string
  29.          */
  30.          protected function prepare($input){      
  31.               
  32.               if(substr($input, 0, 1) == ‘/’){
  33.                 $input = substr($input, 1);
  34.               }
  35.              
  36.            if(substr($input, -1) == ‘/’){
  37.                $input = substr($input, 0, -1);
  38.            }
  39.                  
  40.           return $input;
  41.          }
  42.         
  43.          /**
  44.          * Parsowanie inputu
  45.          *
  46.          * @return bool
  47.          */
  48.          public function parse(){
  49.               
  50.                if($this -> input){
  51.                  $this -> setParams(explode(self::URL_DELIMITER, $this -> input));
  52.                  return true;
  53.                }
  54.               
  55.            return false;
  56.          }
  57.         
  58.          /**
  59.          * Tworzenie url’a
  60.          *
  61.          * @param array $params
  62.          * @return string
  63.          */
  64.          public static function url($params){
  65.            
  66.                $url = ‘http://’.$_SERVER[‘SERVER_NAME’].str_replace(‘index.php’, ”, $_SERVER[‘SCRIPT_NAME’]);
  67.               
  68.                if(!is_array($params)){
  69.                 $params = func_get_args();      
  70.                }         
  71.               
  72.                $params = implode(self::URL_DELIMITER, $params);
  73.               
  74.                return $url.$params;
  75.          }
  76.         
  77.  }

Nie mam tutaj nic skomplikowanego. Krótki opis najważnieszych metod:

  • bool parse() - parsuje zawratość właściwości $input, pierwsze 2 elementy są umieszczane odpowiednio we właściwościach $contoller i $action, reszta ląduje w $params.
  • string url(array $params) – statyczna metoda tworząca url

Wszystko gotowe, przykładowe użycie świeżo napisanej klasy jest bardzo proste.

PHP [Show Plain Code]:
  1. $router = new NiceUrlsRouter();
  2.  $router -> setInput($_SERVER[‘PATH_INFO’]);
  3.  
  4.  if($router -> parse()){
  5.    echo ‘Kontroler: ‘.$router -> controller.‘<br />’;
  6.    echo ‘Akcja: ‘.$router -> action.‘<br />’;
  7.    echo ‘Parametry: ‘;
  8.    print_r($router -> params);
  9.  }
  10.  
  11.  echo ‘Wygenerowany url: ‘.NiceUrlsRouter::url(array_merge(array($router -> controller, $router -> action), $router -> params)).‘<br /><br />’;

Jeszcze tylko regułki mod_rewrite, odpowiedzialne za “usówanie” index.php z adresu:

[Show Plain Code]:
  1. RewriteEngine On
  2. RewriteCond %{REQUEST_FILENAME} !-f
  3. RewriteCond %{REQUEST_FILENAME} !-d
  4. RewriteRule (.*) index.php?$1 [L]

Po wejściu na http://localhost/news/show-one/65234 powinniśmy zobaczyć wylistowane wartości które zostały dostarczone przez router. Wszystko działa jak powinno.

Jeszcze jedną rzeczą o której trzeba pamiętć jest umieszczenie w head tagu base, podając adres strony. Dzięki temu będziemy mogli użwać ścieżek względnych w adresach naszych obrazków, plików css etc.

HTML [Show Plain Code]:
  1. <base href="http://localhost/" />

RewriteRouter

Z czasem może się okazać że taka prosta funkcjonalność nam nie wystarczy i będziemy chcieli posiadać różne rodzaje URL. Przykładowo:

  • http://strona.pl/news/534.html
  • http://strona.pl/artykuly/programowanie/php/przyjazne-urle-piszemy-router.html
  • http://strona.pl/forum/temat/5851.html

Zaczynają się schody, ponieważ w takim zapisie nie ma jakiejś ogólnej zasady. Każdy zbudowany jest inaczej i nie wiemy czy pierwsza pozycja to akacja, czy może parametr. A może być tak że w ogóle nie znajdziemy informacji w URL o kontrolerze bądź akcji, a są to przecież niezbędne informacje by nasz front kontroler mógł uruchamiać system. Dodatkowo na końcu dodaliśmy “.html” symulujące rozszerzenie, statycznej strony html, co ułatwia indeksowanie, ale całkowicie komplikuje naszą sytuację. Można to rozwiązać udoskonalając nasz router o wcześniej deklarowane drogi z wyrażeniami regularnymi, oraz drogami którymi mają zostać zastąpione. Zrobimy sobie dokładnie to samo co robi mod_rewrite w Apache :)

Można sobie pomyśleć że to nie jest łatwa rzecz - nic bardziej mylnego! Prostota implementacji zaskoczyła nawet mnie w momencie gdy programowałem i okazało się że rozwiązanie jest aż tak łatwe.

Zasada działania jest bardzo prosta. Otrzymujemy na wejściu /news/534. A chcemy uruchomić moduł News i akcję ShowOne czyli url powinien wyglądać następująco: /news/showone/534. Potrzebujemy więc przepisać pierwszy URL na drugi i po problemie.

RewriteRouter jest klasą dziedziczącą po NiceUrlsRouter który napisaliśmy przed chwilą. Dodajemy właściwość przetrzymującą reguły, metody do zarządzania regułami, oraz nadpisujemy metodę parse która porównuje URL wejściowy i jeżeli zgadza się on to podmienia go. Oto cała klasa:

PHP [Show Plain Code]:
  1. class RewriteRouter extends NiceUrlsRouter {
  2.    
  3.      public $rules = array();
  4.      
  5.       /**
  6.        * Dodanie reguły
  7.        *
  8.        * @param string $name
  9.        * @param string $pattern
  10.        * @param string $url
  11.        */
  12.       public function addRule($name, $pattern, $url){
  13.        $this -> rules[$name] = array(‘pattern’ => $pattern, ‘url’ => $url);
  14.       }
  15.      
  16.        /**
  17.         * Ustawienie tablicy z regułami
  18.         *
  19.         * @param array $rules
  20.         */     
  21.        public function setRules($rules){
  22.            $this -> rules = $rules;
  23.        }
  24.      
  25.        /**
  26.         * Sprawdzanie wzoru z regułki.
  27.         * Jeżeli się zgadza podmiana urla i
  28.         * wykonanie NiceUrlsRouter::parse();
  29.         *
  30.         * @return bool
  31.         */
  32.        public function parse(){
  33.          
  34.            foreach($this -> rules as $name => $rule){           
  35.              $pattern = "#^".$this -> prepare($rule[‘pattern’])."$#";
  36.              if(preg_match($pattern, $this -> input)){
  37.                  $this -> setInput(preg_replace($pattern, $rule[‘url’], $this -> input));
  38.                  return parent::parse();
  39.                  break;
  40.              }
  41.            }
  42.                  
  43.            return parent::parse();
  44.        }
  45.      
  46.  }

Używanie tego routera różni się jedynie tym że przed parsowaniem powinniśmy zadeklarować regułki:

PHP [Show Plain Code]:
  1. $rewriteRouter = new RewriteRouter();
  2.  $rewriteRouter -> setInput($_SERVER[‘PATH_INFO’]);
  3.  
  4.  $rewriteRouter -> addRule(‘news’, ‘/news/(\d+)’, ‘/news/showOne/$1′);
  5.  $rewriteRouter -> addRule(‘pages’, ‘/strona/([a-z1-9\-\/]+)’, ‘/pages/showByPath/$1′);
  6.  
  7.  if($rewriteRouter -> parse()){
  8.    echo ‘Kontroler: ‘.$rewriteRouter -> controller.‘<br />’;
  9.    echo ‘Akcja: ‘.$rewriteRouter -> action.‘<br />’;
  10.    echo ‘Parametry: ‘;
  11.    print_r($rewriteRouter -> params);
  12.  }

Nasz router przy parsowaniu wykonuje teraz jedną czynność więcej. Sprawdza czy input zgadza się z wyrażeniem regularnym zawartym w regule. Jeżeli tak, to podmienia do z url zadeklarowanym do podmiany i ten url daje do parsowania metodzie rodzica - NiceUrlsRouter::parse().

Podsumowanie

Stworzone w artykule routery są bardzo proste. Służą one raczej jako przykładowa implementacja. Można do nich dodać bardzo dużo innych funkcjonalności. Jako przykład może posłużyć świetny router frameworka Agavi. W porównaniu do naszych 2 routerów routing w Agavi jest o wiele bardziej złożony i posiada większe możliwości. Całość składa się z kilkunastu plików, a drogi definiuje się w oddzielnym pliku xml. Można tam zagnieżdżać drogi, ustawić callback, opcje odpowiedzialne za i18n ;)

]]> http://strzalek.net/blog/3/przyjazne-urle-piszemy-router/feed http://strzalek.net/blog/3/przyjazne-urle-piszemy-router Hello world! http://feedproxy.google.com/~r/strzalek-devblog/~3/rl0gzDIJJ4s/hello-world http://strzalek.net/blog/1/hello-world#comments Sat, 01 Sep 2007 12:15:06 +0000 Strzałek Witam po dłuższej przerwie. Nie było mnie przez jakiś czas. Spowodowane było to przesiadką na … prosiaka ;) Mowa o naszym serwerze, z którym było trochę zabawy, co odbiło się na moim blogu - straciłem wszystkie dane. Nie zrobiłem backupu na czas i po notkach zostały wspomnienia. Mam zapisane jedynie 3 najciekawsze które na dniach przeredaguję, wzbogacę i ponownie opublikuję.

Pięknie dziękuję tiraeth’owi za nowe logo.

]]> http://strzalek.net/blog/1/hello-world/feed http://strzalek.net/blog/1/hello-world