Praktyczne zastosowania technologii,
która zrewolucjonizowała aplikacje sieciowe

• Podstawy Ajaksa
• Metodologie tworzenia aplikacji internetowych
• Optymalizacja i zabezpieczanie aplikacji

• Podstawowe zastosowania Ajaksa
• Dostosowywanie istniejących aplikacji do Ajaksa
• Wzorzec MVC w aplikacjach
• Biblioteki i frameworki wspomagające pracę nad aplikacjami
• Oddzielanie logiki od widoku
• Wymiana danych pomiędzy przeglądarką i serwerem
• Zabezpieczanie aplikacji
• Optymalizacja wydajności

Spis treści:

Przedmowa (13)

Podziękowania (15)

O książce (19)

Część I Reorganizacja pojęcia aplikacji internetowej (27)

1. Nowe projektowanie dla serwisów internetowych (29)

• 1.1. Dlaczego mówi się o wzbogaconych klientach ajaksowych? (30)
  
  • 1.1.1. Porównanie odczuć użytkowników (31)
  • 1.1.2. Opóźnienia sieci (35)
  • 1.1.3. Interakcje asynchroniczne (37)
  • 1.1.4. Długotrwałe i chwilowe wzorce użytkowania (40)
  • 1.1.5. "Oduczanie się" internetu (41)
• 1.2. Cztery zasady definiujące Ajaksa (42)
  
  • 1.2.1. Przeglądarka przechowuje aplikację, nie zawartość (42)
  • 1.2.2. Serwer dostarcza dane, nie zawartość (44)
  • 1.2.3. Interakcja użytkownika z aplikacją może być płynna i ciągła (46)
  • 1.2.4. To jest prawdziwe pisanie programów i wymaga dyscypliny (47)
• 1.3. Wzbogacone klienty ajaksowe w rzeczywistym świecie (48)
  
  • 1.3.1. Badanie terenu (48)
  • 1.3.2. Google Maps (49)
• 1.4. Alternatywy dla Ajaksa (52)
  
  • 1.4.1. Rozwiązania oparte na Macromedia Flash (52)
  • 1.4.2. Java Web Start i związane z nią technologie (53)
• 1.5. Podsumowanie (53)
  
• 1.6. Zasoby (54)

2. Pierwsze kroki z Ajaksem (55)

• 2.1. Kluczowe elementy Ajaksa (56)
  
• 2.2. Sprawianie dobrego wrażenia na użytkownikach za pomocą JavaScriptu (58)
  
• 2.3. Definiowanie wyglądu i zachowania przy użyciu CSS (59)
  
  • 2.3.1. Selektory CSS (60)
  • 2.3.2. Właściwości stylów CSS (62)
  • 2.3.3. Prosty przykład CSS (63)
• 2.4. Organizowanie widoku za pomocą DOM (68)
  
  • 2.4.1. Praca z DOM przy użyciu JavaScriptu (70)
  • 2.4.2. Znajdowanie węzła DOM (72)
  • 2.4.3. Tworzenie węzła DOM (73)
  • 2.4.4. Dodawanie stylów do dokumentu (74)
  • 2.4.5. Droga na skróty: użycie właściwości innerHTML (75)
• 2.5. Asynchroniczne ładowanie danych przy użyciu technologii XML (76)
  
  • 2.5.1. (77)
  • 2.5.2. Obiekty XmlDocument i XMLHttpRequest (79)
  • 2.5.3. Wysyłanie żądań do serwera (81)
  • 2.5.4. Używanie funkcji zwrotnych do monitorowania żądania (83)
  • 2.5.5. Pełny cykl życia (84)
• 2.6. Czym wyróżnia się Ajax? (87)
  
• 2.7. Podsumowanie (89)
  
• 2.8. Zasoby (90)

3. Porządkowanie aplikacji wykorzystujących technologię Ajax (91)

• 3.1. Porządkowanie chaosu (93)
  
  • 3.1.1. Wzorce: tworzenie wspólnego słownictwa (93)
  • 3.1.2. Refaktoryzacja a Ajax (94)
  • 3.1.3. Zachowanie właściwych proporcji (95)
  • 3.1.4. Refaktoryzacja w działaniu (96)
• 3.2. Niewielkie przykłady refaktoryzacji (99)
  
  • 3.2.1. Niezgodności przeglądarek: wzorce FaĂParagrafade oraz Adapter (99)
  • 3.2.2. Zarządzanie procedurami obsługi zdarzeń: wzorzec Observer (103)
  • 3.2.3. Wielokrotne stosowanie funkcji obsługujących działania użytkownika: wzorzec Command (107)
  • 3.2.4. Przechowywanie tylko jednej referencji do zasobu: wzorzec Singleton (110)
• 3.3. Model-View-Controller (114)
  
• 3.4. Wzorzec MVC stosowany na serwerze (117)
  
  • 3.4.1. Serwerowa część aplikacji tworzona bez użycia wzorców (117)
  • 3.4.2. Refaktoryzacja modelu dziedziny (121)
  • 3.4.3. Separacja zawartości od prezentacji (124)
• 3.5. Biblioteki i frameworki (128)
  
  • 3.5.1. Biblioteki zapewniające poprawne działanie skryptów w różnych przeglądarkach (128)
  • 3.5.2. Kontrolki oraz bazujące na nich szkielety (133)
  • 3.5.3. Frameworki aplikacji (136)
• 3.6. Podsumowanie (140)
  
• 3.7. Zasoby (142)

Część II Podstawowe techniki (143)

4. Strona WWW jako aplikacja (145)

• 4.1. Inny rodzaj wzorca MVC (146)
  
  • 4.1.1. Powielanie wzorca w różnych skalach (146)
  • 4.1.2. Stosowanie wzorca MVC w przeglądarce (147)
• 4.2. Widoki w aplikacjach Ajax (150)
  
  • 4.2.1. Oddzielanie logiki od widoku (150)
  • 4.2.2. Oddzielanie widoku od logiki (156)
• 4.3. Kontroler w aplikacjach wykorzystujących technologię Ajax (160)
  
  • 4.3.1. Klasyczne procedury obsługi zdarzeń (160)
  • 4.3.2. Model obsługi zdarzeń W3C (164)
  • 4.3.3. Implementacja elastycznego modelu obsługi zdarzeń w języku JavaScript (165)
• 4.4. Model w aplikacjach wykorzystujących technologię Ajax (170)
  
  • 4.4.1. Zastosowanie JavaScriptu do stworzenia modelu dziedziny biznesowej (171)
  • 4.4.2. Wymiana danych z serwerem (173)
• 4.5. Generacja widoku na podstawie modelu (175)
  
  • 4.5.1. Refleksja obiektów JavaScript (175)
  • 4.5.2. Obsługa tablic i obiektów (179)
  • 4.5.3. Dodawanie kontrolera (182)
• 4.6. Podsumowanie (185)
  
• 4.7. Zasoby (186)

5. Rola serwera (187)

• 5.1. Współpraca z aplikacjami działającymi na serwerze (188)
  
• 5.2. Tworzenie aplikacji działającej po stronie serwera (189)
  
  • 5.2.1. Najczęściej stosowane języki programowania (189)
  • 5.2.2. Architektury n-warstwowe (190)
  • 5.2.3. Utrzymanie modeli dziedziny po stronie klienta i serwera (191)
• 5.3. Postać ogólna: najczęściej stosowane projekty aplikacji wykonywanych na serwerze (193)
  
  • 5.3.1. Naiwne tworzenie kodu działającego na serwerze bez stosowania żadnego frameworka (193)
  • 5.3.2. Korzystanie z frameworków Model2 (195)
  • 5.3.3. Frameworki bazujące na komponentach (196)
  • 5.3.4. Stosowanie architektur bazujących na usługach (199)
• 5.4. Informacje szczegółowe: wymiana danych (204)
  
  • 5.4.1. Interakcje klienckie (205)
  • 5.4.2. Prezentacja przykładowej aplikacji przeglądarki planet (205)
  • 5.4.3. Myśl jak strona WWW - interakcje operujące na zawartości (208)
  • 5.4.4. Myśl jak plugin - interakcje operujące na skryptach (212)
  • 5.4.5. Myśl jak aplikacja - interakcje operujące na danych (218)
• 5.5. Przekazywanie danych na serwer (223)
  
  • 5.5.1. Stosowanie formularzy HTML (224)
  • 5.5.2. Stosowanie obiektu XMLHttpRequest (226)
  • 5.5.3. Efektywna obsługa aktualizacji danych (227)
• 5.6. Podsumowanie (236)
  
• 5.7. Zasoby (237)

Część III Profesjonalny Ajax (239)

6. Wrażenia użytkownika (241)

• 6.1. Róbmy to dobrze - pisanie dobrych aplikacji (242)
  
  • 6.1.1. Łatwość i szybkość reakcji (243)
  • 6.1.2. Solidność (244)
  • 6.1.3. Konsekwencja (244)
  • 6.1.4. Prostota (245)
  • 6.1.5. Zapewnienie działania (246)
• 6.2. Informowanie użytkownika (246)
  
  • 6.2.1. Obsługa odpowiedzi na nasze żądania (247)
  • 6.2.2. Obsługa modyfikacji wprowadzanych przez inne osoby (248)
• 6.3. Projektowanie systemu powiadomień dla aplikacji Ajax (253)
  
  • 6.3.1. Modelowanie powiadomień (254)
  • 6.3.2. Definiowanie wymagań interfejsu (256)
• 6.4. Implementacja frameworka do obsługi powiadomień (257)
  
  • 6.4.1. Prezentacja ikony na pasku stanu (257)
  • 6.4.2. Prezentacja szczegółów powiadomienia (260)
  • 6.4.3. Scalanie poszczególnych elementów systemu (261)
• 6.5. Zastosowanie frameworka podczas obsługi żądań sieciowych (267)
  
• 6.6. Sygnalizacja aktualności danych (271)
  
  • 6.6.1. Zdefiniowanie prostego sposobu wyróżniania (272)
  • 6.6.2. Wyróżnianie przy użyciu biblioteki efektów Scriptaculous (274)
• 6.7. Podsumowanie (275)
  
• 6.8. Zasoby (275)

7. Bezpieczeństwo a Ajax (277)

• 7.1. Bezpieczeństwo języka JavaScript i przeglądarki (278)
  
  • 7.1.1. Wprowadzanie polityki "serwera pochodzenia" (279)
  • 7.1.2. Problemy do rozważenia w aplikacjach Ajax (280)
  • 7.1.3. Problemy z poddomenami (280)
  • 7.1.4. Bezpieczeństwo w różnych przeglądarkach (281)
• 7.2. Komunikacja ze zdalnymi usługami (283)
  
  • 7.2.1. Pośredniczenie w korzystaniu ze zdalnych usług (283)
  • 7.2.2. Korzystanie z usług WWW (284)
• 7.3. Ochrona poufnych danych (295)
  
  • 7.3.1. Atak "man in the middle" (295)
  • 7.3.2. Stosowanie bezpiecznego protokołu HTTP (296)
  • 7.3.3. Użycie JavaScriptu do szyfrowania danych przesyłanych protokołem HTTP (297)
• 7.4. Zabezpieczanie transmisji danych w aplikacjach wykorzystujących technologię Ajax (300)
  
  • 7.4.1. Projektowanie bezpiecznej warstwy internetowej (301)
  • 7.4.2. Ograniczanie dostępu do danych (305)
• 7.5. Podsumowanie (310)
  
• 7.6. Zasoby (310)

8. Wydajność (313)

• 8.1. Czym jest wydajność? (314)
  
• 8.2. Szybkość wykonywania kodu JavaScript (315)
  
  • 8.2.1. Profilowanie aplikacji w najprostszy możliwy sposób (316)
  • 8.2.2. Użycie programu profilującego Venkman (322)
  • 8.2.3. Optymalizacja szybkości wykonywania kodu JavaScript (324)
• 8.3. Wymagania pamięciowe kodu JavaScript (336)
  
  • 8.3.1. Zapobieganie "wyciekom" pamięci (337)
  • 8.3.2. Zagadnienia odnoszące się do technologii Ajax (341)
• 8.4. Projektowanie pod kątem wydajności (346)
  
  • 8.4.1. Mierzenie zajętości pamięci (346)
  • 8.4.2. Prosty przykład (351)
  • 8.4.3. Wyniki: jak 150-krotnie zmniejszyć zużycie pamięci? (355)
• 8.5. Podsumowanie (358)
  
• 8.6. Zasoby (358)

Część IV Ajax w przykładach (361)

9. Podwójna dynamiczna lista rozwijalna (363)

• 9.1. Skrypt podwójnej listy rozwijalnej (364)
  
  • 9.1.1. Ograniczenia rozwiązania działającego po stronie klienta (364)
  • 9.1.2. Ograniczenia rozwiązania działającego po stronie serwera (365)
  • 9.1.3. Rozwiązanie wykorzystujące Ajaksa (366)
• 9.2. Architektura warstwy klienta (367)
  
  • 9.2.1. Projektowanie formularza (368)
  • 9.2.2. Projektowanie interakcji klient-serwer (369)
• 9.3. Implementacja serwera - VB.NET (371)
  
  • 9.3.1. Definiowanie formatu odpowiedzi XML (372)
  • 9.3.2. Pisanie kodu wykonywanego na serwerze (372)
• 9.4. Przetwarzanie wyników (375)
  
  • 9.4.1. Przeglądanie dokumentu XML (376)
  • 9.4.2. Zastosowanie kaskadowych arkuszy stylów (378)
• 9.5. Zagadnienia zaawansowane (379)
  
  • 9.5.1. Zapewnienie możliwości wyboru większej ilości opcji (380)
  • 9.5.2. Zamiana listy podwójnej na potrójną (381)
• 9.6. Refaktoring (382)
  
  • 9.6.1. Nowy i poprawiony komponent net.ContentLoader (383)
  • 9.6.2. Tworzenie komponentu podwójnej listy rozwijalnej (389)
• 9.7. Podsumowanie (396)

10. Sugestie prezentowane podczas wpisywania (399)

• 10.1. Zastosowania i cechy mechanizmu prezentacji sugestii (400)
  
  • 10.1.1. Cechy mechanizmów prezentacji sugestii (400)
  • 10.1.2. Google Suggest (402)
  • 10.1.3. Autorski mechanizm prezentowania sugestii (403)
• 10.2. Skrypt wykonywany na serwerze - C# (404)
  
  • 10.2.1. Serwer oraz baza danych (404)
  • 10.2.2. Testowanie kodu wykonywanego na serwerze (407)
• 10.3. Framework działający po stronie klienta (408)
  
  • 10.3.1. HTML (408)
  • 10.3.2. JavaScript (409)
  • 10.3.3. Pobieranie danych z serwera (419)
• 10.4. Rozbudowa możliwości funkcjonalnych: więcej elementów używających różnych zapytań (431)
  
• 10.5. Refaktoring (432)
  
  • 10.5.1. Dzień 1. Określenie planu prac nad komponentem TextSuggest (433)
  • 10.5.2. Dzień 2. Tworzenie komponentu TextSuggest - "eleganckiego" i konfigurowalnego (437)
  • 10.5.3. Dzień 3. Zastosowanie Ajaksa (441)
  • 10.5.4. Dzień 4. Obsługa zdarzeń (446)
  • 10.5.5. Dzień 5. Interfejs użytkownika listy sugestii (453)
  • 10.5.6. Podsumowanie prac nad komponentem (462)
• 10.6. Podsumowanie (462)

11. Rozbudowany portal wykorzystujący Ajaksa (463)

• 11.1. Ewolucja portali (464)
  
  • 11.1.1. Klasyczne portale (465)
  • 11.1.2. Portale o zaawansowanym interfejsie użytkownika (465)
• 11.2. Architektura portalu używającego Ajaksa i Javy (467)
  
• 11.3. Logowanie wykorzystujące Ajaksa (469)
  
  • 11.3.1. Tabela użytkowników (470)
  • 11.3.2. Kod obsługujący logowanie na serwerze: Java (471)
  • 11.3.3. Mechanizm logowania działający po stronie klienta (474)
• 11.4. Implementacja okien DHTML (480)
  
  • 11.4.1. Baza danych okien (480)
  • 11.4.2. Kod obsługi okien działający na serwerze (482)
  • 11.4.3. Dodawanie zewnętrznej biblioteki JavaScript (486)
• 11.5. Implementacja automatycznego zapisu właściwości (489)
  
  • 11.5.1. Dostosowanie biblioteki (489)
  • 11.5.2. Automatyczny zapis informacji w bazie danych (491)
• 11.6. Refaktoring (494)
  
  • 11.6.1. Definiowanie konstruktora (497)
  • 11.6.2. Dostosowanie biblioteki AjaxWindows.js (497)
  • 11.6.3. Określanie poleceń obsługiwanych przez portal (500)
  • 11.6.4. Wykorzystanie technologii Ajax (504)
  • 11.6.5. Podsumowanie prac nad komponentem (505)
• 11.7. Podsumowanie (506)

12. Dynamiczne wyszukiwanie przy użyciu XSLT (507)

• 12.1. Analiza technik wyszukiwania (508)
  
  • 12.1.1. Klasyczne rozwiązania wyszukiwania (509)
  • 12.1.2. Wady metody wykorzystującej ramki i wyskakujące okienka (510)
  • 12.1.3. Analiza dynamicznego wyszukiwania przy użyciu technologii Ajax i XSLT (512)
  • 12.1.4. Przesyłanie wyników do klienta (513)
• 12.2. Kod klienta (514)
  
  • 12.2.1. Konfiguracja klienta (515)
  • 12.2.2. Rozpoczęcie procesu (516)
• 12.3. Kod działający na serwerze - PHP (518)
  
  • 12.3.1. Generacja dokumentu XML (518)
  • 12.3.2. Tworzenie dokumentu XSLT (521)
• 12.4. Łączenie dokumentów XML i XSLT (523)
  
  • 12.4.1. Przekształcenia XSLT w Internet Explorerze (525)
  • 12.4.2. Przekształcenia XSLT w przeglądarkach Mozilla i Firefox (526)
• 12.5. Dopracowanie wyszukiwania (527)
  
  • 12.5.1. Zastosowanie CSS (528)
  • 12.5.2. Usprawnianie wyszukiwania (529)
  • 12.5.3. Podejmowanie decyzji o zastosowaniu XSLT (531)
  • 12.5.4. Rozwiązanie problemu zakładek (533)
• 12.6. Refaktoring (534)
  
  • 12.6.1. XSLTHelper (535)
  • 12.6.2. Komponent dynamicznego wyszukiwania (539)
  • 12.6.3. Podsumowanie prac nad komponentem (544)
• 12.7. Podsumowanie (544)

13. Tworzenie niezależnych aplikacji wykorzystujących technologię Ajax (547)

• 13.1. Odczytywanie informacji ze świata (548)
  
  • 13.1.1. Poszukiwanie kanałów XML (549)
  • 13.1.2. Struktura formatu RSS (550)
• 13.2. Tworzenie bogatego interfejsu użytkownika (553)
  
  • 13.2.1. Proces (554)
  • 13.2.2. Strona HTML bez tabel (555)
  • 13.2.3. Formatowanie przy użyciu CSS (557)
• 13.3. Pobieranie zawartości kanałów RSS (563)
  
  • 13.3.1. Zasięg globalny (563)
  • 13.3.2. Wczytywanie danych (565)
• 13.4. Utworzenie wizualnego efektu przejścia (569)
  
  • 13.4.1. Nieprzezroczystość w różnych przeglądarkach (569)
  • 13.4.2. Implementacja efektu przejścia (570)
  • 13.4.3. Zastosowanie liczników czasu (572)
• 13.5. Dodatkowe możliwości (574)
  
  • 13.5.1. Dodawanie kolejnych kanałów (575)
  • 13.5.2. Implementacja możliwości przechodzenia do innych artykułów i wstrzymywania czytnika (577)
• 13.6. Unikanie ograniczeń projektu (579)
  
  • 13.6.1. Problemy z systemem zabezpieczeń przeglądarek fundacji Mozilla (580)
  • 13.6.2. Zmiana zakresu aplikacji (583)
• 13.7. Refaktoring (584)
  
  • 13.7.1. Model używany w czytniku RSS (584)
  • 13.7.2. Widok stosowany w czytniku RSS (587)
  • 13.7.3. Kontroler czytnika RSS (591)
  • 13.7.4. Podsumowanie wprowadzonych zmian (605)
• 13.8. Podsumowanie (605)

Część V Dodatki (607)

A Przybornik programisty aplikacji Ajax (609)

B JavaScript dla programistów obiektowych (639)

C Frameworki i biblioteki ułatwiające stosowanie technologii Ajax (671)

Skorowidz (691)