ajax w akcji full scan.pdf

(30255 KB) Pobierz
887620754.001.png
6
Spis treści
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
Spis treści
7
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
 
8
Spis treści
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
Spis treści
9
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
 

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin