Ajax w akcji

Autorzy:

Szczegóły książki w Helionie
Tytuł oryginału: Ajax in Action
ISBN: 978-83-246-0495-1
Cena: 89 zł
Zniżka: 10%
Cena ze zniżką: 80.1 zł
Oprawa: miękka
Format: B5
Data wydania: 2007.02.28
Liczba stron: 712
Przykładowy rozdział: ftp://ftp.helion.pl/online/ajaakc/ajaakc-3.pdf
Kategoria: Ajax

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

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

Ajax to technologia tworzenia aplikacji i witryn WWW, która zyskuje coraz większe uznanie wśród programistów. Dzięki połączeniu języków JavaScript i XML z asynchroniczną komunikacją między przeglądarką i serwerem twórcom tej technologii udało się wyeliminować podstawową wadę aplikacji bazujących na przeglądarce internetowej, czyli konieczność oczekiwania na "przeładowanie" strony. Ajax sprawia, że niezbędne dane są pobierane w tle. Zastosowanie tej technologii powoduje, że aplikacje sieciowe pod względem obsługi coraz bardziej przypominają tradycyjne programy. Efekty działania Ajaksa można zaobserwować na coraz większej ilości witryn WWW.

"Ajax w akcji" to praktyczny przewodnik po zagadnieniach związanych z projektowaniem witryn i aplikacji WWW w tej technologii. Czytając go, poznasz genezę Ajaksa i podstawy korzystania z niego. Nauczysz się stosować wzorce projektowe, model MVC oraz frameworki i biblioteki wspomagające tworzenie witryn WWW. Przeczytasz o profesjonalnych technikach budowania aplikacji sieciowych i zastosujesz je w praktyce, pisząc własne systemy. Znajdziesz tu również informacje o optymalizowaniu wydajności aplikacji oraz tworzeniu mechanizmów zabezpieczeń. Dzięki przykładom zgromadzonym w kolejnych rozdziałach książki, takim jak dynamiczna lista rozwijana, mechanizm podpowiedzi, rozbudowany portal sieciowy oraz interfejsy użytkownika, poznasz praktyczne aspekty stosowania Ajaksa w projektach.

  • 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

Twórz aplikacje, które będą nie tylko funkcjonalne,
ale również wygodne w obsłudze.

Ajax w akcji -- 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. <iframe> (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çade 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)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań