Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00266 006944 14488596 na godz. na dobę w sumie
PHP. Obiekty, wzorce, narzędzia. Wydanie III - książka
PHP. Obiekty, wzorce, narzędzia. Wydanie III - książka
Autor: Liczba stron: 496
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3026-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> php - programowanie
Porównaj ceny (książka, ebook, audiobook).

Kompendium wiedzy na temat obiektów w PHP!

PHP jest dowodem na to, że czas potrzebny na opanowanie języka programowania oraz uzyskanie pierwszych efektów wcale nie musi zmierzać do nieskończoności! Łatwa konfiguracja środowiska programistycznego, tanie i ogólnodostępne serwery do umieszczania własnych aplikacji oraz witryn opartych o PHP, a ponadto duża liczba publikacji i chętna do pomocy społeczność użytkowników sprawiły, że język PHP błyskawicznie zdobył uznanie. W ciągu ostatnich lat język ten przeszedł obiektową rewolucję. Dostęp do zaawansowanych narzędzi, wzrost świadomości oraz zmiany w samym języku wystarczyły, by programiści coraz powszechniej zaczęli stosować techniki obiektowe w trakcie tworzenia rozwiązań w PHP.

W trakcie lektury tej książki zostaniesz wprowadzony w świat obiektów w PHP. Poznasz pojęcia ściśle związane z tym podejściem do programowania - klasa, obiekt, metoda, dziedziczenie czy widoczność zmiennych to słowa, które nabiorą dla Ciebie nowego znaczenia. Na kolejnych stronach przeczytasz o tym, jak obsługiwać wyjątkowe sytuacje, korzystać z interfejsów, domknięć i funkcji zwrotnych. Ponadto zdobędziesz wiedzę na temat projektowania obiektowego. Zasada hermetyzacji i diagramy UML staną się dla Ciebie całkowicie jasne. Autor bardzo dużo czasu poświęca wzorcom projektowym w PHP. Dzięki nim Twój kod stanie się przejrzysty, a nawet najtrudniejsze problemy będą zdecydowanie łatwiejsze do rozwiązania. Na sam koniec sprawdzisz, jak najlepiej dokumentować kod, korzystać z dodatkowych bibliotek oraz wykonywać testy jednostkowe. Książka ta stanowi kompendium wiedzy na temat obiektowego programowania w PHP, dlatego musi się znaleźć na półce każdej osoby choć trochę związanej z tym popularnym językiem programowania!

Twórz lepszy, czytelniejszy i wydajniejszy kod w PHP!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Idź do • Spis treści • Przykładowy rozdział • Skorowidz Katalog książek • Katalog online • Zamów drukowany katalog Twój koszyk • Dodaj do koszyka Cennik i informacje • Zamów informacje o nowościach • Zamów cennik Czytelnia • Fragmenty książek online Kontakt Helion SA ul. Kościuszki 1c 44-100 Gliwice tel. 32 230 98 63 e-mail: helion@helion.pl © Helion 1991–2011 PHP. Obiekty, wzorce, narzędzia. Wydanie III Autor: Matt Zandstra Tłumaczenie: Przemysław Szeremiota ISBN: 978-83-246-3026-4 Tytuł oryginału: PHP Objects, Patterns and Practice, Third Edition Format: 168×237, stron: 496 Kompendium wiedzy na temat obiektów w PHP! • Jak wykorzystać techniki obiektowe w PHP? • Jaka obsługiwać wyjątkowe sytuacje? • Jak zapewnić ciągłą integrację kodu? PHP jest dowodem na to, że czas potrzebny na opanowanie języka programowania oraz uzyskanie pierwszych efektów wcale nie musi zmierzać do nieskończoności! Łatwa konfiguracja środowiska programistycznego, tanie i ogólnodostępne serwery do umieszczania własnych aplikacji oraz witryn opartych o PHP, a ponadto duża liczba publikacji i chętna do pomocy społeczność użytkowników sprawiły, że język PHP błyskawicznie zdobył uznanie. W ciągu ostatnich lat język ten przeszedł obiektową rewolucję. Dostęp do zaawansowanych narzędzi, wzrost świadomości oraz zmiany w samym języku wystarczyły, by programiści coraz powszechniej zaczęli stosować techniki obiektowe w trakcie tworzenia rozwiązań w PHP. W trakcie lektury tej książki zostaniesz wprowadzony w świat obiektów w PHP. Poznasz pojęcia ściśle związane z tym podejściem do programowania – klasa, obiekt, metoda, dziedziczenie czy widoczność zmiennych to słowa, które nabiorą dla Ciebie nowego znaczenia. Na kolejnych stronach przeczytasz o tym, jak obsługiwać wyjątkowe sytuacje, korzystać z interfejsów, domknięć i funkcji zwrotnych. Ponadto zdobędziesz wiedzę na temat projektowania obiektowego. Zasada hermetyzacji i diagramy UML staną się dla Ciebie całkowicie jasne. Autor bardzo dużo czasu poświęca wzorcom projektowym w PHP. Dzięki nim Twój kod stanie się przejrzysty, a nawet najtrudniejsze problemy będą zdecydowanie łatwiejsze do rozwiązania. Na sam koniec sprawdzisz, jak najlepiej dokumentować kod, korzystać z dodatkowych bibliotek oraz wykonywać testy jednostkowe. Książka ta stanowi kompendium wiedzy na temat obiektowego programowania w PHP, dlatego musi się znaleźć na półce każdej osoby choć trochę związanej z tym popularnym językiem programowania! • Historia obiektowości w PHP • Elementarz pojęć z programowania obiektowego • Obsługa błędów • Wykorzystanie interfejsów, klas abstrakcyjnych oraz metod statycznych • Projektowanie obiektowe – diagramy UML, hermetyzacja • Wzorce projektowe • Wykorzystanie PEAR i Pyrus • Generowanie dokumentacji za pomocą phpDocumentor • Zarządzanie kodem za pomocą Subversion • Przygotowywanie testów jednostkowych • Automatyzacja instalacji • Ciągła integracja kodu Twórz lepszy, czytelniejszy i wydajniejszy kod w PHP! Spis treĂci O autorze .....................................................................................................................................11 O recenzencie technicznym ..........................................................................................................13 PodziÚkowania ............................................................................................................................15 Przedmowa do trzeciego wydania .................................................................................................17 CzÚĂÊ I Wprowadzenie ................................................................................. 19 Rozdziaï 1. PHP — projektowanie i zarzÈdzanie ......................................................................21 Problem ................................................................................................................................................. 21 PHP a inne języki programowania .................................................................................................... 22 O książce ............................................................................................................................................... 24 Obiekty ........................................................................................................................................... 24 Wzorce ............................................................................................................................................ 24 Narzędzia ....................................................................................................................................... 25 Nowości w trzecim wydaniu ....................................................................................................... 26 Podsumowanie ..................................................................................................................................... 26 CzÚĂÊ II Obiekty ............................................................................................. 27 Rozdziaï 2. PHP a obiekty ........................................................................................................29 Nieoczekiwany sukces obiektów w PHP ........................................................................................... 29 PHP/FI — u zarania języka ......................................................................................................... 29 PHP3 — składniowy lukier ......................................................................................................... 30 Cicha rewolucja — PHP4 ............................................................................................................ 30 PHP5 — nieuchronne zmiany .................................................................................................... 31 W przyszłości ........................................................................................................................................ 32 Debata obiektowa — za czy przeciw? ............................................................................................... 32 Podsumowanie ..................................................................................................................................... 32 Rozdziaï 3. Obiektowy elementarz ..........................................................................................33 Klasy i obiekty ...................................................................................................................................... 33 Pierwsza klasa ................................................................................................................................ 33 Pierwszy obiekt (lub dwa) ........................................................................................................... 34 Definiowanie składowych klasy ......................................................................................................... 35 SPIS TRE¥CI Rozdziaï 4. Metody .................................................................................................................................................. 37 Metoda konstrukcji obiektu ........................................................................................................ 38 Typy argumentów metod ................................................................................................................... 39 Typy elementarne ......................................................................................................................... 40 Typy obiektowe ............................................................................................................................. 42 Dziedziczenie ........................................................................................................................................ 44 Problemy związane z dziedziczeniem ........................................................................................ 44 Stosowanie dziedziczenia ............................................................................................................. 48 Zarządzanie dostępem do klasy — słowa public, private i protected ................................... 52 Podsumowanie ..................................................................................................................................... 56 Zaawansowana obsïuga obiektów ........................................................................57 Metody i składowe statyczne .............................................................................................................. 57 Składowe stałe ...................................................................................................................................... 60 Klasy abstrakcyjne ............................................................................................................................... 61 Interfejsy ................................................................................................................................................ 62 Późne wiązanie statyczne: słowo static ............................................................................................. 64 Obsługa błędów .................................................................................................................................... 66 Wyjątki ........................................................................................................................................... 68 Klasy i metody finalne ......................................................................................................................... 72 Przechwytywanie chybionych wywołań ........................................................................................... 73 Definiowanie destruktorów ................................................................................................................ 77 Wykonywanie kopii obiektów ........................................................................................................... 78 Reprezentacja obiektu w ciągach znaków ........................................................................................ 80 Wywołania zwrotne, funkcje anonimowe i domknięcia .................................................................. 81 Podsumowanie ..................................................................................................................................... 85 Rozdziaï 5. NarzÚdzia obiektowe .............................................................................................87 PHP a pakiety ....................................................................................................................................... 87 Pakiety i przestrzenie nazw w PHP ............................................................................................ 87 Ratunek — przestrzenie nazw ..................................................................................................... 88 Symulowanie systemu pakietów na bazie systemu plików ..................................................... 92 Nazwy à la PEAR .......................................................................................................................... 93 Ścieżki przeszukiwania ................................................................................................................. 93 Automatyczne wczytywanie kodu .............................................................................................. 95 Klasy i funkcje pomocnicze ................................................................................................................ 96 Szukanie klasy ................................................................................................................................ 97 Badanie obiektów i klas ................................................................................................................ 98 Badanie metod ............................................................................................................................... 99 Badanie składowych ................................................................................................................... 100 Badanie relacji dziedziczenia ..................................................................................................... 100 Badanie wywołań metod ............................................................................................................ 101 Interfejs retrospekcji — Reflection API .......................................................................................... 102 Zaczynamy ................................................................................................................................... 102 Pora zakasać rękawy ................................................................................................................... 103 Badanie klasy ............................................................................................................................... 104 Badanie metod ............................................................................................................................. 106 Badanie argumentów metod ..................................................................................................... 107 Korzystanie z retrospekcji ......................................................................................................... 108 Podsumowanie ................................................................................................................................... 111 4 SPIS TRE¥CI Rozdziaï 6. Obiekty a projektowanie obiektowe ...................................................................113 Czym jest projektowanie? ................................................................................................................. 113 Programowanie obiektowe i proceduralne .................................................................................... 114 Odpowiedzialność ...................................................................................................................... 117 Spójność ....................................................................................................................................... 117 Sprzęganie .................................................................................................................................... 118 Ortogonalność ............................................................................................................................. 118 Zasięg klas ........................................................................................................................................... 118 Polimorfizm ........................................................................................................................................ 119 Hermetyzacja ...................................................................................................................................... 121 Nieważne jak ....................................................................................................................................... 122 Cztery drogowskazy .......................................................................................................................... 122 Zwielokrotnianie kodu ............................................................................................................... 123 Przemądrzałe klasy ..................................................................................................................... 123 Złota rączka ................................................................................................................................. 123 Za dużo warunków ..................................................................................................................... 123 Język UML .......................................................................................................................................... 123 Diagramy klas .............................................................................................................................. 124 Diagramy sekwencji ................................................................................................................... 129 Podsumowanie ................................................................................................................................... 131 CzÚĂÊ III Wzorce ........................................................................................... 133 Rozdziaï 7. Czym sÈ wzorce projektowe? Do czego siÚ przydajÈ? .........................................135 Czym są wzorce projektowe? ........................................................................................................... 135 Wzorzec projektowy .......................................................................................................................... 137 Nazwa ........................................................................................................................................... 137 Problem ........................................................................................................................................ 138 Rozwiązanie ................................................................................................................................. 138 Konsekwencje .............................................................................................................................. 138 Format wzorca według Bandy Czworga ......................................................................................... 138 Po co nam wzorce projektowe? ....................................................................................................... 139 Wzorzec projektowy definiuje problem .................................................................................. 139 Wzorzec projektowy definiuje rozwiązanie ............................................................................ 139 Wzorce projektowe są niezależne od języka programowania .............................................. 139 Wzorce definiują słownictwo .................................................................................................... 140 Wzorce są wypróbowane ........................................................................................................... 140 Wzorce mają współpracować .................................................................................................... 141 Wzorce promują prawidła projektowe .................................................................................... 141 Wzorce projektowe a PHP ............................................................................................................... 141 Podsumowanie ................................................................................................................................... 141 Rozdziaï 8. Wybrane prawidïa wzorców ................................................................................143 Olśnienie wzorcami ........................................................................................................................... 143 Kompozycja i dziedziczenie ............................................................................................................. 144 Problem ........................................................................................................................................ 144 Zastosowanie kompozycji .......................................................................................................... 147 Rozprzęganie ...................................................................................................................................... 149 Problem ........................................................................................................................................ 149 Osłabianie sprzężenia ................................................................................................................. 150 5 SPIS TRE¥CI Kod ma używać interfejsów, nie implementacji ............................................................................ 151 Zmienne koncepcje ........................................................................................................................... 153 Nadmiar wzorców ............................................................................................................................. 153 Wzorce ................................................................................................................................................ 154 Wzorce generowania obiektów ................................................................................................. 154 Wzorce organizacji obiektów i klas .......................................................................................... 154 Wzorce zadaniowe ...................................................................................................................... 154 Wzorce korporacyjne ................................................................................................................. 154 Wzorce baz danych ..................................................................................................................... 154 Podsumowanie ................................................................................................................................... 154 Rozdziaï 9. Generowanie obiektów .......................................................................................157 Generowanie obiektów — problemy i rozwiązania ...................................................................... 157 Wzorzec Singleton ............................................................................................................................. 161 Problem ........................................................................................................................................ 161 Implementacja ............................................................................................................................. 162 Konsekwencje .............................................................................................................................. 163 Wzorzec Factory Method ................................................................................................................. 164 Problem ........................................................................................................................................ 164 Implementacja ............................................................................................................................. 166 Konsekwencje .............................................................................................................................. 167 Wzorzec Abstract Factory ................................................................................................................ 168 Problem ........................................................................................................................................ 168 Implementacja ............................................................................................................................. 169 Konsekwencje .............................................................................................................................. 171 Prototyp ........................................................................................................................................ 172 Problem ........................................................................................................................................ 173 Implementacja ............................................................................................................................. 173 Ależ to oszustwo! ............................................................................................................................... 175 Podsumowanie ................................................................................................................................... 177 Rozdziaï 10. Wzorce elastycznego programowania obiektowego ...........................................179 Strukturalizacja klas pod kątem elastyczności obiektów ................................................................. 179 Wzorzec Composite .......................................................................................................................... 179 Problem ........................................................................................................................................ 180 Implementacja ............................................................................................................................. 182 Konsekwencje .............................................................................................................................. 185 Composite — podsumowanie ................................................................................................... 188 Wzorzec Decorator ............................................................................................................................ 188 Problem ........................................................................................................................................ 188 Implementacja ............................................................................................................................. 190 Konsekwencje .............................................................................................................................. 193 Wzorzec Facade ................................................................................................................................. 193 Problem ........................................................................................................................................ 193 Implementacja ............................................................................................................................. 195 Konsekwencje .............................................................................................................................. 195 Podsumowanie ................................................................................................................................... 196 6 SPIS TRE¥CI Rozdziaï 11. Reprezentacja i realizacja zadañ ..........................................................................197 Wzorzec Interpreter .......................................................................................................................... 197 Problem ........................................................................................................................................ 197 Implementacja ............................................................................................................................. 198 Ciemne strony wzorca Interpreter ........................................................................................... 204 Wzorzec Strategy ............................................................................................................................... 205 Problem ........................................................................................................................................ 205 Implementacja ............................................................................................................................. 206 Wzorzec Observer ............................................................................................................................. 210 Implementacja ............................................................................................................................. 211 Wzorzec Visitor ................................................................................................................................. 216 Problem ........................................................................................................................................ 216 Implementacja ............................................................................................................................. 217 Wady wzorca Visitor .................................................................................................................. 221 Wzorzec Command ........................................................................................................................... 222 Problem ........................................................................................................................................ 222 Implementacja ............................................................................................................................. 222 Podsumowanie ................................................................................................................................... 225 Rozdziaï 12. Wzorce korporacyjne ...........................................................................................227 Przegląd architektury ........................................................................................................................ 227 Wzorce .......................................................................................................................................... 228 Aplikacje i warstwy ..................................................................................................................... 228 Małe oszustwo na samym początku ................................................................................................ 231 Wzorzec Registry ........................................................................................................................ 231 Implementacja ............................................................................................................................. 232 Warstwa prezentacji .......................................................................................................................... 240 Wzorzec Front Controller ......................................................................................................... 240 Wzorzec Application Controller .............................................................................................. 249 Wzorzec Page Controller ........................................................................................................... 259 Wzorce Template View i Helper View .................................................................................... 263 Warstwa logiki biznesowej ............................................................................................................... 266 Wzorzec Transaction Script ...................................................................................................... 266 Wzorzec Domain Model ............................................................................................................ 270 Podsumowanie ................................................................................................................................... 273 Rozdziaï 13. Wzorce bazodanowe ...........................................................................................275 Warstwa danych ................................................................................................................................. 275 Wzorzec Data Mapper ...................................................................................................................... 276 Problem ........................................................................................................................................ 276 Implementacja ............................................................................................................................. 276 Wzorzec Identity Map ...................................................................................................................... 288 Problem ........................................................................................................................................ 288 Implementacja ............................................................................................................................. 288 Konsekwencje .............................................................................................................................. 291 Wzorzec Unit of Work ...................................................................................................................... 291 Problem ........................................................................................................................................ 291 Implementacja ............................................................................................................................. 291 Konsekwencje .............................................................................................................................. 295 7 SPIS TRE¥CI Wzorzec Lazy Load ............................................................................................................................ 295 Problem ........................................................................................................................................ 295 Implementacja ............................................................................................................................. 296 Konsekwencje .............................................................................................................................. 297 Wzorzec Domain Object Factory .................................................................................................... 297 Problem ........................................................................................................................................ 298 Implementacja ............................................................................................................................. 298 Konsekwencje .............................................................................................................................. 299 Wzorzec Identity Object ................................................................................................................... 300 Problem ........................................................................................................................................ 300 Implementacja ............................................................................................................................. 301 Konsekwencje .............................................................................................................................. 305 Wzorce Selection Factory i Update Factory .................................................................................. 306 Problem ........................................................................................................................................ 306 Implementacja ............................................................................................................................. 306 Konsekwencje .............................................................................................................................. 309 Co zostało z wzorca Data Mapper? ................................................................................................. 309 Podsumowanie ................................................................................................................................... 311 CzÚĂÊ IV NarzÚdzia ....................................................................................... 313 Rozdziaï 14. Dobre (i zïe) praktyki ...........................................................................................315 Nie tylko kod ...................................................................................................................................... 315 Pukanie do otwartych drzwi ............................................................................................................ 316 Jak to zgrać? ........................................................................................................................................ 317 Uskrzydlanie kodu ............................................................................................................................. 318 Dokumentacja .................................................................................................................................... 319 Testowanie .......................................................................................................................................... 320 Ciągła integracja ................................................................................................................................. 320 Podsumowanie ................................................................................................................................... 321 Rozdziaï 15. PEAR i Pyrus ........................................................................................................323 Czym jest PEAR? ............................................................................................................................... 323 Pyrus .................................................................................................................................................... 324 Instalowanie pakietu ......................................................................................................................... 325 Kanały PEAR ............................................................................................................................... 327 Korzystanie z pakietu z PEAR ......................................................................................................... 328 Obsługa błędów w pakietach PEAR ......................................................................................... 330 Tworzenie własnych pakietów PEAR ............................................................................................. 333 Plik package.xml ......................................................................................................................... 333 Składniki pakietu ........................................................................................................................ 333 Element contents ........................................................................................................................ 335 Zależności ..................................................................................................................................... 337 Dookreślanie instalacji — phprelease ...................................................................................... 339 Przygotowanie pakietu do dystrybucji .................................................................................... 340 Konfigurowanie własnego kanału PEAR ................................................................................ 340 Podsumowanie ................................................................................................................................... 344 8 SPIS TRE¥CI Rozdziaï 16. Generowanie dokumentacji — phpDocumentor .................................................345 Po co nam dokumentacja? ................................................................................................................ 345 Instalacja ............................................................................................................................................. 346 Generowanie dokumentacji ............................................................................................................. 347 Komentarze DocBlock ...................................................................................................................... 348 Dokumentowanie klas ...................................................................................................................... 349 Dokumentowanie plików ................................................................................................................. 351 Dokumentowanie składowych ......................................................................................................... 351 Dokumentowanie metod .................................................................................................................. 352 Tworzenie odnośników w dokumentacji ....................................................................................... 354 Podsumowanie ................................................................................................................................... 356 Rozdziaï 17. ZarzÈdzanie wersjami projektu z Subversion .......................................................357 Po co mi kontrola wersji? ................................................................................................................. 357 Skąd wziąć Subversion? ..................................................................................................................... 358 Konfigurowanie repozytorium Subversion ................................................................................... 359 Tworzenie repozytorium ........................................................................................................... 359 Dostęp do repozytorium Subversion ....................................................................................... 360 Rozpoczynamy projekt ..................................................................................................................... 361 Aktualizacja i zatwierdzanie zmian ................................................................................................. 363 Dodawanie i usuwanie plików i katalogów .................................................................................... 367 Dodawanie pliku ......................................................................................................................... 367 Usuwanie pliku ........................................................................................................................... 367 Dodawanie katalogu ................................................................................................................... 367 Usuwanie katalogów ................................................................................................................... 368 Etykietowanie i eksportowanie wydania ........................................................................................ 368 Etykietowanie projektu .............................................................................................................. 368 Eksportowanie projektu ............................................................................................................. 369 Rozgałęzianie projektu ...................................................................................................................... 369 Podsumowanie ................................................................................................................................... 373 Rozdziaï 18. Testy jednostkowe z PHPUnit ..............................................................................375 Testy funkcjonalne i testy jednostkowe .......................................................................................... 375 Testowanie ręczne ............................................................................................................................. 376 PHPUnit .............................................................................................................................................. 378 Tworzenie przypadku testowego .............................................................................................. 378 Metody asercji ............................................................................................................................. 379 Testowanie wyjątków ................................................................................................................. 380 Uruchamianie zestawów testów ............................................................................................... 381 Ograniczenia ................................................................................................................................ 382 Atrapy i imitacje .......................................................................................................................... 383 Dobry test to oblany test ............................................................................................................ 386 Testy dla aplikacji WWW ................................................................................................................. 389 Przygotowanie aplikacji WWW do testów ............................................................................. 389 Proste testy aplikacji WWW ..................................................................................................... 391 Selenium ....................................................................................................................................... 393 Słowo ostrzeżenia ............................................................................................................................... 397 Podsumowanie ................................................................................................................................... 398 9 SPIS TRE¥CI Rozdziaï 19. Automatyzacja instalacji z Phing .........................................................................401 Czym jest Phing? ................................................................................................................................ 402 Pobieranie i instalacja pakietu Phing .............................................................................................. 402 Montowanie dokumentu kompilacji .............................................................................................. 403 Różnicowanie zadań kompilacji ............................................................................................... 404 Właściwości ................................................................................................................................. 406 Typy .............................................................................................................................................. 410 Operacje ....................................................................................................................................... 414 Podsumowanie ................................................................................................................................... 418 Rozdziaï 20. CiÈgïa integracja kodu .........................................................................................419 Czym jest ciągła integracja? .............................................................................................................. 419 Przygotowanie projektu do ciągłej integracji ......................................................................... 421 CruiseControl i phpUnderControl ................................................................................................. 427 Instalowanie CruiseControl ...................................................................................................... 427 Instalowanie phpUnderControl ............................................................................................... 428 Instalowanie projektu do integracji ciągłej ............................................................................. 430 Podsumowanie ................................................................................................................................... 439 CzÚĂÊ V Konkluzje ........................................................................................ 441 Rozdziaï 21. Obiekty, wzorce, narzÚdzia ..................................................................................443 Obiekty ................................................................................................................................................ 443 Wybór ........................................................................................................................................... 444 Hermetyzacja i delegowanie ...................................................................................................... 444 Osłabianie sprzężenia ................................................................................................................. 444 Zdatność do wielokrotnego stosowania kodu ........................................................................ 445 Estetyka ........................................................................................................................................ 445 Wzorce ................................................................................................................................................ 446 Co dają nam wzorce? .................................................................................................................. 446 Wzorce a zasady projektowe ..................................................................................................... 447 Narzędzia ............................................................................................................................................ 448 Testowanie ................................................................................................................................... 449 Dokumentacja ............................................................................................................................. 449 Zarządzanie wersjami ................................................................................................................. 449 Automatyczna kompilacja (instalacja) .................................................................................... 450 System integracji ciągłej ............................................................................................................. 450 Co pominęliśmy? ........................................................................................................................ 450 Podsumowanie ................................................................................................................................... 451 CzÚĂÊ VI Dodatki .......................................................................................... 453 Bibliografia ..........................................................................................................455 Dodatek A Książki ................................................................................................................................................. 455 Publikacje ............................................................................................................................................ 456 Witryny WWW ................................................................................................................................. 456 Prosty analizator leksykalny ................................................................................459 Skaner .................................................................................................................................................. 459 Analizator leksykalny ........................................................................................................................ 466 Skorowidz ............................................................................................................477 Dodatek B 10 R O Z D Z I A ’ 6 „ „ „ Obiekty a projektowanie obiektowe Znamy już dość szczegółowo mechanizmy obsługi obiektów w języku PHP, wypadałoby więc zostawić na boku szczegóły i zastanowić się nad najlepszymi możliwymi zastosowaniami poznanych narzędzi. W niniejszym rozdziale wprowadzę Cię w kwestie oddalone nieco od obiektów, a bliższe projektowaniu. Przyjrzymy się między innymi UML, czyli efektywnemu graficznemu językowi opisu systemów obiektowych. Rozdział będzie traktował o: x Podstawach projektowania — co rozumieć pod pojęciem projektowania i w czym projektowanie obiektowe różni się od proceduralnego. x Zasięgu klas — jak decydować o zawartości i odpowiedzialności klas. x Hermetyzacji — czyli ukrywaniu implementacji i danych za interfejsami. x Polimorfizmie — czyli stosowaniu wspólnych typów bazowych dla uzyskania transparentnej podmiany specjalizowanych typów pochodnych. x Języku UML — zastosowaniach diagramów w opisach architektur obiektowych. Czym jest projektowanie? Jedno ze znaczeń pojęcia „projektowanie kodu” to definiowanie systemu — określanie dla systemu wymagań i zakresu jego zadań. Co system powinien robić? Czego potrzebuje do realizacji swoich zadań? Jakie dane system generuje? Czy spełniają one wyrażone uprzednio wymagania? Na niższym poziomie projektowanie oznacza proces definiowania uczestników systemu i rozpoznawania zachodzących pomiędzy nimi relacji. W tym rozdziale zajmiemy się właśnie projektowaniem w tym drugim ujęciu, a więc klasami i obiektami oraz ich powiązaniami. Jak rozpoznać elementy systemu? System obiektowy składa się z klas. Należy zdecydować o naturze poszczególnych klas uczestniczących w systemie. Klasy składają się po części z metod, więc definiując klasy, trzeba zdecydować o grupowaniu metod. Klasy często uczestniczą też w relacjach dziedziczenia, mających im zapewnić spełnianie wymogów wspólnych dla poszczególnych części systemu interfejsów. Pierwsze wyzwanie w projektowaniu systemu tkwi właśnie w rozpoznaniu i wytypowaniu tych interfejsów. Klasy mogą jednak wchodzić również w inne relacje. Można bowiem tworzyć klasy składające się z innych klas i typów albo utrzymujące listy egzemplarzy innych typów. Klasy mogą korzystać z obiektów zewnętrznych. Klasy dysponują więc wbudowanym potencjałem do realizowania relacji kompozycji i użycia (na przykład za pośrednictwem narzucania typów obiektowych w sygnaturach metod), ale właściwe relacje zawiązują się dopiero w czasie wykonania, co zwiększa elastyczność projektu. W rozdziale zaprezentowane zostaną sposoby modelowania tego rodzaju zależności; będą one podstawą do omówienia zawartego w kolejnej części książki. CZ}¥m II „ OBIEKTY W ramach procesu projektowego należy również decydować, kiedy dana operacja należy do danego typu, a kiedy powinna należeć do innego typu, wykorzystywanego przez dany. Każdy etap projektowania oznacza nowe wybory i decyzje; jedne z nich prowadzą do elegancji i przejrzystości, inne mogą się na decydencie zemścić. Rozdział ten będzie w części poświęcony pewnym kwestiom, których rozpoznanie jest pomocne w podejmowaniu właściwych decyzji. Programowanie obiektowe i proceduralne Czym różni się kod obiektowy od tradycyjnego kodu proceduralnego? Najłatwiej powiedzieć, że główna różnica tkwi w obecności obiektów. Nie jest to jednak stwierdzenie ani odkrywcze, ani prawdziwe. Przecież w języku PHP obiekty mogą być z powodzeniem wykorzystywane w kodzie proceduralnym. Na porządku dziennym jest również definiowanie klas opartych na kodzie proceduralnym. Obecność klas i obiektów nie jest więc równoznaczna z obiektowością — nawet w językach takich jak Java, gdzie większość elementów programu to obiekty. Jedną z kluczowych różnic pomiędzy kodem obiektowym a proceduralnym odnajdujemy w podziale odpowiedzialności. Kod proceduralny przyjmuje postać sekwencji poleceń i wywołań metod. Do obsługi różnych stanów programu wydziela się kod kontrolujący. Taki model odpowiedzialności prowokuje powielanie kodu i uściślanie zależności pomiędzy elementami projektu. W kodzie obiektowym mamy zaś do czynienia z próbą minimalizacji owych zależności przez przekładanie odpowiedzialności za różne zadania na obiekty rezydujące w systemie. W tym rozdziale przedstawię przykładowy, uproszczony problem i przeanalizuję jego proceduralne i obiektowe rozwiązania. Załóżmy, że zadanie polega na skonstruowaniu narzędzia odczytu i zapisu plików konfiguracyjnych. Ponieważ najbardziej interesuje nas ogólna struktura kodu, nie będziemy zagłębiać się w żadnym z przypadków w szczegóły implementacyjne. Zacznijmy od podejścia proceduralnego. Odczytywać i zapisywać będziemy dane tekstowe w formacie: klucz:wartoĂÊ Wystarczą nam do tego dwie funkcje: function readParams($sourceFile) { $params = array(); // wczytaj parametry z pliku $sourceFile… return $params; } function writeParams($params, $destFile) { // zapisz parametry do pliku $destFile… } Funkcja readParams() wymaga przekazania jako argumentu wywołania nazwy pliku źródłowego. W jej ciele następuje próba otwarcia pliku, a potem odczyt kolejnych wierszy tekstu. Na podstawie wyszukiwanych w poszczególnych wierszach par kluczy i wartości konstruowana jest asocjacyjna tablica parametrów zwracana następnie do wywołującego. Funkcja writeParams() przyjmuje z kolei na wejście tablicę asocjacyjną i ścieżkę dostępu do pliku docelowego. W implementowanej w ciele funkcji pętli przegląda tablicę, zapisując wyodrębniane z niej pary klucz i wartość w pliku docelowym. Oto kod używający obu funkcji: $file = ./param.txt ; $array[ klucz1 ] = wartoĂÊ1 ; $array[ klucz2 ] = wartoĂÊ2 ; $array[ klucz3 ] = wartoĂÊ3 ; writeParams($array, $file); // zapis tablicy parametrów do pliku $output = readParams($file); // odczyt tablicy parametrów z pliku print_r($output); 114 ROZDZIA’ 6. „ OBIEKTY A PROJEKTOWANIE OBIEKTOWE Kod jest, jak widać, stosunkowo zwięzły i nie powinien sprawiać problemów konserwatorskich. Do utworzenia i zapisania pliku param.txt użyjemy wywołania writeParams(), którego zadaniem jest utrwalenie par klucz – wartość: klucz1:wartoĂÊ1 klucz2:wartoĂÊ2 klucz3:wartoĂÊ3 Niestety, dowiadujemy się właśnie, że narzędzie powinniśmy przystosować do obsługi prostych plików XML o następującym formacie: params param key klucz /key val wartoĂÊ /val /param /params Rozpoznanie formatu zapisu pliku powinno się odbywać na podstawie rozszerzenia pliku — dla plików z rozszerzeniem .xml należałoby wszcząć procedurę odczytu w formacie XML. Choć i tym razem poradzimy sobie z zadaniem, zagraża nam komplikacja kodu i zwiększenie uciążliwości utrzymania (konserwacji). Mamy teraz dwie możliwości. Albo będziemy sprawdzać rozszerzenie pliku parametrów w kodzie zewnętrznym, albo wewnątrz funkcji odczytujących i zapisujących. Spróbujmy oprogramować drugą z opcji: function readParams($source) { $params = array(); if (preg_match( /\.xml$/i , $source)) { // odczyt parametrów z pliku XML } else { // odczyt parametrów z pliku tekstowego } return $params; } function writeParams($params, $source) { if (preg_match( /\.xml$/i , $source)) { // zapis parametrów do pliku XML } else { // zapis parametrów do pliku tekstowego } } „ Uwaga Kod przykïadowy to zawsze sztuka kompromisu. Musi byÊ dostatecznie czytelny, aby ilustrowaï konkretnÈ koncepcjÚ bÈdě problem, co czÚsto oznacza koniecznoĂÊ rezygnacji z kontroli bïÚdów i elastycznoĂci. Innymi sïowy, prezentowany tu przykïad jest jedynie ilustracjÈ kwestii projektowania i powielania kodu, w ĝadnym razie nie bÚdÈc wzorcowÈ implementacjÈ parsowania i zapisywania danych w plikach. Z tego wzglÚdu wszÚdzie tam, gdzie nie jest to konieczne do omówienia, implementacja fragmentów kodu zostaïa zwyczajnie pominiÚta. Jak widać, w każdej z funkcji musieliśmy uwzględnić test rozszerzenia pliku parametrów. Tego rodzaju zwielokrotnienie kodu może być w przyszłości przyczyną problemów. Gdybyśmy bowiem stanęli w obliczu zadania obsługi kolejnego formatu pliku parametrów, musielibyśmy pamiętać o synchronizacji kodu sprawdzającego rozszerzenie w obu funkcjach. Spróbujmy to samo zadanie zrealizować za pomocą prostych klas. Na początek zdefiniujemy abstrakcyjną klasę bazową wyznaczającą interfejs typu: 115 CZ}¥m II „ OBIEKTY abstract class ParamHandler { protected $source; protected $params = array(); function __construct($source) { $this- source = $source; } function addParam($key, $val) { $this- params[$key] = $val; } function getAllParams() { return $this- params; } static function getInstance($filename) { if ( preg_match( /\.xml$/i , $filename)) return new XmlParamHandler($filename); } return new TextParamHandler($filename); } abstract function write(); abstract function read(); } W klasie tej definiujemy metodę addParam() służącą do uzupełniania tablicy parametrów i metodę getAllParams() dającą użytkownikom dostęp do kopii tablicy parametrów. Tworzymy też statyczną metodę getInstance(), której zadaniem jest analiza rozszerzenia nazwy pliku parametrów i zwrócenie użytkownikowi klasy specjalizowanej do obsługi pliku odpowiedniego formatu. Wreszcie definiujemy dwie abstrakcyjne metody: write() i read(), wymuszając ich implementację w klasach pochodnych i tym samym narzucając im wspólny interfejs obsługi plików. „ Uwaga Uĝycie metody statycznej do generowania obiektów klas pochodnych w klasie nadrzÚdnej jest bardzo wygodne. Taka decyzja projektowa ma jednak równieĝ wady. Typ ParamHandler jest teraz zasadniczo w swoich gïównych instrukcjach warunkowych ograniczony do pracy z konkretnymi klasami. A jeĂli zechcemy obsïuĝyÊ inny format danych? OczywiĂcie wïaĂciciel klasy ParamHandler moĝe zawsze uzupeïniÊ metodÚ getInstance(). Ale juĝ programista kodu klienckiego nie ma ïatwej moĝliwoĂci zmieniania klasy bibliotecznej (sama zmiana nie jest moĝe specjalnie trudna, ale pojawia siÚ problem ponownego aplikowania zmian w kolejnych wersjach bibliotek). Zagadnienia tworzenia obiektów omówiÚ bardziej szczegóïowo w rozdziale 9. Zdefiniujmy teraz owe klasy specjalizowane (znów gwoli przejrzystości przykładu pomijając szczegóły implementacyjne): class XmlParamHandler extends ParamHandler { function write() { // zapis tablicy parametrów $this- params w pliku XML } function read() { // odczyt pliku XML i wypełnienie tablicy parametrów $this- params } } class TextParamHandler extends ParamHandler { function write() { 116 ROZDZIA’ 6. „ OBIEKTY A PROJEKTOWANIE OBIEKTOWE // zapis tablicy parametrów $this- params w pliku tekstowym } function read() { // odczyt pliku tekstowego i wypełnienie tablicy parametrów $this- params } } Obie klasy ograniczają się do implementowania metod wirte() i read(). Każda z klas zapisuje i odczytuje parametry w odpowiednim dla siebie formacie. Użytkownik takiego zestawu klas będzie mógł zapisywać i odczytywać pliki parametrów niezależnie od ich formatu, całkowicie ignorując (i nie mając nawet tego świadomości) znaczenie rozszerzenia nazwy pliku: $test = ParamHandler::getInstance( ./params.xml ); $test- addParam( klucz1 , wartoĂÊ1 ); $test- addParam( klucz2 , wartoĂÊ2 ); $test- addParam( klucz3 , wartoĂÊ3 ); $test- write(); // zapis w formacie XML Równie łatwo można odczytywać parametry z pliku niezależnie od jego formatu: $test = ParamHandler::getInstance( ./params.txt ); $test- read(); // odczyt z pliku tekstowego Spróbujmy podsumować naukę płynącą z ilustracji tych dwóch metod projektowych. Odpowiedzialność Odpowiedzialność za decyzję co do formatu pliku w podejściu proceduralnym bierze na siebie użytkownik (kod kontrolujący) i czyni to nie raz, a dwa razy. Co prawda kod sprawdzający rozszerzenie został przeniesiony do wnętrza funkcji, ale nie przesłania to faktycznego przepływu sterowania. Wywołanie funkcji readParams() musi zawsze
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

PHP. Obiekty, wzorce, narzędzia. Wydanie III
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: