Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00380 010309 11037699 na godz. na dobę w sumie
PHP. Zaawansowane programowanie.  Vademecum profesjonalisty - książka
PHP. Zaawansowane programowanie. Vademecum profesjonalisty - książka
Autor: Liczba stron: 624
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-589-X Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> webmasterstwo >> php - programowanie
Porównaj ceny (książka, ebook, audiobook).

PHP to obecnie jeden z najpopularniejszych języków programowania służących do tworzenia aplikacji internetowych. Od początku jego istnienia wykorzystywano go do tworzenia dynamicznych witryn WWW. Dynamiczny rozwój sprawił, że możliwości jego zastosowania znacznie się poszerzyły. Obecnie używa się PHP do tworzenia aplikacji, które jeszcze niedawno wydawały się niemożliwe do napisania w tym języku. Początkowo wykorzystywany przez grono entuzjastów, z czasem stał się stabilną i dobrze udokumentowaną platformą programistyczną, liczącą się na rynku.

Książka 'PHP. Zaawansowane programowanie. Vademecum profesjonalisty' to pozycja dla tych, którzy chcą zostać ekspertami w dziedzinie tworzenia aplikacji w PHP. Opisuje najbardziej zaawansowane mechanizmy języka, pozwalające na zastosowanie go w złożonych aplikacjach. Przedstawia techniki programowania obiektowego, testowania jednostek leksykalnych, zagadnienia bezpieczeństwa, techniki buforowania oraz sposoby tworzenia skalowalnych aplikacji internetowych. W książce omówiono również dostrajanie wydajności oraz tworzenie rozszerzeń PHP. Wszystkie, nawet najbardziej skomplikowane kwestie zostały opisane w przejrzysty sposób i zilustrowane kompletnymi przykładami zastosowania w prawdziwych aplikacjach.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl PHP. Zaawansowane programowanie. Vademecum profesjonalisty Autor: George Schlossnagle T³umaczenie: W³odzimierz Gajda, Pawe³ Gonera, Rados³aw Meryk, Jacek Smycz ISBN: 83-7361-589-X Tytu³ orygina³u: Advanced PHP Programming Format: B5, stron: 624 PHP to obecnie jeden z najpopularniejszych jêzyków programowania s³u¿¹cych do tworzenia aplikacji internetowych. Od pocz¹tku jego istnienia wykorzystywano go do tworzenia dynamicznych witryn WWW. Dynamiczny rozwój sprawi³, ¿e mo¿liwoġci jego zastosowania znacznie siê poszerzy³y. Obecnie u¿ywa siê PHP do tworzenia aplikacji, które jeszcze niedawno wydawa³y siê niemo¿liwe do napisania w tym jêzyku. Pocz¹tkowo wykorzystywany przez grono entuzjastów, z czasem sta³ siê stabiln¹ i dobrze udokumentowan¹ platform¹ programistyczn¹, licz¹c¹ siê na rynku. Ksi¹¿ka „PHP. Zaawansowane programowanie. Vademecum profesjonalisty” to pozycja dla tych, którzy chc¹ zostaæ ekspertami w dziedzinie tworzenia aplikacji w PHP. Opisuje najbardziej zaawansowane mechanizmy jêzyka, pozwalaj¹ce na zastosowanie go w z³o¿onych aplikacjach. Przedstawia techniki programowania obiektowego, testowania jednostek leksykalnych, zagadnienia bezpieczeñstwa, techniki buforowania oraz sposoby tworzenia skalowalnych aplikacji internetowych. W ksi¹¿ce omówiono równie¿ dostrajanie wydajnoġci oraz tworzenie rozszerzeñ PHP. Wszystkie, nawet najbardziej skomplikowane kwestie zosta³y opisane w przejrzysty sposób i zilustrowane kompletnymi przyk³adami zastosowania w prawdziwych aplikacjach. • Styl kodowania • Programowanie obiektowe i wzorce projektowe • Obs³uga b³êdów • Korzystanie z szablonów Smarty • Testowanie modu³ów • Zarz¹dzanie wersjami — system CVS • Techniki buforowania • Dostêp do baz danych • Autoryzacja u¿ytkowników • Tworzenie ġrodowiska rozproszonego • Wykorzystanie us³ug sieciowych • Wydajnoġæ aplikacji • Tworzenie rozszerzeñ PHP 5RKUVTGħEK 1#WVQTG  5đQYQYUVúRPG 9UVúR  úħè+ +ORNGOGPVCELCKOGVQFQNQIKGRTQITCOQYCPKC 4QFKCđ 5V[NMQFQYCPKC  Wybór wygodnego stylu programowania ...................................................d.........................26 Formatowanie kodu i układ ...................................................d........................................26 Wcięcia ...................................................d...................................................d....................26 Długość wiersza...................................................d...................................................d.......28 Zastosowanie odstępów ...................................................d..............................................29 Zalecenia na temat SQL...................................................d..............................................29 Instrukcje sterujące ...................................................d...................................................d..30 Nazewnictwo symboli...................................................d...................................................d....35 Zmienne faktycznie globalne oraz stałe...................................................d......................36 Zmienne długowieczne ...................................................d...............................................38 Zmienne tymczasowe ...................................................d.................................................38 Nazwy wieloczłonowe...................................................d................................................39 Nazwy funkcji...................................................d...................................................d..........39 Nazwy klas ...................................................d...................................................d..............40 Nazwy metod...................................................d...................................................d...........40 Spójność nazw ...................................................d...................................................d.........40 Dopasowanie nazw zmiennych do nazw schematu...................................................d.....40 Unikanie mylącego kodu ...................................................d..................................................41 Unikanie korzystania z otwartych znaczników ...................................................d...........42 Unikanie korzystania z funkcji echo do tworzenia kodu HTML ...................................42 Rozsądne korzystanie z nawiasów ...................................................d..............................43 Dokumentacja ...................................................d...................................................d................43 Dokumentacja wewnątrz kodu...................................................d....................................44 Dokumentacja API...................................................d...................................................d...45 Dalsze lektury ...................................................d...................................................d................49 4QFKCđ 2TQITCOQYCPKGQDKGMVQYGRQRTGYQTEGRTQLGMVQYG  Wstęp do programowania obiektowego ...................................................d............................52 Dziedziczenie...................................................d...................................................d...........53 Hermetyzacja ...................................................d...................................................d...........54 Atrybuty i metody statyczne (klasowe)...................................................d.......................55 Metody specjalne ...................................................d...................................................d.....56 6 PHP. Zaawansowane programowanie. Vademecum profesjonalisty Krótkie wprowadzenie do wzorców projektowych ...................................................d...........57 Wzorzec Adaptor ...................................................d...................................................d.....58 Wzorzec Template ...................................................d...................................................d...62 Polimorfizm ...................................................d...................................................d.............63 Interfejsy i podpowiadanie typów...................................................d...............................65 Wzorzec Factory...................................................d...................................................d......67 Wzorzec Singleton...................................................d...................................................d...68 Przeciążanie ...................................................d...................................................d...................70 SPL i iteratory...................................................d...................................................d..........75 __call ()...................................................d...................................................d....................80 __autoload()...................................................d...................................................d.............82 Dalsze lektury ...................................................d...................................................d................83 4QFKCđ 1DUđWICDđúFÎY  Obsługa błędów ...................................................d...................................................d.............87 Wyświetlanie błędów...................................................d..................................................88 Rejestrowanie błędów...................................................d.................................................89 Ignorowanie błędów ...................................................d...................................................d90 Reagowanie na błędy ...................................................d..................................................90 Obsługa błędów zewnętrznych...................................................d..........................................92 Wyjątki ...................................................d...................................................d..........................94 Wykorzystanie hierarchii wyjątków ...................................................d...........................97 Przykład zastosowania wyjątków ...................................................d...............................99 Wyjątki kaskadowe...................................................d...................................................d104 Obsługa błędu działania konstruktora...................................................d.......................107 Instalowanie wysokopoziomowej procedury obsługi wyjątków..................................108 Kontrola poprawności danych ...................................................d..................................110 Kiedy korzystać z wyjątków? ...................................................d.........................................114 Dalsze lektury ...................................................d...................................................d..............114 4QFKCđ 4QFKCđ +ORNGOGPVCELCY2*2ōUCDNQP[KUKGè999 Smarty...................................................d...................................................d..........................116 Instalowanie Smarty ...................................................d.................................................116 Pierwszy szablon Smarty ...................................................d..........................................118 Pod maską skompilowanych szablonów...................................................d...................118 Struktury sterujące Smarty...................................................d........................................119 Funkcje Smarty i więcej...................................................d............................................122 Buforowanie w Smarty ...................................................d.............................................124 Zaawansowane funkcje Smarty ...................................................d................................126 Tworzenie własnego systemu szablonów...................................................d........................127 Dalsze lektury ...................................................d...................................................d..............128 +ORNGOGPVCELCY2*2ōUCOQFKGNPGUMT[RV[  Wprowadzenie do interfejsu wiersza poleceń PHP (CLI)..................................................133 Obsługa wejścia-wyjścia...................................................d.................................................133 Analizowanie argumentów wiersza poleceń ...................................................d...................136 Tworzenie procesów potomnych i zarządzanie nimi...................................................d.......138 Zamykanie współdzielonych zasobów...................................................d......................139 Współdzielenie zmiennych ...................................................d.......................................139 Porządkowanie po procesach potomnych ...................................................d.................139 Sygnały ...................................................d...................................................d..................141 4QFKCđ Spis treści 7 Tworzenie demonów...................................................d...................................................d....146 Zmiana katalogu roboczego...................................................d......................................147 Zmniejszanie uprawnień ...................................................d...........................................147 Gwarantowanie wyłączności ...................................................d....................................148 Łączymy wszystko razem — kontrolowanie usług...................................................d.........148 Dalsze lektury ...................................................d...................................................d..............157 6GUVQYCPKGOQFWđÎY  Wprowadzenie do testowania modułów...................................................d..........................160 Tworzenie testów dla automatycznego testowania modułów ......................................161 Pierwszy test modułu...................................................d................................................161 Dodawanie wielu testów...................................................d...........................................162 Tworzenie wewnętrznych i zewnętrznych testów modułów ..............................................163 Testy wewnątrz modułu...................................................d............................................164 Testy na zewnątrz modułu ...................................................d........................................165 Jednoczesne uruchamianie wielu testów...................................................d...................166 Dodatkowe funkcje w PHPUnit ...................................................d......................................168 Tworzenie opisowych komunikatów błędów...................................................d............168 Dodawanie większej liczby warunków testowych...................................................d....169 Zastosowanie metod setUp() oraz tearDown()...................................................d..........171 Dodawanie nasłuchów ...................................................d..............................................171 Wykorzystanie interfejsu graficznego...................................................d.......................173 Projektowanie sterowane testami ...................................................d....................................173 Kalkulator oceny Flescha...................................................d..........................................174 Testowanie klasy Word ...................................................d............................................175 Raport błędów...................................................d...................................................d........182 Testowanie modułów w środowisku WWW...................................................d...................184 Dalsze lektury ...................................................d...................................................d..............186 4QFKCđ CTæFCPKGħTQFQYKUMKGORTQITCOKUV[EP[O  Kontrola wersji...................................................d...................................................d.............188 Podstawy CVS...................................................d...................................................d.......189 Modyfikacja plików...................................................d..................................................192 Badanie różnic między plikami...................................................d.................................193 Mechanizmy usprawniające pracę wielu programistów na tym samym projekcie.......195 Znaczniki symboliczne ...................................................d.............................................197 Gałęzie...................................................d...................................................d...................198 Zarządzanie środowiskiem produkcyjnym oraz programistycznym ............................199 Zarządzanie pakietami ...................................................d...................................................d.203 Tworzenie pakietów i przenoszenie kodu ...................................................d.................204 Tworzenie pakietów plików binarnych...................................................d.....................207 Tworzenie pakietu Apache ...................................................d.......................................208 Tworzenie pakietu PHP ...................................................d............................................209 Dalsze lektury ...................................................d...................................................d..............209 4QFKCđ 2TQLGMVQYCPKGFQDTGIQ#2+  Projektowanie zapewniające możliwości rozszerzania i łatwość modyfikacji ...................212 Umieszczenie logiki w funkcjach ...................................................d.............................212 Tworzenie prostych klas i funkcji...................................................d.............................214 Przestrzenie nazw ...................................................d...................................................d..214 Zmniejszanie sprzężeń...................................................d..............................................216 Kodowanie defensywne ...................................................d..................................................217 Wprowadzenie standardowych konwencji...................................................d................218 Użycie technik oczyszczania danych ...................................................d........................218 Dalsze lektury ...................................................d...................................................d..............220 D:PDFPHP. Zaawansowane programowanie. Vademecum profesjonalisty\__Spis treści.doc 7 8 PHP. Zaawansowane programowanie. Vademecum profesjonalisty úħè++ $WHQTQYCPKG N 4QFKCđ 5VTQLGPKGY[FCLPQħEKGYPúVTPGL  Techniki dostrajania na poziomie języka ...................................................d........................223 Bufory kompilatora...................................................d...................................................d223 Optymalizatory ...................................................d...................................................d......226 Akceleratory HTTP ...................................................d..................................................227 Odwrotne serwery proxy...................................................d...........................................228 Dostrajanie systemu operacyjnego...................................................d............................233 Bufory proxy...................................................d...................................................d..........234 Aplikacje PHP przystosowane do wykorzystania buforowania .........................................234 Kompresja...................................................d...................................................d....................239 Dalsze lektury ...................................................d...................................................d..............240 Dokumenty RFC...................................................d...................................................d....240 Bufory kompilatora...................................................d...................................................d240 Bufory proxy...................................................d...................................................d..........240 Kompresja...................................................d...................................................d..............241 4QFKCđ $WHQTQYCPKGMQORQPGPVÎYFCP[EJ  Właściwości buforowania ...................................................d...............................................243 Identyfikacja komponentów danych, które nadają się do buforowania..............................245 Wybór właściwej strategii: klasy własne czy biblioteczne?...............................................245 Buforowanie wyników...................................................d...................................................d.246 Buforowanie w pamięci ...................................................d..................................................248 Bufor w postaci pojedynczego pliku...................................................d.........................248 Zarządzanie rozmiarem bufora ...................................................d.................................249 Współbieżny dostęp i spójność buforów...................................................d...................250 Buforowanie z wykorzystaniem plików DBM...................................................d................256 Współbieżny dostęp i spójność buforów...................................................d...................257 Weryfikacja bufora i zarządzanie ...................................................d.............................257 Buforowanie we współdzielonej pamięci...................................................d........................262 Buforowanie z wykorzystaniem plików cookie ...................................................d..............263 Zarządzanie rozmiarem bufora ...................................................d.................................267 Współbieżny dostęp i spójność buforów...................................................d...................268 Integracja buforowania w kodzie aplikacji...................................................d......................268 Buforowanie stron głównych...................................................d....................................270 Wykorzystanie modułu mod_rewrite serwera Apache w celu wykonania inteligentnego buforowania...................................................d......276 Buforowanie części stron...................................................d..........................................280 Implementacja bufora zapytań...................................................d..................................282 Dalsze lektury ...................................................d...................................................d..............284 4QFKCđ 2QPQYPGY[MQT[UVCPKGQDNKEGē  Wstęp z przykładem — ciągi Fibonacciego...................................................d....................285 Buforowanie danych do wielokrotnego użytku wewnątrz żądań .......................................291 Buforowanie wielokrotnie wykorzystywanych danych pomiędzy żądaniami....................293 Wielokrotne wykorzystywanie obliczeń w PHP ...................................................d.............297 Wyrażenia PCRE...................................................d...................................................d...297 Liczniki rozmiarów tablic...................................................d.........................................297 Dalsze lektury ...................................................d...................................................d..............298 Spis treści 9 úħè+++ #RNKMCELGTQRTQUQPG N 4QFKCđ 9URÎđRTCECDCCOKFCP[EJ  Działanie baz danych i zapytań...................................................d.......................................302 Analiza zapytań przy użyciu EXPLAIN ...................................................d...................305 Wyznaczanie zapytań wymagających profilowania...................................................d..306 Wzorce dostępu do bazy danych...................................................d.....................................308 Zapytania ad hoc...................................................d...................................................d....309 Metoda aktywnego rekordu ...................................................d......................................309 Metoda odwzorowania...................................................d..............................................312 Metoda zintegrowanego odwzorowania ...................................................d...................317 Dostrajanie dostępu do bazy danych ...................................................d...............................318 Ograniczanie zbioru wyników ...................................................d..................................318 Opóźniona inicjalizacja...................................................d.............................................320 Dalsze lektury ...................................................d...................................................d..............323 4QFKCđ #WVQT[CELCWľ[VMQYPKMÎYQTCDGRKGEGēUVYQUGULK Proste schematy uwierzytelniania ...................................................d...................................326 Proste uwierzytelnianie HTTP...................................................d..................................327 Przesyłanie danych identyfikacyjnych w zapytaniu...................................................d..327 Pliki cookie...................................................d...................................................d............328 Rejestrowanie użytkowników ...................................................d.........................................329 Ochrona haseł ...................................................d...................................................d........329 Zabezpieczenie haseł przed atakami socjotechnicznymi..............................................332 Utrzymanie uwierzytelniania: sprawdzenie, czy w dalszym ciągu komunikujemy się z tą samą osobą ...................................................d...................................................d.........333 Sprawdzenie, czy wartość $_SERVER [ REMOTE_IP ] pozostaje taka sama.............333 Sprawdzenie, czy wartość $_SERVER [ USER_AGENT ] pozostaje taka sama.........334 Wykorzystanie niezaszyfrowanych plików cookie ...................................................d...334 Zalecane rozwiązania...................................................d................................................334 Przykładowa implementacja uwierzytelniania...................................................d..........336 Pojedyncze logowanie...................................................d...................................................d..341 Implementacja techniki pojedynczego logowania ...................................................d....343 Dalsze lektury ...................................................d...................................................d..............348 4QFKCđ 1DUđWICUGULK Przechowywanie danych sesyjnych po stronie klienta...................................................d....350 Implementacja sesji przy użyciu plików cookie...................................................d........351 Nieco lepsza pułapka na myszy ...................................................d................................353 Przechowywanie danych sesyjnych po stronie serwera ...................................................d..354 Śledzenie identyfikatora sesji...................................................d....................................356 Krótkie wprowadzenie do sesji w PHP...................................................d.....................358 Niestandardowe funkcje obsługi sesji...................................................d.......................360 Usuwanie niepotrzebnych danych ...................................................d............................365 Przechowywanie stanu sesji po stronie serwera oraz po stronie klienta.......................366 4QFKCđ 6YQTGPKGħTQFQYKUMCTQRTQUQPGIQ  Czym jest klaster? ...................................................d...................................................d........369 Projektowanie klastrów — podstawy...................................................d..............................372 Planowanie niepowodzeń ...................................................d.........................................373 Zgodna współpraca...................................................d...................................................d373 Dystrybucja zawartości w klastrze...................................................d............................375 Skalowanie poziome ...................................................d.................................................376 Klastry wyspecjalizowane ...................................................d........................................377 D:PDFPHP. Zaawansowane programowanie. Vademecum profesjonalisty\__Spis treści.doc 9 10 PHP. Zaawansowane programowanie. Vademecum profesjonalisty Buforowanie w środowisku rozproszonym ...................................................d.....................377 Bufory scentralizowane ...................................................d............................................380 W pełni zdecentralizowany bufor wykorzystujący Spread ..........................................382 Skalowanie baz danych...................................................d...................................................d385 Tworzenie aplikacji korzystających z konfiguracji główny-podległy..........................388 Alternatywy replikacji ...................................................d..............................................390 Alternatywy systemów zarządzania relacyjnymi bazami danych ................................391 Dalsze lektury ...................................................d...................................................d..............392 4QFKCđ 42 ōYURÎđRTCECGFCNP[OKWUđWICOK XML-RPC...................................................d...................................................d....................394 Tworzenie serwera: implementacja interfejsu MetaWeblog ........................................396 Automatyczne wykrywanie usług XML-RPC ...................................................d..........400 SOAP ...................................................d...................................................d...........................402 WSDL...................................................d...................................................d....................404 Zamiana system.load w usługę SOAP ...................................................d......................406 Usługi WWW Amazon i typy złożone...................................................d......................409 Generowanie kodu proxy...................................................d..........................................411 Porównanie SOAP i XML-RPC...................................................d......................................411 Dalsze lektury ...................................................d...................................................d..............412 SOAP...................................................d...................................................d.....................412 XML-RPC ...................................................d...................................................d.............412 Dzienniki WWW ...................................................d...................................................d...413 Dostępne publicznie usługi WWW...................................................d...........................413 úħè+8 9[FCLPQħè N 4QFKCđ 6GUV[Y[FCLPQħEKCRNKMCELKōVGUVQYCPKGECđQħEKCRNKMCELK Pasywna identyfikacja wąskich gardeł...................................................d............................418 Generatory obciążenia...................................................d...................................................d..420 ab ...................................................d...................................................d...........................420 httperf ...................................................d...................................................d....................421 Daiquiri...................................................d...................................................d..................424 Dalsze lektury ...................................................d...................................................d..............424 4QFKCđ 2TQHKNQYCPKG Co jest potrzebne w programie profilującym PHP? ...................................................d........426 Programy profilujące...................................................d...................................................d....426 Instalacja i zastosowanie APD ...................................................d........................................427 Przykład śledzenia ...................................................d...................................................d.......429 Profilowanie większej aplikacji ...................................................d......................................431 Identyfikacja ogólnego braku efektywności...................................................d....................436 Usuwanie zbytecznej funkcjonalności ...................................................d............................438 Dalsze lektury ...................................................d...................................................d..............443 4QFKCđ 5[PVGV[EPGVGUV[Y[FCLPQħEK ōURTCYFCPKGDNQMÎYMQFWKHWPMELK Podstawy testowania wydajności ...................................................d....................................446 Tworzenie szablonu testów wydajności ...................................................d..........................447 Zestaw testów wydajności PEAR ...................................................d.............................448 Tworzenie funkcji testujących ...................................................d..................................450 Dodawanie randomizacji danych do wszystkich iteracji..............................................451 Usuwanie kosztów funkcji testujących ...................................................d.....................452 Dodawanie własnych informacji czasowych ...................................................d............453 Tworzenie testów bezpośrednich...................................................d..............................457 Spis treści 11 Przykłady testów wydajności...................................................d..........................................457 Dopasowanie znaków na początku ciągu...................................................d..................458 Rozszerzenia makr...................................................d...................................................d.459 Interpolacja i łączenie ...................................................d...............................................464 úħè8 /QľNKYQħEKTQUGTCPKCN 4QFKCđ KCđCPKGOCU[P[ GPFK2*2  Jak działa maszyna Zend: kody i tablice operacji ...................................................d...........470 Zmienne ...................................................d...................................................d.......................475 Funkcje ...................................................d...................................................d........................479 Klasy ...................................................d...................................................d............................480 Mechanizmy obsługi obiektów ...................................................d.................................482 Tworzenie obiektów ...................................................d.................................................483 Inne ważne struktury...................................................d.................................................483 Cykl życiowy żądania PHP...................................................d.............................................485 Warstwa SAPI ...................................................d...................................................d.......486 Jądro PHP ...................................................d...................................................d..............488 Interfejs rozszerzeń PHP...................................................d...........................................489 Interfejs Zend Extension...................................................d...........................................490 Jak pasują do siebie wszystkie części?...................................................d......................492 Dalsze lektury ...................................................d...................................................d..............492 4QFKCđ 4QUGTCPKG2*2ōEúħè+  Podstawy rozszerzania ...................................................d...................................................d.496 Tworzenie zrębu rozszerzenia...................................................d...................................496 Budowa i włączanie rozszerzenia ...................................................d.............................499 Wykorzystanie funkcji...................................................d..............................................500 Zarządzanie typami i pamięcią ...................................................d.................................502 Analiza ciągów ...................................................d...................................................d......505 Manipulacja typami ...................................................d..................................................506 Testowanie typów, konwersje i mechanizmy dostępu .................................................511 Korzystanie z zasobów ...................................................d.............................................514 Zwracanie błędów...................................................d...................................................d..519 Wykorzystanie punktów zaczepienia modułów...................................................d........519 Przykład: osłona klienta Spread ...................................................d......................................527 MINIT...................................................d...................................................d....................529 MSHUTDOWN...................................................d...................................................d.....529 Funkcje modułu ...................................................d...................................................d.....529 Wykorzystanie modułu Spread ...................................................d.................................535 Dalsze lektury ...................................................d...................................................d..............536 4QFKCđ 4QUGTCPKG2*2ōEúħè++  Implementacja klas ...................................................d...................................................d......537 Tworzenie nowej klasy ...................................................d.............................................538 Definiowanie właściwości klasy...................................................d...............................539 Dziedziczenie...................................................d...................................................d.........541 Definiowanie metod klasy ...................................................d........................................542 Definiowanie konstruktorów klas ...................................................d.............................544 Zgłaszanie wyjątków ...................................................d................................................545 Wykorzystanie obiektów zdefiniowanych przez użytkownika oraz prywatnych zmiennych ...................................................d..................................546 Wykorzystanie metod factory ...................................................d...................................549 Tworzenie i implementacja interfejsów ...................................................d....................550 D:PDFPHP. Zaawansowane programowanie. Vademecum profesjonalisty\__Spis treści.doc 11  12 PHP. Zaawansowane programowanie. Vademecum profesjonalisty Pisanie własnych procedur obsługi sesji ...................................................d.........................551 Interfejs API obsługi strumieni ...................................................d.......................................555 Dalsze lektury ...................................................d...................................................d..............565 4QFKCđ 6YQTGPKGOQFWđÎY5#2+QTCTQUGTCPKGOCU[P[ GPF Interfejsy SAPI ...................................................d...................................................d............567 CGI SAPI...................................................d...................................................d...............568 Interfejs Embed SAPI ...................................................d...............................................577 Filtry wejściowe interfejsu SAPI ...................................................d..............................578 Modyfikacja i introspekcja mechanizmu maszyny Zend ...................................................d583 Ostrzeżenia jako wyjątki...................................................d...........................................584 Program przetwarzający kod operacyjny ...................................................d..................586 APD ...................................................d...................................................d.......................589 APC ...................................................d...................................................d.......................590 Wykorzystanie wywołań rozszerzenia Zend...................................................d.............590 Praca domowa...................................................d...................................................d..............593 QFCVMKN 5MQTQYKF  Rozdział 9. 5VTQLGPKGY[FCLPQħEK GYPúVTPGL W każdym przypadku dostrajania nie można utracić obrazu całości systemu. O ile celem cząstkowym bywa przyspieszenie działania określonej funkcji lub strony, głównym celem zawsze jest przyspieszenie działania aplikacji jako całości. Czasami wykonanie zmian w jednym elemencie aplikacji przyczynia się do poprawy jej ogólnej wydajności. Największe znaczenie dla uzyskania wysokiej wydajności ma uważnie wykonany i solid- ny projekt oraz zastosowanie właściwych technik programistycznych. Nic tego nie zastąpi. Istnieją jednak techniki dostrajania na zewnątrz kodu PHP, które pozwalają na poprawę wydajności aplikacji. Zastosowanie technik na poziomie serwera lub języka nie zneutrali- zuje nieudolnego lub nieefektywnego kodowania, ale zapewni, że aplikacja będzie działała najlepiej, jak to możliwe. W niniejszym rozdziale zamieszczono przegląd kilku technik i produktów, które pozwa- lają na poprawę wydajności aplikacji. Ponieważ opisane techniki dotyczą wewnętrznych mechanizmów PHP albo też są to produkty zewnętrzne, w niniejszym rozdziale nie ma zbyt wiele kodu. Nie powinno to jednak zniechęcić czytelnika do lektury — czasami naj- większe korzyści uzyskuje się dzięki odpowiedniej kombinacji stosowanych technik. 6GEJPKMKFQUVTCLCPKCPCRQKQOKGLú[MC Techniki dostrajania na poziomie języka to modyfikacje poprawiające ogólną wydajność aplikacji, które można wykonać w konfiguracji PHP. Język PHP jest wyposażony w wy- godny interfejs programowy aplikacji (opisany szczegółowo w rozdziale 21. oraz w roz- dziale 23.) pozwalający na pisanie rozszerzeń mających bezpośredni wpływ na działa- nie mechanizmów języka i sposób wykonywania kodu. Zastosowanie tego interfejsu umożliwia przyspieszenie procesu kompilacji i wykonywania skryptów PHP. $WHQT[MQORKNCVQTC Gdyby można było wybrać tylko jedną modyfikację konfiguracji serwera, która miałaby przyczynić się do poprawienia wydajności aplikacji PHP, zainstalowanie bufora kom- pilatora byłoby najwłaściwszym wyborem. Zainstalowanie tego mechanizmu przynosi 224 Część II  Buforowanie olbrzymie korzyści. Dodatkowo, w odróżnieniu od innych technik, których efekty stoso- wania słabną w miarę zwiększania się rozmiarów aplikacji, w przypadku bufora kom- pilatora dla bardziej rozbudowanych i złożonych aplikacji efekty okazują się lepsze. Zatem, czym jest bufor kompilatora i jak to się dzieje, że jego zastosowanie umożliwia uzyskanie tak znacznego wzrostu wydajności? Aby odpowiedzieć na te pytania, spróbuj- my przyjrzeć się sposobowi wykonywania skryptów PHP przez maszynę Zend. Kiedy przeglądarka uruchamia skrypt PHP, wykonuje proces składający się z dwóch etapów:  Serwer PHP odczytuje plik, analizuje zapisany w nim kod i generuje kod pośredni przeznaczony do wykonywania na wirtualnej maszynie Zend. Kod pośredni to termin stosowany w informatyce, opisujący wewnętrzną reprezentację kodu źródłowego skryptu po jego skompilowaniu.  Serwer PHP wykonuje kod pośredni. W procesie tym należy zwrócić uwagę na kilka istotnych elementów:  w przypadku wielu skryptów (szczególnie takich, w których jest dużo instrukcji KPENWFG ) — więcej czasu zajmuje przeanalizowanie skryptu i jego przekształcenie na postać pośrednią niż samo wykonanie kodu;  nawet jeśli wyniki wykonania etapu 1. niewiele różnią się pomiędzy poszczególnymi wywołaniami skryptu, każde jego wywołanie powoduje wykonywanie opisanych wyżej dwóch etapów;  sekwencja dwóch etapów wykonywana jest nie tylko wtedy, kiedy wykonywany jest główny skrypt, ale także za każdym razem, kiedy skrypt jest wywoływany za pomocą poleceń TGSWKTG , KPENWFG lub GXCN . Jak łatwo wywnioskować z powyższego opisu, umieszczenie w buforze kodu pośred- niego uzyskanego w wyniku wykonania etapu 1. i wykorzystanie go do każdego wy- wołania skryptu może przynieść duże korzyści. Właśnie na tym polega działanie bufora kompilatora. Na rysunku 9.1 zilustrowano proces wykonywania skryptu bez wykorzystania bufora kom- pilatora, natomiast na rysunku 9.2 — z wykorzystaniem bufora. Warto zwrócić uwagę, że tylko pierwsze uruchomienie skryptu lub odwołanie się do niego w instrukcji KPENWFG powoduje konieczność tworzenia kodu pośredniego i jego umieszczania w buforze. W każ- dym kolejnym przypadku etap kompilacji skryptu jest pomijany całkowicie. Dla języka PHP istnieją trzy najbardziej popularne bufory kompilatorów:  Zend Accelerator — komercyjny bufor kompilatora bez dostępu do kodu źródłowego, produkowany przez firmę Zend Industries i rozprowadzany za opłatą;  ionCube Accelerator — komercyjny bufor kompilatora bez dostępu do kodu źródłowego, ale darmowy; napisany przez Nicka Lindridge’a i rozprowadzany przez jego firmę ionCube;  APC — darmowy bufor kompilatora typu open source, napisany przez Daniela Cowgilla i mnie. Rozdział 9.  Strojenie wydajności zewnętrznej 225 4[UWPGM Wykonywanie skryptu w PHP W rozdziale 23., w którym opisano rozszerzenia PHP i mechanizm maszyny Zend, szcze- gółowo omówiono także działanie bufora APC. Bufor kompilatora APC jest dostępny poprzez bibliotekę rozszerzeń PECL (skrót od ang. PEAR Extension Code Library). Bibliotekę tę instaluje się za pomocą następującego polecenia: RGCTKPUVCNNCRE Skonfigurowanie bufora wymaga dodania następującego wiersza w pliku php.ini: GZVGPUKQPħEKGľMCFQRNKMWCREUQ Oprócz tego nie trzeba wykonywać żadnych czynności konfiguracyjnych. Przy następnym uruchomieniu serwera PHP bufor APC będzie aktywny (będzie buforował skrypty we współdzielonej pamięci). Jak pamiętamy, bufor kompilatora umożliwia pominięcie fazy analizy kodu podczas wy- konywania skryptu, a zatem najlepsze efekty jego stosowania można uzyskać dla skryp- tów zawierających dużo kodu. Dla sprawdzenia różnicy porównałem przykładową stronę wykorzystującą szablony, rozprowadzaną z systemem Smarty. W przypadku standardowej konfiguracji PHP udało mi się uzyskać 26 żądań na sekundę. Po załadowaniu bufora APC uzyskałem 42 żądania na sekundę — 61 poprawy wydajności to znaczący zysk, zwłasz- cza, że efekt ten uzyskałem bez modyfikacji kodu. 226 Część II  Buforowanie 4[UWPGM Wykonywanie kodu z zastosowaniem bufora kompilatora Bufory kompilatorów pozwalają na uzyskanie największych korzyści w przypadku kodu, w którym występuje duża ilość instrukcji KPENWFG . Kiedy pracowałem w firmie Commu- nity Connect (tam, gdzie powstał bufor APC), zdarzało się, że w skrypcie było, uwzględ- niając wywołania rekurencyjne, 30, a nawet 40 wywołań tej instrukcji. Taka duża liczba plików dołączanych wynikała z modularnego układu zasadniczej części kodu, w której funkcje o podobnym przeznaczeniu były umieszczane w oddzielnych bibliotekach. W tam- tym środowisku zastosowanie bufora APC pozwoliło na uzyskanie ponad stuprocentowego wzrostu wydajności. 1RV[OCNKCVQT[ Działanie optymalizatorów kodu polega na przekształceniu skompilowanego pośrednie- go kodu skryptu i przeprowadzenie dla niego optymalizacji. W większości języków pro- gramowania istnieją optymalizatory wykonujące następujące działania:  Eliminacja „martwego” kodu — usuwanie instrukcji, do których nie ma dostępu, na przykład KH  ]_. Rozdział 9.  Strojenie wydajności zewnętrznej 227  Składanie stałych — przekształcanie kodu wykonującego operacje na grupie stałych w taki sposób, aby obliczenia były wykonywane raz w fazie kompilacji. Na przykład operację: UGEQPFUAKPAFC[   optymalizator przekształci wewnętrznie na instrukcję w postaci: UGEQPFUAKPAFC[ bez konieczności modyfikacji kodu.  Optymalizacja wewnętrznej struktury kodu — lokalne działania optymalizacyjne wykonywane w celu poprawy wydajności kodu (na przykład przekształcenie instrukcji EQWPV na EQWPV w przypadku, kiedy zwracana wartość występuje w kontekście void). Instrukcja EQWPV wykonuje inkrementację po obliczeniu wartości wyrażenia EQWPV. I tak na przykład wykonanie instrukcji KEQWPV powoduje ustawienie zmiennej K na wartość zmiennej EQWPV i późniejszą inkrementację zmiennej EQWPV. Oznacza to konieczność zapamiętania wartości zmiennej EQWPV do wykorzystania w wyrażeniach. W odróżnieniu od tej instrukcji EQWPV powoduje inkrementację przed obliczeniem wartości wyrażenia, a zatem nie trzeba zapamiętywać wartości (dzięki czemu instrukcja wykonuje się szybciej). Jeżeli instrukcja EQWPV jest wykorzystywana w wyrażeniu, w którym wartość zmiennej EQWPV nie jest wykorzystywana (co określa się jako kontekst void), można ją bezpiecznie przekształcić na instrukcję EQWPV. Optymalizatory można również wykorzystać do wielu innych zastosowań. W języku PHP nie ma wewnętrznego optymalizatora kodu, ale istnieją dodatki spełniające takie funkcje:  optymalizator Zend — bez dostępu do kodu źródłowego, ale darmowy;  wbudowany optymalizator akceleratora ionCube;  optymalizator typu proof-of-concept w bibliotece PEAR. Największe korzyści z zastosowania optymalizatorów kodu uzyskuje się w przypadku, kiedy kod jest kompilowany i optymalizowany raz, a potem uruchamiany wielokrotnie. Tak więc w języku PHP korzyści z zastosowania optymalizatora bez bufora kompilatora są minimalne. Optymalizator użyty w połączeniu z buforem kompilatora pozwala na uzy- skanie niewielkiej, ale zauważalnej poprawy w porównaniu z użyciem samego bufora kompilatora. #MEGNGTCVQT[*662 Wydajność aplikacji jest zagadnieniem złożonym. Składa się na nią wiele czynników, mię- dzy innymi:  wydajność bazy danych;  wydajność procesora — dla aplikacji, w której są wykonywane intensywne obliczenia; 228 Część II  Buforowanie  wydajność dysku — z uwagi na wykonywanie wielu operacji wejścia-wyjścia (we-wy);  wydajność sieci — dla aplikacji, w których są przesyłane duże ilości danych sieciowych. W kilku następnych rozdziałach zostaną opisane sposoby dostrajania aplikacji mające na celu zminimalizowanie efektów tych „wąskich gardeł”. Zanim jednak przejdziemy do omawiania tych tematów, zajmijmy się innym „wąskim gardłem”, którego się często nie dostrzega, a mianowicie opóźnieniami sieci. Kiedy użytkownik maszyny klienckiej żąda informacji z witryny, pakiety danych muszą być fizycznie przesłane w sieci internet od klienta do serwera i z powrotem. Co więcej — w systemie operacyjnym są ograniczenia ilości danych, jakie można jednorazowo przesyłać przez gniazdo TCP. W przypadku prze- kroczenia tego limitu aplikacja blokuje transfer danych lub po prostu czeka do chwili po- twierdzenia otrzymania danych przez system zdalny. Tak więc oprócz czasu poświęcone- go na przetwarzanie żądania serwer WWW, który je obsługuje, musi jeszcze oczekiwać przez czas opóźnienia spowodowany wolnym połączeniem sieciowym. Na rysunku 9.3 zilustrowano wykonywane w sieci działania związane z obsługą poje- dynczego żądania wraz z przykładowym czasem ich wykonywania. Podczas przesyłania pakietów pomiędzy serwerem a klientem w sieci aplikacja PHP jest zupełnie bezczynna. Zwróćmy uwagę, że w sytuacji pokazanej na rysunku 9.3 serwer PHP jest bezczynny przez 200 ms i oczekuje na zakończenie transmisji w sieci pomimo tego, że jest gotowy do obsługi żądania. W wielu aplikacjach czas opóźnień sieciowych jest większy od czasu wykonywania skryptów. Choć wydaje się, że bezczynność serwera nie jest wąskim gardłem, okazuje się, że również może nim być. Problem polega na tym, że nawet bezczynny serwer WWW zużywa za- soby: pamięć, trwałe połączenia z bazą danych oraz miejsce w tablicy procesów. Jeśli uda się wyeliminować opóźnienia w sieci, można zmniejszyć ilość czasu, w którym procesy serwera PHP wykonują nieistotne działania, i w ten sposób poprawić wydajność. Blokowanie połączeń sieciowych Określenie, że aplikacja musi zablokować połączenie sieciowe, nie jest do końca precyzyjne. Gniaz- da sieciowe można tworzyć w taki sposób, że zamiast blokowania sterowanie wraca do aplikacji. Metoda ta jest stosowana w wielu wysoko wydajnych serwerach WWW, takich, jak thttpd i Tux. Oprócz nich nie są mi znane interfejsy API serwera PHP (SAPI — aplikacje z wbudowanym serwe- rem PHP), które umożliwiają jednemu serwerowi PHP jednoczesną obsługę wielu żądań. Tak więc pomimo tego, że połączenie sieciowe nie blokuje aplikacji, nawet szybkie serwery wymagają de- dykowanego procesu PHP przez cały czas trwania obsługi żądania klienta. 1FYTQVPGUGTYGT[RTQZ[ Niestety, wyeliminowanie opóźnień sieciowych w internecie leży poza zakresem naszych możliwości (a szkoda). Można jednak zainstalować dodatkowy serwer pomiędzy użytkow- nikiem a aplikacją PHP, który będzie odbierał żądania od klientów, przekazywał kom- pletne żądania do aplikacji PHP, oczekiwał na odpowiedź, a następnie przesyłał ją do użytkownika zdalnego. Taki „wtrącony” serwer nazywa się odwrotnym serwerem proxy (ang. reverse proxy), a czasami akceleratorem HTTP. Rozdział 9.  Strojenie wydajności zewnętrznej 229 4[UWPGM Czasy transmisji sieciowej dla typowego żądania Zastosowanie takiej strategii wymaga spełnienia kilku warunków:  Serwer proxy nie może zużywać zbyt wielu zasobów. Dla jednego żądania klienta serwer proxy zużywa znacznie mniej zasobów niż aplikacja PHP.  Serwer proxy oraz aplikacja PHP muszą znajdować się w tej samej sieci lokalnej. Dzięki temu połączenie pomiędzy aplikacją, a serwerem wprowadza bardzo małe opóźnienie. Typową konfigurację odwrotnego serwera proxy pokazano na rysunku 9.4. Warto zwrócić uwagę, że zdalne klienty są podłączone do wolnych łącz (z dużymi opóźnieniami), na- tomiast serwer proxy i serwer WWW znajdują się w tej samej, szybkiej sieci. Zwróćmy również uwagę na to, że serwer proxy podtrzymuje znacznie więcej połączeń klienckich niż połączeń z serwerem WWW. Taka sytuacja jest spowodowana tym, że dzięki szyb- kiemu łączu pomiędzy serwerem WWW a serwerem proxy serwer WWW może obsługi- wać żądania na bieżąco i nie musi marnować czasu w oczekiwaniu na zakończenie trans- misji sieciowej. 230 Część II  Buforowanie 4[UWPGM Typowa konfiguracja odwrotnego serwera proxy W przypadku serwera Apache mamy do wyboru kilka doskonałych odwrotnych serwerów proxy, między innymi:   OQFARTQZ[ — standardowy moduł dostarczany wraz z serwerem Apache; OQFACEEGN — moduł produkowany przez firmę zewnętrzną, bardzo podobny do modułu mod_proxy (w dużej części wykorzystano w nim kod źródłowy modułu mod_proxy), oferujący dodatkowo funkcje specyficzne dla odwrotnych serwerów proxy;  OQFADCEMJCPF — moduł równoważenia obciążenia, produkowany przez firmę zewnętrzną, spełniający funkcję odwrotnego serwera proxy;  Squid — zewnętrzny demon serwera proxy oferujący wysoko wydajne funkcje zwykłego (działającego w trybie forward) i odwrotnego serwera proxy. We wszystkich wymienionych rozwiązaniach egzemplarz serwera proxy może działać na dedykowanym komputerze lub też jako oddzielny egzemplarz serwera na tym samym komputerze. Spróbujmy przeanalizować sposób konfiguracji odwrotnego serwera proxy działającego na tym samym komputerze z wykorzystaniem serwera mod_proxy. Naj- łatwiejszym sposobem wykonania takiej konfiguracji jest zainstalowanie dwóch kopii serwera Apache — jednej z wbudowanym modułem mod_proxy (zainstalowanym w ka- talogu /opt/apache_proxy) oraz drugiej z serwerem PHP (zainstalowanym w katalogu /opt/ apache_php). Rozdział 9.  Strojenie wydajności zewnętrznej 231 W tym celu wykorzystamy znaną sztuczkę umożliwiającą wykorzystanie tej samej konfi- guracji serwera Apache na wielu komputerach: w pliku konfiguracyjnym serwera Apache zdefiniujemy hosta o nazwie GZVGTPCNGVJGT. Następnie odwzorujemy go na publiczny (ze- wnętrzny) interfejs ethernetowy w pliku /etc/hosts. Podobnie zdefiniujemy hosta localhost w pliku konfiguracyjnym serwera, który będzie odwzorowywany na adres pętli zwrot- nej 127.0.0.1. Umieszczenie całej konfiguracji serwera Apache w niniejszym rozdziale zajęłoby zbyt dużo miejsca. Zamiast tego w celu pokazania najważniejszych ustawień zaprezentujemy zaledwie niewielki fragment pliku httpd.conf. Konfiguracja odwrotnego serwera proxy z wykorzystaniem modułu mod_proxy wymaga wprowadzenia następujących ustawień: QEWOGPV4QQVFGXPWNN .KUVGPGZVGTPCNGVJGT /CZ NKGPVU -GGR#NKXG1HH #FF/QFWNGOQFARTQZ[E 2TQZ[4GSWGUVU1P 2TQZ[2CUUJVVRNQECNJQUV 2TQZ[2CUU4GXGTUGJVVRNQECNJQUV 2TQZ[+1$WHHGT5KG  KTGEVQT[RTQZ[ 1TFGT GP[#NNQY  GP[HTQOCNN  KTGEVQT[ W przypadku pokazanej konfiguracji należy zwrócić uwagę na następujące elementy:  Katalog QEWOGPV4QQV jest ustawiony na /dev/null, ponieważ serwer nie posiada własnej zawartości.  W konfiguracji określono jawne dowiązanie do zewnętrznego adresu ethernetowego serwera (GZVGTPCNGVJGT). Powiązanie należy określić jawnie, ponieważ w przypadku tej konfiguracji na jednym komputerze działają dwa oddzielne egzemplarze serwera PHP. Bez instrukcji .KUVGP pierwszy serwer rozpoczynający działanie wiązałby wszystkie dostępne adresy, uniemożliwiając działanie drugiego egzemplarza.  Parametr -GGR#NKXG ustawiono na 1HH. Serwery WWW obsługujące duży ruch, w których stosuje się model pre-fork (np. Apache), lub (w mniejszym stopniu) takie, w których stosuje się modele wielowątkowe (np. Zeus), zazwyczaj działają mniej wydajnie przy ustawieniu parametru -GGR#NKXG na QP.  Parametr 2TQZ[4GSWGUVU ma wartość 1P, co uaktywnia moduł mod_proxy.  Instrukcja 2TQZ[2CUUJVVRNQECNJQUV powoduje, że moduł mod_proxy wewnętrznie pośredniczy w przekazywaniu żądań rozpoczynających się od znaku  (czyli wszystkich żądań) do serwera powiązanego z adresem IP hosta localhost (tzn. z serwerem PHP). 232 Część II  Buforowanie  Jeśli serwer PHP wyśle do skryptu foo.php żądanie przekierowania zawierające nazwę serwera, klient otrzyma to żądanie w następującej postaci: .QECVKQPJVVRNQECNJQUVHQQRJR W przypadku użytkownika zdalnego takie żądanie nie zadziała, a zatem zmienna 2TQZ[2CUU4GXGTUG przepisuje przeadresowania .QECVKQP w taki sposób, aby wskazywały na właściwego hosta.  Zapis 2TQZ[+1$WHHGT5KG powoduje ustawienie rozmiaru bufora wykorzystywanego przez odwrotny serwer proxy do zbierania informacji przekazywanych przez serwer PHP na 131072 bajty. Aby zapobiec blokowaniu serwera podczas komunikacji z przeglądarką, parametr ten należy ustawić na wartość równą co najmniej największemu rozmiarowi strony przesyłanej do użytkownika. Dzięki temu można przesłać całą stronę z serwera PHP do serwera proxy, zanim jakiekolwiek dane zostaną przesłane z powrotem do przeglądarki. W takim przypadku, podczas gdy serwer proxy obsługuje przesyłanie danych do przeglądarki klienckiej, serwer PHP może kontynuować działanie.  Na zakończenie należy wyłączyć wszystkie żądania proxy wychodzące do serwera. Ustawienie to zapobiega powstawaniu błędów typu open proxy. Architektury procesów: pre-fork, z obsługą zdarzeń oraz wielowątkowa Serwery WWW mogą działać w trzech różnych architekturach: w architekturze pre-fork, z obsługą zdarzeń i wielowątkowej. W modelu pre-fork istnieje pula procesów, których zadaniem jest obsługa nowych żądań. W przy- padku pojawienia się nowego żądania jego obsługę powierza się jednemu z procesów potomnych. Proces potomny zwykle obsługuje więcej niż jedno żądanie. Taki model zastosowano w wersji 1.3 serwera Apache. W modelu z obsługą z
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

PHP. Zaawansowane programowanie. Vademecum profesjonalisty
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ą: